Пример #1
0
  // default constructor
  public PiFaceBase(byte spiAddress, SpiChannel spiChannel) throws IOException {

    // create Pi-Face GPIO provider
    gpioProvider = new PiFaceGpioProvider(spiAddress, spiChannel);

    // provision gpio input pins for the Pi-Face board
    inputPins =
        new GpioPinDigitalInput[] {
          gpio.provisionDigitalInputPin(gpioProvider, PiFacePin.INPUT_00),
          gpio.provisionDigitalInputPin(gpioProvider, PiFacePin.INPUT_01),
          gpio.provisionDigitalInputPin(gpioProvider, PiFacePin.INPUT_02),
          gpio.provisionDigitalInputPin(gpioProvider, PiFacePin.INPUT_03),
          gpio.provisionDigitalInputPin(gpioProvider, PiFacePin.INPUT_04),
          gpio.provisionDigitalInputPin(gpioProvider, PiFacePin.INPUT_05),
          gpio.provisionDigitalInputPin(gpioProvider, PiFacePin.INPUT_06),
          gpio.provisionDigitalInputPin(gpioProvider, PiFacePin.INPUT_07)
        };

    // provision gpio output pins for the Pi-Face board
    outputPins =
        new GpioPinDigitalOutput[] {
          gpio.provisionDigitalOutputPin(gpioProvider, PiFacePin.OUTPUT_00),
          gpio.provisionDigitalOutputPin(gpioProvider, PiFacePin.OUTPUT_01),
          gpio.provisionDigitalOutputPin(gpioProvider, PiFacePin.OUTPUT_02),
          gpio.provisionDigitalOutputPin(gpioProvider, PiFacePin.OUTPUT_03),
          gpio.provisionDigitalOutputPin(gpioProvider, PiFacePin.OUTPUT_04),
          gpio.provisionDigitalOutputPin(gpioProvider, PiFacePin.OUTPUT_05),
          gpio.provisionDigitalOutputPin(gpioProvider, PiFacePin.OUTPUT_06),
          gpio.provisionDigitalOutputPin(gpioProvider, PiFacePin.OUTPUT_07)
        };

    // create relay components for the first two output pins on the Pi-Face board
    relays =
        new Relay[] {new GpioRelayComponent(outputPins[0]), new GpioRelayComponent(outputPins[1])};

    // create switch components for the first four input pins on the Pi-Face board
    switches =
        new Switch[] {
          new GpioSwitchComponent(inputPins[0], PinState.HIGH, PinState.LOW),
          new GpioSwitchComponent(inputPins[1], PinState.HIGH, PinState.LOW),
          new GpioSwitchComponent(inputPins[2], PinState.HIGH, PinState.LOW),
          new GpioSwitchComponent(inputPins[3], PinState.HIGH, PinState.LOW)
        };

    // create LED components for the eight output pins on the Pi-Face board
    leds =
        new LED[] {
          new GpioLEDComponent(outputPins[0]),
          new GpioLEDComponent(outputPins[1]),
          new GpioLEDComponent(outputPins[2]),
          new GpioLEDComponent(outputPins[3]),
          new GpioLEDComponent(outputPins[4]),
          new GpioLEDComponent(outputPins[5]),
          new GpioLEDComponent(outputPins[6]),
          new GpioLEDComponent(outputPins[7])
        };
  }
Пример #2
0
  public static void main(String[] args) throws InterruptedException {

    System.out.println("<--Pi4J--> GPIO Trigger Example ... started.");

    // create gpio controller
    final GpioController gpio = GpioFactory.getInstance();

    // provision gpio pin #02 as an input pin with its internal pull down resistor enabled
    final GpioPinDigitalInput myButton =
        gpio.provisionDigitalInputPin(RaspiPin.GPIO_02, PinPullResistance.PULL_DOWN);

    System.out.println(" ... complete the GPIO #02 circuit and see the triggers take effect.");

    // setup gpio pins #04, #05, #06 as an output pins and make sure they are all LOW at startup
    GpioPinDigitalOutput myLed[] = {
      gpio.provisionDigitalOutputPin(RaspiPin.GPIO_04, "LED #1", PinState.LOW),
      gpio.provisionDigitalOutputPin(RaspiPin.GPIO_05, "LED #2", PinState.LOW),
      gpio.provisionDigitalOutputPin(RaspiPin.GPIO_06, "LED #3", PinState.LOW)
    };

    // create a gpio control trigger on the input pin ; when the input goes HIGH, also set gpio pin
    // #04 to HIGH
    myButton.addTrigger(new GpioSetStateTrigger(PinState.HIGH, myLed[0], PinState.HIGH));

    // create a gpio control trigger on the input pin ; when the input goes LOW, also set gpio pin
    // #04 to LOW
    myButton.addTrigger(new GpioSetStateTrigger(PinState.LOW, myLed[0], PinState.LOW));

    // create a gpio synchronization trigger on the input pin; when the input changes, also set gpio
    // pin #05 to same state
    myButton.addTrigger(new GpioSyncStateTrigger(myLed[1]));

    // create a gpio pulse trigger on the input pin; when the input goes HIGH, also pulse gpio pin
    // #06 to the HIGH state for 1 second
    myButton.addTrigger(new GpioPulseStateTrigger(PinState.HIGH, myLed[2], 1000));

    // create a gpio callback trigger on gpio pin#4; when #4 changes state, perform a callback
    // invocation on the user defined 'Callable' class instance
    myButton.addTrigger(
        new GpioCallbackTrigger(
            new Callable<Void>() {
              public Void call() throws Exception {
                System.out.println(" --> GPIO TRIGGER CALLBACK RECEIVED ");
                return null;
              }
            }));

    // keep program running until user aborts (CTRL-C)
    for (; ; ) {
      Thread.sleep(500);
    }

    // stop all GPIO activity/threads by shutting down the GPIO controller
    // (this method will forcefully shutdown all GPIO monitoring threads and scheduled tasks)
    // gpio.shutdown();   <--- implement this method call if you wish to terminate the Pi4J GPIO
    // controller
  }
Пример #3
0
 private void provisionPins() {
   System.out.println(gpio.toString());
   dataIn =
       gpio.provisionDigitalOutputPin(
           new PinImpl(
               "RaspberryPi GPIO Provider",
               pins[0],
               "Pin1",
               EnumSet.of(PinMode.DIGITAL_INPUT, PinMode.DIGITAL_OUTPUT),
               PinPullResistance.all()),
           "MyLED",
           PinState.LOW);
   outputEnable =
       gpio.provisionDigitalOutputPin(
           new PinImpl(
               "RaspberryPi GPIO Provider",
               pins[1],
               "Pin4",
               EnumSet.of(PinMode.DIGITAL_INPUT, PinMode.DIGITAL_OUTPUT),
               PinPullResistance.all()),
           "MyLED",
           PinState.LOW);
   latch =
       gpio.provisionDigitalOutputPin(
           new PinImpl(
               "RaspberryPi GPIO Provider",
               pins[2],
               "Pin5",
               EnumSet.of(PinMode.DIGITAL_INPUT, PinMode.DIGITAL_OUTPUT),
               PinPullResistance.all()),
           "MyLED",
           PinState.LOW);
   clear =
       gpio.provisionDigitalOutputPin(
           new PinImpl(
               "RaspberryPi GPIO Provider",
               pins[3],
               "Pin3",
               EnumSet.of(PinMode.DIGITAL_INPUT, PinMode.DIGITAL_OUTPUT),
               PinPullResistance.all()),
           "MyLED",
           PinState.HIGH);
   clock =
       gpio.provisionDigitalOutputPin(
           new PinImpl(
               "RaspberryPi GPIO Provider",
               pins[4],
               "Pin2",
               EnumSet.of(PinMode.DIGITAL_INPUT, PinMode.DIGITAL_OUTPUT),
               PinPullResistance.all()),
           "MyLED",
           PinState.LOW);
 }
Пример #4
0
  public static void main(String[] args) throws InterruptedException {
    System.out.println("works");
    GpioController gpio = GpioFactory.getInstance();
    GpioPinDigitalOutput pin1 =
        gpio.provisionDigitalOutputPin(RaspiPin.GPIO_01, "MyLed", PinState.HIGH);
    pin1.setShutdownOptions(true, PinState.LOW);

    Thread.sleep(5000);
    System.out.println("pin low");
    pin1.low();

    Thread.sleep(5000);
    System.out.println("pin toggle");
    pin1.toggle();

    Thread.sleep(5000);
    System.out.println("pin pulse");
    pin1.pulse(1000, true);

    Thread.sleep(2000);
    System.out.println("pin blink");
    pin1.blink(500, 5000);

    Thread.sleep(2000);
    System.out.println("koniec");
    gpio.shutdown();
  }
Пример #5
0
  public static void main(String[] args) throws InterruptedException {

    System.out.println("<--Pi4J--> GPIO Cylon Example ... started.");

    // create gpio controller
    final GpioController gpio = GpioFactory.getInstance();

    // provision gpio pin #01 as an output pin and turn on
    final GpioPinDigitalOutput[] pins = {
      gpio.provisionDigitalOutputPin(RaspiPin.GPIO_00, PinState.LOW),
      gpio.provisionDigitalOutputPin(RaspiPin.GPIO_01, PinState.LOW),
      gpio.provisionDigitalOutputPin(RaspiPin.GPIO_02, PinState.LOW),
      gpio.provisionDigitalOutputPin(RaspiPin.GPIO_03, PinState.LOW),
      gpio.provisionDigitalOutputPin(RaspiPin.GPIO_04, PinState.LOW),
      gpio.provisionDigitalOutputPin(RaspiPin.GPIO_05, PinState.LOW),
      gpio.provisionDigitalOutputPin(RaspiPin.GPIO_06, PinState.LOW),
      gpio.provisionDigitalOutputPin(RaspiPin.GPIO_07, PinState.LOW)
    };
    System.out.println("--> GPIO state should be: ON");

    // set shutdown options on all pins
    gpio.setShutdownOptions(true, PinState.LOW, pins);

    // infinite loop
    while (true) {

      for (int index = 0; index <= 6; index++) {
        pins[index].pulse(50);
        Thread.sleep(50);
      }

      for (int index = 6; index >= 0; index--) {
        pins[index].pulse(50);
        Thread.sleep(50);
      }
    }

    // stop all GPIO activity/threads by shutting down the GPIO controller
    // (this method will forcefully shutdown all GPIO monitoring threads and scheduled tasks)
    // gpio.shutdown();   <--- implement this method call if you wish to terminate the Pi4J GPIO
    // controller
  }
Пример #6
0
  @Before
  public void setup() {
    // create a mock gpio provider and controller
    provider = MockGpioFactory.getMockProvider();
    gpio = MockGpioFactory.getInstance();

    // provision pins for testing
    inputPin = gpio.provisionDigitalInputPin(MockPin.DIGITAL_INPUT_PIN, "digitalInputPin");
    outputPin = gpio.provisionDigitalOutputPin(MockPin.DIGITAL_OUTPUT_PIN, "digitalOutputPin");

    // create triggers
    triggerHigh = new GpioSetStateTrigger(PinState.HIGH, outputPin, PinState.HIGH);
    triggerLow = new GpioSetStateTrigger(PinState.LOW, outputPin, PinState.LOW);

    // add triggers to input pin
    inputPin.addTrigger(triggerHigh);
    inputPin.addTrigger(triggerLow);
  }
Пример #7
0
  public static void main(String[] args) {

    System.out.println("<--Pi4J--> GPIO Frequency Example ... started.");

    // create gpio controller
    final GpioController gpio = GpioFactory.getInstance();

    // provision gpio pin #01 as an output pin and turn on
    final GpioPinDigitalOutput pin = gpio.provisionDigitalOutputPin(RaspiPin.GPIO_01, PinState.LOW);

    // continuous loop
    while (true) {
      pin.setState(true);
      pin.setState(false);
    }

    // stop all GPIO activity/threads by shutting down the GPIO controller
    // (this method will forcefully shutdown all GPIO monitoring threads and scheduled tasks)
    // gpio.shutdown();   <--- implement this method call if you wish to terminate the Pi4J GPIO
    // controller
  }
Пример #8
0
 public GpioPinDigitalOutput getOutputPin(Integer pinNumber) {
   switch (pinNumber) {
     case 0:
       return gpio.provisionDigitalOutputPin(RaspiPin.GPIO_00);
     case 1:
       return gpio.provisionDigitalOutputPin(RaspiPin.GPIO_01);
     case 2:
       return gpio.provisionDigitalOutputPin(RaspiPin.GPIO_02);
     case 3:
       return gpio.provisionDigitalOutputPin(RaspiPin.GPIO_03);
     case 4:
       return gpio.provisionDigitalOutputPin(RaspiPin.GPIO_04);
     case 5:
       return gpio.provisionDigitalOutputPin(RaspiPin.GPIO_05);
     case 6:
       return gpio.provisionDigitalOutputPin(RaspiPin.GPIO_06);
     case 7:
       return gpio.provisionDigitalOutputPin(RaspiPin.GPIO_07);
     case 8:
       return gpio.provisionDigitalOutputPin(RaspiPin.GPIO_08);
     case 9:
       return gpio.provisionDigitalOutputPin(RaspiPin.GPIO_09);
     case 10:
       return gpio.provisionDigitalOutputPin(RaspiPin.GPIO_10);
     case 11:
       return gpio.provisionDigitalOutputPin(RaspiPin.GPIO_11);
     case 12:
       return gpio.provisionDigitalOutputPin(RaspiPin.GPIO_12);
     case 13:
       return gpio.provisionDigitalOutputPin(RaspiPin.GPIO_13);
     case 14:
       return gpio.provisionDigitalOutputPin(RaspiPin.GPIO_14);
     case 15:
       return gpio.provisionDigitalOutputPin(RaspiPin.GPIO_15);
     case 16:
       return gpio.provisionDigitalOutputPin(RaspiPin.GPIO_16);
     case 17:
       return gpio.provisionDigitalOutputPin(RaspiPin.GPIO_17);
     case 18:
       return gpio.provisionDigitalOutputPin(RaspiPin.GPIO_18);
     case 19:
       return gpio.provisionDigitalOutputPin(RaspiPin.GPIO_19);
     case 20:
       return gpio.provisionDigitalOutputPin(RaspiPin.GPIO_20);
     case 21:
       return gpio.provisionDigitalOutputPin(RaspiPin.GPIO_21);
     case 22:
       return gpio.provisionDigitalOutputPin(RaspiPin.GPIO_22);
     case 23:
       return gpio.provisionDigitalOutputPin(RaspiPin.GPIO_23);
     case 24:
       return gpio.provisionDigitalOutputPin(RaspiPin.GPIO_24);
     case 25:
       return gpio.provisionDigitalOutputPin(RaspiPin.GPIO_25);
     case 26:
       return gpio.provisionDigitalOutputPin(RaspiPin.GPIO_26);
     case 27:
       return gpio.provisionDigitalOutputPin(RaspiPin.GPIO_27);
     case 28:
       return gpio.provisionDigitalOutputPin(RaspiPin.GPIO_28);
     case 29:
       return gpio.provisionDigitalOutputPin(RaspiPin.GPIO_29);
     default:
       return null;
   }
 }
Пример #9
0
  public static void main(String[] args) throws InterruptedException {

    // START SNIPPET: usage-create-controller-snippet
    // create gpio controller instance
    final GpioController gpio = GpioFactory.getInstance();
    // END SNIPPET: usage-create-controller-snippet

    // START SNIPPET: usage-provision-input-pin-snippet
    // provision gpio pin #02 as an input pin with its internal pull down resistor enabled
    // (configure pin edge to both rising and falling to get notified for HIGH and LOW state
    // changes)
    GpioPinDigitalInput myButton =
        gpio.provisionDigitalInputPin(
            RaspiPin.GPIO_02, // PIN NUMBER
            "MyButton", // PIN FRIENDLY NAME (optional)
            PinPullResistance.PULL_DOWN); // PIN RESISTANCE (optional)

    // END SNIPPET: usage-provision-input-pin-snippet
    // START SNIPPET: usage-provision-output-pin-snippet
    // provision gpio pins #04 as an output pin and make sure is is set to LOW at startup
    GpioPinDigitalOutput myLed =
        gpio.provisionDigitalOutputPin(
            RaspiPin.GPIO_04, // PIN NUMBER
            "My LED", // PIN FRIENDLY NAME (optional)
            PinState.LOW); // PIN STARTUP STATE (optional)
    // END SNIPPET: usage-provision-output-pin-snippet

    // START SNIPPET: usage-shutdown-pin-snippet
    // configure the pin shutdown behavior; these settings will be
    // automatically applied to the pin when the application is terminated
    // ensure that the LED is turned OFF when the application is shutdown
    myLed.setShutdownOptions(true, PinState.LOW, PinPullResistance.OFF);
    // END SNIPPET: usage-shutdown-pin-snippet

    // START SNIPPET: usage-control-pin-snippet
    // explicitly set a state on the pin object
    myLed.setState(PinState.HIGH);

    // use convenience wrapper method to set state on the pin object
    myLed.low();
    myLed.high();

    // use toggle method to apply inverse state on the pin object
    myLed.toggle();

    // use pulse method to set the pin to the HIGH state for
    // an explicit length of time in milliseconds
    myLed.pulse(1000);
    // END SNIPPET: usage-control-pin-snippet

    // START SNIPPET: usage-read-pin-snippet
    // get explicit state enumeration for the GPIO pin associated with the button
    PinState myButtonState = myButton.getState();

    // use convenience wrapper method to interrogate the button state
    boolean buttonPressed = myButton.isHigh();
    // END SNIPPET: usage-read-pin-snippet

    // START SNIPPET: usage-register-listener-snippet
    // create and register gpio pin listener
    myButton.addListener(new GpioUsageExampleListener());
    // END SNIPPET: usage-register-listener-snippet

    // START SNIPPET: usage-trigger-snippet
    // create a gpio synchronization trigger on the input pin
    // when the input state changes, also set LED controlling gpio pin to same state
    myButton.addTrigger(new GpioSyncStateTrigger(myLed));
    // END SNIPPET: usage-trigger-snippet

    // keep program running until user aborts (CTRL-C)
    while (true) {
      Thread.sleep(500);
    }

    // stop all GPIO activity/threads by shutting down the GPIO controller
    // (this method will forcefully shutdown all GPIO monitoring threads and scheduled tasks)
    // gpio.shutdown();   <--- implement this method call if you wish to terminate the Pi4J GPIO
    // controller
  }
Пример #10
0
 @Override
 public GpioPinDigitalOutput provisionDigitalOutputPin(Pin pin, PinState defaultState) {
   return delegate.provisionDigitalOutputPin(pin, defaultState);
 }
Пример #11
0
 @Override
 public GpioPinDigitalOutput provisionDigitalOutputPin(
     GpioProvider provider, Pin pin, String name, PinState defaultState) {
   return delegate.provisionDigitalOutputPin(provider, pin, name, defaultState);
 }
Пример #12
0
 @Override
 public GpioPinDigitalOutput provisionDigitalOutputPin(Pin pin) {
   return delegate.provisionDigitalOutputPin(pin);
 }
Пример #13
0
  public static void main(String args[]) throws InterruptedException {

    System.out.println("<--Pi4J--> GPIO Listen Example ... started.");

    // create gpio controller
    final GpioController gpio = GpioFactory.getInstance();

    // provision gpio pin #02 as an input pin with its internal pull down resistor enabled
    final GpioPinDigitalInput myButton =
        gpio.provisionDigitalInputPin(RaspiPin.GPIO_02, PinPullResistance.PULL_DOWN);

    // create custom Olimex GPIO provider
    final OlimexAVRIOGpioProvider olimexProvider =
        new OlimexAVRIOGpioProvider(Serial.DEFAULT_COM_PORT);

    // provision gpio input pin #01 from Olimex
    final GpioPinDigitalInput myInput =
        gpio.provisionDigitalInputPin(olimexProvider, OlimexAVRIOPin.IN_01);

    // create gpio pin listener
    GpioPinListenerDigital listener =
        new GpioPinListenerDigital() {
          @Override
          public void handleGpioPinDigitalStateChangeEvent(GpioPinDigitalStateChangeEvent event) {
            // display pin state on console
            System.out.println(
                " --> GPIO PIN STATE CHANGE: " + event.getPin() + " = " + event.getState());
          }
        };

    // register gpio pin listener for each input pin
    myButton.addListener(listener);
    myInput.addListener(listener);

    // setup gpio pins #04, #05, #06 as an output pins and make sure they are all LOW at startup
    GpioPinDigitalOutput myRelays[] = {
      gpio.provisionDigitalOutputPin(
          olimexProvider, OlimexAVRIOPin.RELAY_01, "RELAY #1", PinState.LOW),
      gpio.provisionDigitalOutputPin(
          olimexProvider, OlimexAVRIOPin.RELAY_02, "RELAY #2", PinState.LOW),
      gpio.provisionDigitalOutputPin(
          olimexProvider, OlimexAVRIOPin.RELAY_03, "RELAY #3", PinState.LOW),
      gpio.provisionDigitalOutputPin(
          olimexProvider, OlimexAVRIOPin.RELAY_04, "RELAY #4", PinState.LOW)
    };

    // create a gpio control trigger on the input pin ; when the input goes HIGH, also set gpio pin
    // #04 to HIGH
    myButton.addTrigger(new GpioSetStateTrigger(PinState.HIGH, myRelays[0], PinState.HIGH));

    // create a gpio control trigger on the input pin ; when the input goes LOW, also set gpio pin
    // #04 to LOW
    myButton.addTrigger(new GpioSetStateTrigger(PinState.LOW, myRelays[0], PinState.LOW));

    // create a gpio synchronization trigger on the input pin; when the input changes, also set gpio
    // pin #05 to same state
    myButton.addTrigger(new GpioSyncStateTrigger(myRelays[1]));

    // create a gpio synchronization trigger on the input pin; when the input changes, also set gpio
    // pin #05 to same state
    myButton.addTrigger(new GpioSyncStateTrigger(myRelays[2]));

    // create a gpio pulse trigger on the input pin; when the input goes HIGH, also pulse gpio pin
    // #06 to the HIGH state for 1 second
    myButton.addTrigger(new GpioPulseStateTrigger(PinState.HIGH, myRelays[3], 1000));

    System.out.println(
        " ... complete the GPIO #02 circuit and see the listener feedback here in the console.");

    // keep program running until user aborts (CTRL-C)
    // or we reach 60 seconds
    for (int seconds = 0; seconds < 60; seconds++) {
      Thread.sleep(1000);
    }

    System.out.println(" ... exiting program.");

    // stop all GPIO activity/threads by shutting down the GPIO controller
    // (this method will forcefully shutdown all GPIO monitoring threads and scheduled tasks)
    gpio.shutdown();
  }
Пример #14
0
/*
 *
 * Essa classe foi criada a partir do exemplo em python do endereço abaixo
 * https://www.modmypi.com/blog/hc-sr04-ultrasonic-range-sensor-on-the-raspberry-pi
 *
 *
 */
public class HCSR04 {

  GpioController gpio = GpioFactory.getInstance();

  // Configura os pinos
  GpioPinDigitalOutput trigger =
      gpio.provisionDigitalOutputPin(RaspiPin.GPIO_04, "trigger", PinState.LOW);
  GpioPinDigitalInput echo =
      gpio.provisionDigitalInputPin(RaspiPin.GPIO_05, "echo", PinPullResistance.PULL_DOWN);

  public long getDistancia() {
    System.out.println("Medição de distância em progresso...");

    this.trigger.low();

    System.out.println("Aguardando tempo do pino...");
    try {
      Thread.sleep(2000);
    } catch (InterruptedException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }

    // Iniciando a leitura
    System.out.println("Iniciando a leitura");
    try {

      // Envia o sinal no pino Trigger
      // Coloca o trigger em HIGH por 10uS (8 ultrasound bursts at 40 kHz)
      this.trigger.high();
      TimeUnit.MICROSECONDS.sleep(10);
      this.trigger.low();

      // Escuta o pino de ECHO
      // O sensor emitirá uma onda sonora que ao encontrar um obstáculo
      // rebaterá de volta em direção ao módulo, sendo que o neste tempo
      // de emissão e recebimento do sinal o pino ECHO ficará em nivel alto.
      // Logo o calcula da distância pode ser feito de acordo com o tempo em
      // que o pino ECHO permaneceu em nível alto após o pino Trigger ter
      // sido colocado em nível alto.
      long inicio = 0;
      long fim = 0;

      while (this.echo.isLow()) {
        inicio = System.nanoTime();
      }
      while (this.echo.isHigh()) {
        fim = System.nanoTime();
      }

      // Calcula a diferença entre "fim" e "inicio"
      long duracao_pulso = fim - inicio;

      // Calcula distância
      long distancia = 17150 * duracao_pulso;

      // Round
      distancia = Math.round(distancia);

      System.out.println("Distancia: " + distancia);

      return distancia;

    } catch (InterruptedException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }

    return 0;
  }
}
  public static void main(String args[]) throws InterruptedException, IOException {

    System.out.println("<--Pi4J--> PiFace (MCP23017) GPIO Example ... started.");

    // create gpio controller
    final GpioController gpio = GpioFactory.getInstance();

    // create custom PiFace GPIO provider
    final PiFaceGpioProvider gpioProvider =
        new PiFaceGpioProvider(PiFaceGpioProvider.DEFAULT_ADDRESS, SpiChannel.CS0);

    // provision gpio input pins from PiFaceGpioProvider
    GpioPinDigitalInput myInputs[] = {
      gpio.provisionDigitalInputPin(gpioProvider, PiFacePin.INPUT_00),
      gpio.provisionDigitalInputPin(gpioProvider, PiFacePin.INPUT_01),
      gpio.provisionDigitalInputPin(gpioProvider, PiFacePin.INPUT_02),
      gpio.provisionDigitalInputPin(gpioProvider, PiFacePin.INPUT_03),
      gpio.provisionDigitalInputPin(gpioProvider, PiFacePin.INPUT_04),
      gpio.provisionDigitalInputPin(gpioProvider, PiFacePin.INPUT_05),
      gpio.provisionDigitalInputPin(gpioProvider, PiFacePin.INPUT_06),
      gpio.provisionDigitalInputPin(gpioProvider, PiFacePin.INPUT_07)
    };

    // create and register gpio pin listener
    gpio.addListener(
        new GpioPinListenerDigital() {
          @Override
          public void handleGpioPinDigitalStateChangeEvent(GpioPinDigitalStateChangeEvent event) {
            // display pin state on console
            System.out.println(
                " --> GPIO PIN STATE CHANGE: " + event.getPin() + " = " + event.getState());
          }
        },
        myInputs);

    // provision gpio output pins and make sure they are all LOW at startup
    GpioPinDigitalOutput myOutputs[] = {
      gpio.provisionDigitalOutputPin(gpioProvider, PiFacePin.OUTPUT_00),
      gpio.provisionDigitalOutputPin(gpioProvider, PiFacePin.OUTPUT_01),
      gpio.provisionDigitalOutputPin(gpioProvider, PiFacePin.OUTPUT_02),
      gpio.provisionDigitalOutputPin(gpioProvider, PiFacePin.OUTPUT_03),
      gpio.provisionDigitalOutputPin(gpioProvider, PiFacePin.OUTPUT_04),
      gpio.provisionDigitalOutputPin(gpioProvider, PiFacePin.OUTPUT_05),
      gpio.provisionDigitalOutputPin(gpioProvider, PiFacePin.OUTPUT_06),
      gpio.provisionDigitalOutputPin(gpioProvider, PiFacePin.OUTPUT_07),
    };

    // keep program running for 20 seconds
    for (int count = 0; count < 10; count++) {
      gpio.setState(true, myOutputs);
      Thread.sleep(1000);
      gpio.setState(false, myOutputs);
      Thread.sleep(1000);
    }

    // stop all GPIO activity/threads by shutting down the GPIO controller
    // (this method will forcefully shutdown all GPIO monitoring threads and scheduled tasks)
    gpio.shutdown();

    System.out.println("Exiting PiFaceGpioExample");
  }
Пример #16
0
  /**
   * [ARGUMENT/OPTION "--pin (#)" | "-p (#)" ] This example program accepts an optional argument for
   * specifying the GPIO pin (by number) to use with this GPIO listener example. If no argument is
   * provided, then GPIO #1 will be used. -- EXAMPLE: "--pin 4" or "-p 0".
   *
   * @param args
   * @throws InterruptedException
   * @throws PlatformAlreadyAssignedException
   */
  public static void main(String[] args)
      throws InterruptedException, PlatformAlreadyAssignedException {

    // ####################################################################
    //
    // since we are not using the default Raspberry Pi platform, we should
    // explicitly assign the platform as the BananaPi platform.
    //
    // ####################################################################
    PlatformManager.setPlatform(Platform.BANANAPI);

    // create Pi4J console wrapper/helper
    // (This is a utility class to abstract some of the boilerplate code)
    final Console console = new Console();

    // print program title/header
    console.title("<-- The Pi4J Project -->", "GPIO Output Example");

    // allow for user to exit program using CTRL-C
    console.promptForExit();

    // create gpio controller
    final GpioController gpio = GpioFactory.getInstance();

    // ####################################################################
    //
    // When provisioning a pin, use the BananaPiPin class.
    //
    // ####################################################################

    // by default we will use gpio pin #01; however, if an argument
    // has been provided, then lookup the pin by address
    Pin pin =
        CommandArgumentParser.getPin(
            BananaPiPin.class, // pin provider class to obtain pin instance from
            BananaPiPin.GPIO_01, // default pin if no pin argument found
            args); // argument array to search in

    // provision gpio pin as an output pin and turn on
    final GpioPinDigitalOutput output =
        gpio.provisionDigitalOutputPin(pin, "My Output", PinState.HIGH);

    // set shutdown state for this pin: keep as output pin, set to low state
    output.setShutdownOptions(false, PinState.LOW);

    // create a pin listener to print out changes to the output gpio pin state
    output.addListener(
        new GpioPinListenerDigital() {
          @Override
          public void handleGpioPinDigitalStateChangeEvent(GpioPinDigitalStateChangeEvent event) {
            // display pin state on console
            console.println(
                " --> GPIO PIN STATE CHANGE: "
                    + event.getPin()
                    + " = "
                    + ConsoleColor.conditional(
                        event.getState().isHigh(), // conditional expression
                        ConsoleColor.GREEN, // positive conditional color
                        ConsoleColor.RED, // negative conditional color
                        event.getState())); // text to display
          }
        });

    // prompt user that we are ready
    console.println(" ... Successfully provisioned output pin: " + output.toString());
    console.emptyLine();
    console.box("The GPIO output pin states will cycle HIGH and LOW states now.");
    console.emptyLine();

    // notify user of current pin state
    console.println(
        "--> ["
            + output.toString()
            + "] state was provisioned with state = "
            + ConsoleColor.conditional(
                output.getState().isHigh(), // conditional expression
                ConsoleColor.GREEN, // positive conditional color
                ConsoleColor.RED, // negative conditional color
                output.getState())); // text to display

    // wait
    Thread.sleep(500);

    // --------------------------------------------------------------------------

    // tset gpio pin state to LOW
    console.emptyLine();
    console.println("Setting output pin state is set to LOW.");
    output.low(); // or ... output.setState(PinState.LOW);

    // wait
    Thread.sleep(500);

    // --------------------------------------------------------------------------

    // tset gpio pin state to HIGH
    console.emptyLine();
    console.println("Setting output pin state from LOW to HIGH.");
    output.setState(PinState.HIGH); // or ... output.high();

    // wait
    Thread.sleep(500);

    // --------------------------------------------------------------------------

    // toggle the current state of gpio pin (from HIGH to LOW)
    console.emptyLine();
    console.println("Toggling output pin state from HIGH to LOW.");
    output.toggle();

    // wait
    Thread.sleep(500);

    // --------------------------------------------------------------------------

    // pulse gpio pin state for 1 second HIGH and then return to LOW
    console.emptyLine();
    console.println("Pulsing output pin state HIGH for 1 second.");
    output.pulse(1000, true); // set second argument to 'true' use a blocking call
    Thread.sleep(50);

    // --------------------------------------------------------------------------

    // blink gpio pin state for 1 second between HIGH and LOW states
    console.emptyLine();
    console.println(
        "Blinking output pin state between HIGH and LOW for 3 seconds with a blink rate of 250ms.");
    Future future = output.blink(250, 3000);

    // --------------------------------------------------------------------------

    // wait for blinking to finish; we are notified in a future object
    while (!future.isDone()) {
      Thread.sleep(50);
    }

    // stop all GPIO activity/threads by shutting down the GPIO controller
    // (this method will forcefully shutdown all GPIO monitoring threads and scheduled tasks)
    gpio.shutdown();
  }
Пример #17
0
 @Override
 public GpioPinDigitalOutput provisionDigitalOutputPin(Pin pin, String name) {
   return delegate.provisionDigitalOutputPin(pin, name);
 }
@RestController
public class motorController {

  GpioController gpio = GpioFactory.getInstance();

  GpioPinDigitalOutput leftBackMotor =
      gpio.provisionDigitalOutputPin(RaspiPin.GPIO_04, "Motor Izquierda", PinState.LOW);
  GpioPinDigitalOutput rightBackMotor =
      gpio.provisionDigitalOutputPin(RaspiPin.GPIO_05, "Motor Derecha", PinState.LOW);
  GpioPinDigitalOutput rightFrontMotor =
      gpio.provisionDigitalOutputPin(RaspiPin.GPIO_02, "Motor Derecha", PinState.LOW);
  GpioPinDigitalOutput leftFrontMotor =
      gpio.provisionDigitalOutputPin(RaspiPin.GPIO_03, "Motor Derecha", PinState.LOW);

  @RequestMapping("/index")
  public String start() {

    return "app is running ok.";
  }

  @RequestMapping("/forward.htmlc")
  public String forward() throws InterruptedException {

    leftFrontMotor.high();
    rightFrontMotor.high();

    return "Moving forward...";
  }

  @RequestMapping("/back.html")
  public String back() throws InterruptedException {

    leftBackMotor.high();
    rightBackMotor.high();

    return "Moving backwards...";
  }

  @RequestMapping("/right.html")
  public String right() throws InterruptedException {

    leftFrontMotor.toggle();
    rightFrontMotor.toggle();

    return "Moving right...";
  }

  @RequestMapping("/left.html")
  public String left() throws InterruptedException {

    leftFrontMotor.toggle();
    rightFrontMotor.toggle();

    return "Moving left...";
  }

  @RequestMapping("/shutdown.html")
  public String shutdown() {

    gpio.shutdown();
    leftBackMotor.low();
    leftFrontMotor.low();
    rightBackMotor.low();
    rightFrontMotor.low();
    gpio.unprovisionPin(leftBackMotor);
    gpio.unprovisionPin(rightBackMotor);
    gpio.unprovisionPin(rightFrontMotor);
    gpio.unprovisionPin(leftFrontMotor);

    return "Program was shutdown correctly";
  }
}
Пример #19
0
public class SocketServer {

  private ServerSocket serverSocket;
  public static final int SERVERPORT = 6000;

  // ================
  // Commands
  // ================
  private static String LIGHT_ON = "light_on";
  private static String LIGHT_OFF = "light_off";
  private static String DOOR_OPEN = "door_open";
  private static String DOOR_CLOSE = "door_close";

  // ================
  // GPIO block
  // ================
  final GpioController gpio = GpioFactory.getInstance();
  final GpioPinDigitalOutput lightPin =
      gpio.provisionDigitalOutputPin(RaspiPin.GPIO_01, "MyLED", PinState.LOW);
  final GpioPinDigitalInput myButton =
      gpio.provisionDigitalInputPin(RaspiPin.GPIO_02, PinPullResistance.PULL_DOWN);

  Socket socket = null;
  GpioCallbackTrigger doorRingTrigger;

  public SocketServer() {
    try {
      initializeSoftPWM();
      System.out.println("Waiting for connect ...");
      createSocket();
      System.out.println("Device is connected");
      createDoorBell();
      createCommandReader();
      // Wait until user stops the application
      Scanner scanIn = new Scanner(System.in);
      String nextLine = "";
      while (true) {
        nextLine = scanIn.nextLine();
        if (nextLine.equals("!exit")) {
          System.exit(0);
        }
        ;
      }
    } catch (SocketException e) {
      System.out.println(String.format("Socket connect is broken: \n %s", e.getMessage()));
      System.exit(0);
    } catch (IOException e) {
      System.out.println(String.format("Something wrong: \n %s", e.getMessage()));
      System.exit(0);
    }
  }

  private void createSocket() throws IOException, SocketException {
    serverSocket = new ServerSocket(SERVERPORT);
    socket = serverSocket.accept();
    socket.setKeepAlive(true);
  }

  private void initializeSoftPWM() {
    Gpio.wiringPiSetup();
    SoftPwm.softPwmCreate(26, 0, 100);
  }

  private void createCommandReader() {
    new Thread(new CommandReader()).start();
  }

  private class CommandReader implements Runnable {

    public void run() {
      try {
        BufferedReader input = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        while (true) {
          String read = input.readLine();
          if (read != null && !read.isEmpty()) {
            System.out.println(String.format("Message: '%s' was received", read));
            reactToCommand(read);
          }
        }
      } catch (IOException e) {
        System.out.println(String.format("Cannot create input stream: \n %s", e.getMessage()));
      }
    }
  }

  private void createDoorBell() {
    new Thread(new DoorRingListener()).start();
  }

  private class DoorRingListener implements Runnable {

    public void run() {
      try {
        PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
        doorRingTrigger = creareDoorRingTrigger(out);
        myButton.addTrigger(doorRingTrigger);
      } catch (IOException e) {
        System.out.println(String.format("Cannot create output stream: \n %s", e.getMessage()));
      }
    }
  }

  private GpioCallbackTrigger creareDoorRingTrigger(final PrintWriter out) {
    return new GpioCallbackTrigger(
        new Callable<Void>() {
          public Void call() throws Exception {
            myButton.removeAllTriggers();
            System.out.println("Someone comes to home");
            sendNotificationToClient(out);
            try {
              Thread.sleep(500);
            } catch (InterruptedException e) {
            }
            myButton.addTrigger(doorRingTrigger);
            return null;
          }
        });
  }

  private void sendNotificationToClient(PrintWriter out) {
    out.println("Someone comes to home");
    out.flush();
  }

  private void reactToCommand(String read) {
    if (read.equalsIgnoreCase(LIGHT_ON)) {
      turnLightOn();
    } else if (read.equalsIgnoreCase(LIGHT_OFF)) {
      turnLightOff();
    } else if (read.equalsIgnoreCase(DOOR_OPEN)) {
      openDoor();
    } else if (read.equalsIgnoreCase(DOOR_CLOSE)) {
      closeDoor();
    }
  }

  private void closeDoor() {
    SoftPwm.softPwmWrite(26, 5);
    try {
      Thread.sleep(2000);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
    SoftPwm.softPwmWrite(26, 00);
  }

  private void openDoor() {
    SoftPwm.softPwmWrite(26, 45);
    try {
      Thread.sleep(2000);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
    SoftPwm.softPwmWrite(26, 00);
  }

  private void turnLightOff() {
    lightPin.low();
    System.out.println(String.format("Light was turned off"));
  }

  private void turnLightOn() {
    lightPin.high();
    System.out.println(String.format("Light was turned on"));
  }

  public static void main(String[] args) {
    new SocketServer();
  }
}