Java Code Examples for com.pi4j.io.gpio.GpioController#provisionDigitalOutputPin()

@Override
public void start(LocalDateTime now, Timer timer) {
    logger.debug("{}: Starting {} for {}", getApplianceId(), getClass().getSimpleName(), getGpio());
    GpioController gpioController = getGpioController();
    if (gpioController != null) {
        try {
            outputPin = gpioController.provisionDigitalOutputPin(getGpio(), adjustState(PinState.LOW));
            logger.debug("{}: {} uses {} reverseStates={}", getApplianceId(), getClass().getSimpleName(),
                    getGpio(), reverseStates);
        } catch (Exception e) {
            logger.error("{}: Error starting {} for {}", getApplianceId(), getClass().getSimpleName(), getGpio(), e);
        }
    } else {
        logGpioAccessDisabled(logger);
    }
}
 

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        
}
 

public static void main(String[] args) throws InterruptedException {
	// get a handle to the GPIO controller
	final GpioController gpio = GpioFactory.getInstance();

	final GpioPinDigitalOutput pinA = gpio.provisionDigitalOutputPin(RaspiPin.GPIO_04, "PinA");
	final GpioPinDigitalOutput pinB = gpio.provisionDigitalOutputPin(RaspiPin.GPIO_05, "PinB");
	final GpioPinDigitalOutput pinE = gpio.provisionDigitalOutputPin(RaspiPin.GPIO_06, "PinE");

	System.out.println("rotate motor clock-wise for 3 seconds");
	pinA.high();
	pinB.low();
	pinE.high();

	// wait 3 seconds
	Thread.sleep(3000);

	System.out.println("rotate motor in oposite derection for 6 seconds");
	pinA.low();
	pinB.high();

	// wait 6 seconds
	Thread.sleep(6000);

	// stop motor
	System.out.println("Stopping motor");
	pinE.low();

	gpio.shutdown();
}
 

public static void main(String[] args) throws InterruptedException {
    
    System.out.println("<--Pi4J--> GPIO Control 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, "MyLED", PinState.HIGH);
    System.out.println("--> GPIO state should be: ON");
    
    Thread.sleep(5000);
    
    // turn off gpio pin #01
    pin.low();
    System.out.println("--> GPIO state should be: OFF");

    Thread.sleep(5000);

    // toggle the current state of gpio pin #01 (should turn on)
    pin.toggle();
    System.out.println("--> GPIO state should be: ON");

    Thread.sleep(5000);

    // toggle the current state of gpio pin #01  (should turn off)
    pin.toggle();
    System.out.println("--> GPIO state should be: OFF");
    
    Thread.sleep(5000);

    // turn on gpio pin #01 for 1 second and then off
    System.out.println("--> GPIO state should be: ON for only 1 second");
    pin.pulse(1000, true); // set second argument to 'true' use a blocking call
    
    // 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();
}
 

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        
}
 

public static void main(String[] args) throws InterruptedException {
    
    System.out.println("<--Pi4J--> GPIO Blink 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 blink trigger take effect.");
    
    // setup gpio pins #04 an output pins and make sure they are all LOW at startup
    final GpioPinDigitalOutput myLed = gpio.provisionDigitalOutputPin(RaspiPin.GPIO_04, PinState.LOW);
    
    // create a gpio control trigger on the input pin ; when the input goes HIGH, turn on blinking
    myButton.addTrigger(new GpioBlinkStateTrigger(PinState.HIGH, myLed, 250));

    // create a gpio control trigger on the input pin ; when the input goes LOW, turn off blinking
    myButton.addTrigger(new GpioBlinkStopStateTrigger(PinState.LOW, myLed));

    // 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        
}
 

public static void main(String[] args) throws InterruptedException {
    
    System.out.println("<--Pi4J--> GPIO Shutdown 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.HIGH);
    
    // configure the pin shutdown behavior; these settings will be 
    // automatically applied to the pin when the application is terminated
    pin.setShutdownOptions(true, PinState.LOW, PinPullResistance.OFF);
    
    System.out.println("--> GPIO state should be: ON");
    System.out.println("    This program will automatically terminate in 10 seconds,");
    System.out.println("    or you can use the CTRL-C keystroke to terminate at any time.");
    System.out.println("    When the program terminates, the GPIO state should be shutdown and set to: OFF");
    
    // wait 10 seconds
    Thread.sleep(10000);
    
    System.out.println(" .. shutting down now ...");
    
    // 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();
}
 

public static void main(String args[]) throws InterruptedException, IOException {
    
    System.out.println("<--Pi4J--> MCP23017 GPIO Example ... started.");
    
    // create gpio controller
    final GpioController gpio = GpioFactory.getInstance();
    
    // create custom MCP23017 GPIO provider
    final MCP23017GpioProvider gpioProvider = new MCP23017GpioProvider(I2CBus.BUS_1, 0x21);
    
    // provision gpio input pins from MCP23017
    GpioPinDigitalInput myInputs[] = {
            gpio.provisionDigitalInputPin(gpioProvider, MCP23017Pin.GPIO_A0, "MyInput-A0", PinPullResistance.PULL_UP),
            gpio.provisionDigitalInputPin(gpioProvider, MCP23017Pin.GPIO_A1, "MyInput-A1", PinPullResistance.PULL_UP),
            gpio.provisionDigitalInputPin(gpioProvider, MCP23017Pin.GPIO_A2, "MyInput-A2", PinPullResistance.PULL_UP),
            gpio.provisionDigitalInputPin(gpioProvider, MCP23017Pin.GPIO_A3, "MyInput-A3", PinPullResistance.PULL_UP),
            gpio.provisionDigitalInputPin(gpioProvider, MCP23017Pin.GPIO_A4, "MyInput-A4", PinPullResistance.PULL_UP),
            gpio.provisionDigitalInputPin(gpioProvider, MCP23017Pin.GPIO_A5, "MyInput-A5", PinPullResistance.PULL_UP),
            gpio.provisionDigitalInputPin(gpioProvider, MCP23017Pin.GPIO_A6, "MyInput-A6", PinPullResistance.PULL_UP),
            gpio.provisionDigitalInputPin(gpioProvider, MCP23017Pin.GPIO_A7, "MyInput-A7", PinPullResistance.PULL_UP),
        };
    
    // 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, MCP23017Pin.GPIO_B0, "MyOutput-B0", PinState.LOW),
        gpio.provisionDigitalOutputPin(gpioProvider, MCP23017Pin.GPIO_B1, "MyOutput-B1", PinState.LOW),
        gpio.provisionDigitalOutputPin(gpioProvider, MCP23017Pin.GPIO_B2, "MyOutput-B2", PinState.LOW),
        gpio.provisionDigitalOutputPin(gpioProvider, MCP23017Pin.GPIO_B3, "MyOutput-B3", PinState.LOW),
        gpio.provisionDigitalOutputPin(gpioProvider, MCP23017Pin.GPIO_B4, "MyOutput-B4", PinState.LOW),
        gpio.provisionDigitalOutputPin(gpioProvider, MCP23017Pin.GPIO_B5, "MyOutput-B5", PinState.LOW),
        gpio.provisionDigitalOutputPin(gpioProvider, MCP23017Pin.GPIO_B6, "MyOutput-B6", PinState.LOW),
        gpio.provisionDigitalOutputPin(gpioProvider, MCP23017Pin.GPIO_B7, "MyOutput-B7", PinState.LOW)
      };
    
    // 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();                 
}
 

public static void main(String[] args) throws InterruptedException {
    
    System.out.println("<--Pi4J--> GPIO Blink Example ... started.");
    
    // create gpio controller
    final GpioController gpio = GpioFactory.getInstance();
    
    // provision gpio pin #01 & #03 as an output pins and blink
    final GpioPinDigitalOutput led1 = gpio.provisionDigitalOutputPin(RaspiPin.GPIO_01);
    final GpioPinDigitalOutput led2 = gpio.provisionDigitalOutputPin(RaspiPin.GPIO_03);

    // 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 and register gpio pin listener
    myButton.addListener(new GpioPinListenerDigital() {
            @Override
            public void handleGpioPinDigitalStateChangeEvent(GpioPinDigitalStateChangeEvent event) {
                // when button is pressed, speed up the blink rate on LED #2
                if(event.getState().isHigh()){
                  led2.blink(200);
                }                        
                else{
                  led2.blink(1000);
                }
            }
        });

    // continuously blink the led every 1/2 second for 15 seconds
    led1.blink(500, 15000);

    // continuously blink the led every 1 second 
    led2.blink(1000);
    
    System.out.println(" ... the LED will continue blinking until the program is terminated.");
    System.out.println(" ... PRESS <CTRL-C> TO STOP THE PROGRAM.");
    
    // keep program running until user aborts (CTRL-C)
    for (;;) {
        Thread.sleep(500);
    }
    
    // stop all GPIO activity/threads
    // (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
}
 

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        
}
 

public static void main(String args[]) throws InterruptedException, IOException {
    
    System.out.println("<--Pi4J--> MCP23S17 GPIO Example ... started.");
    
    // create gpio controller
    final GpioController gpio = GpioFactory.getInstance();
    
    // create custom MCP23017 GPIO provider
    final MCP23S17GpioProvider gpioProvider = new MCP23S17GpioProvider(MCP23S17GpioProvider.DEFAULT_ADDRESS, Spi.CHANNEL_0);
    
    // provision gpio input pins from MCP23S17
    GpioPinDigitalInput myInputs[] = {
            gpio.provisionDigitalInputPin(gpioProvider, MCP23S17Pin.GPIO_B0, "MyInput-B0", PinPullResistance.PULL_UP),
            gpio.provisionDigitalInputPin(gpioProvider, MCP23S17Pin.GPIO_B1, "MyInput-B1", PinPullResistance.PULL_UP),
            gpio.provisionDigitalInputPin(gpioProvider, MCP23S17Pin.GPIO_B2, "MyInput-B2", PinPullResistance.PULL_UP),
            gpio.provisionDigitalInputPin(gpioProvider, MCP23S17Pin.GPIO_B3, "MyInput-B3", PinPullResistance.PULL_UP),
            gpio.provisionDigitalInputPin(gpioProvider, MCP23S17Pin.GPIO_B4, "MyInput-B4", PinPullResistance.PULL_UP),
            gpio.provisionDigitalInputPin(gpioProvider, MCP23S17Pin.GPIO_B5, "MyInput-B5", PinPullResistance.PULL_UP),
            gpio.provisionDigitalInputPin(gpioProvider, MCP23S17Pin.GPIO_B6, "MyInput-B6", PinPullResistance.PULL_UP),
            gpio.provisionDigitalInputPin(gpioProvider, MCP23S17Pin.GPIO_B7, "MyInput-B7", PinPullResistance.PULL_UP),
        };
    
    // 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, MCP23S17Pin.GPIO_A0, "MyOutput-A0", PinState.LOW),
        gpio.provisionDigitalOutputPin(gpioProvider, MCP23S17Pin.GPIO_A1, "MyOutput-A1", PinState.LOW),
        gpio.provisionDigitalOutputPin(gpioProvider, MCP23S17Pin.GPIO_A2, "MyOutput-A2", PinState.LOW),
        gpio.provisionDigitalOutputPin(gpioProvider, MCP23S17Pin.GPIO_A3, "MyOutput-A3", PinState.LOW),
        gpio.provisionDigitalOutputPin(gpioProvider, MCP23S17Pin.GPIO_A4, "MyOutput-A4", PinState.LOW),
        gpio.provisionDigitalOutputPin(gpioProvider, MCP23S17Pin.GPIO_A5, "MyOutput-A5", PinState.LOW),
        gpio.provisionDigitalOutputPin(gpioProvider, MCP23S17Pin.GPIO_A6, "MyOutput-A6", PinState.LOW),
        gpio.provisionDigitalOutputPin(gpioProvider, MCP23S17Pin.GPIO_A7, "MyOutput-A7", PinState.LOW)
      };
    
    // 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();                 
}
 

public static void main(String args[]) throws InterruptedException, IOException {
    
    System.out.println("<--Pi4J--> PCF8574 GPIO Example ... started.");
    
    // create gpio controller
    final GpioController gpio = GpioFactory.getInstance();
    
    // create custom MCP23017 GPIO provider
    final PCF8574GpioProvider gpioProvider = new PCF8574GpioProvider(I2CBus.BUS_1, PCF8574GpioProvider.PCF8574A_0x3F);
    
    // provision gpio input pins from MCP23017
    GpioPinDigitalInput myInputs[] = {
            gpio.provisionDigitalInputPin(gpioProvider, PCF8574Pin.GPIO_00),
            gpio.provisionDigitalInputPin(gpioProvider, PCF8574Pin.GPIO_01),
            gpio.provisionDigitalInputPin(gpioProvider, PCF8574Pin.GPIO_02)
        };
    
    // 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, PCF8574Pin.GPIO_04, PinState.LOW),
        gpio.provisionDigitalOutputPin(gpioProvider, PCF8574Pin.GPIO_05, PinState.LOW),
        gpio.provisionDigitalOutputPin(gpioProvider, PCF8574Pin.GPIO_06, PinState.LOW)
      };

    // on program shutdown, set the pins back to their default state: HIGH 
    gpio.setShutdownOptions(true, PinState.HIGH, myOutputs);
    
    // 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();
}
 

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,Spi.CHANNEL_0);
    
    // 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();                 
}
 

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();                 
    }
 

public static void main(String[] args) throws InterruptedException {
	// get a handle to the GPIO controller
	final GpioController gpio = GpioFactory.getInstance();

	// init soft PWM pins
	// softPwmCreate(int pin, int value, int range)
	// the range is set like (min=0 ; max=100)
	SoftPwm.softPwmCreate(MOTOR_1_PIN_A, 0, 100);
	SoftPwm.softPwmCreate(MOTOR_1_PIN_B, 0, 100);
	SoftPwm.softPwmCreate(MOTOR_2_PIN_A, 0, 100);
	SoftPwm.softPwmCreate(MOTOR_2_PIN_B, 0, 100);

	// init GPIO pins
	final GpioPinDigitalOutput motor1pinE = gpio.provisionDigitalOutputPin(RaspiPin.GPIO_06, "m1E");
	final GpioPinDigitalOutput motor2pinE = gpio.provisionDigitalOutputPin(RaspiPin.GPIO_03, "m2E");

	System.out.println("rotate motor 1 clockwise at 15% speed for 2 seconds");
	motor1pinE.high();
	SoftPwm.softPwmWrite(MOTOR_1_PIN_A, 15);

	// wait 2 seconds
	Thread.sleep(2000);

	System.out.println("rotate motor 1 clockwise at 60% speed for 2 seconds");
	SoftPwm.softPwmWrite(MOTOR_1_PIN_A, 60);

	// wait 2 seconds
	Thread.sleep(2000);

	System.out.println("rotate motor 1 clockwise at full speed for 2 seconds");
	SoftPwm.softPwmWrite(MOTOR_1_PIN_A, 100);

	// wait 2 seconds
	Thread.sleep(2000);

	System.out.println("rotate motor 1 in oposite direction at 50% speed for 3 seconds");
	SoftPwm.softPwmWrite(MOTOR_1_PIN_A, 0);
	SoftPwm.softPwmWrite(MOTOR_1_PIN_B, 50);

	// wait 3 seconds
	Thread.sleep(3000);

	// disable motor 1
	SoftPwm.softPwmWrite(MOTOR_1_PIN_B, 0);
	motor1pinE.low();

	System.out.println("rotate motor 2 clockwise at 30% speed for 2 seconds");
	motor2pinE.high();
	SoftPwm.softPwmWrite(MOTOR_2_PIN_A, 30);

	// wait 2 seconds
	Thread.sleep(2000);

	System.out.println("rotate motor 2 in oposite direction at 100% speed for 3 seconds");
	SoftPwm.softPwmWrite(MOTOR_2_PIN_A, 0);
	SoftPwm.softPwmWrite(MOTOR_2_PIN_B, 100);

	// wait 3 seconds
	Thread.sleep(3000);

	// disable motor 2
	SoftPwm.softPwmWrite(MOTOR_2_PIN_B, 0);
	motor2pinE.low();

	gpio.shutdown();
}
 

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)
    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                
}
 

public RCSwitch(Pin transmitterPin) {
    final GpioController gpio = GpioFactory.getInstance();
    this.transmitterPin = gpio.provisionDigitalOutputPin(transmitterPin);
}
 

public static void main(String[] args) throws InterruptedException {
	// get a handle to the GPIO controller
	final GpioController gpio = GpioFactory.getInstance();

	final GpioPinDigitalOutput motor1pinA = gpio.provisionDigitalOutputPin(RaspiPin.GPIO_04, "m1A");
	final GpioPinDigitalOutput motor1pinB = gpio.provisionDigitalOutputPin(RaspiPin.GPIO_05, "m1B");
	final GpioPinDigitalOutput motor1pinE = gpio.provisionDigitalOutputPin(RaspiPin.GPIO_06, "m1E");
	final GpioPinDigitalOutput motor2pinA = gpio.provisionDigitalOutputPin(RaspiPin.GPIO_00, "m2A");
	final GpioPinDigitalOutput motor2pinB = gpio.provisionDigitalOutputPin(RaspiPin.GPIO_02, "m2B");
	final GpioPinDigitalOutput motor2pinE = gpio.provisionDigitalOutputPin(RaspiPin.GPIO_03, "m2E");

	System.out.println("rotate both motors clockwise for 3 seconds");
	motor1pinA.high();
	motor1pinB.low();
	motor1pinE.high();
	motor2pinA.high();
	motor2pinB.low();
	motor2pinE.high();

	// wait 3 seconds
	Thread.sleep(3000);

	System.out.println("rotate motor 1 in oposite derection for 3 seconds "
			+ "and motor 2 in oposite direction for 6 seconds");
	motor1pinA.low();
	motor1pinB.high();
	motor2pinA.low();
	motor2pinB.high();

	// wait 3 seconds
	Thread.sleep(3000);
	System.out.println("Stopping motor 1");
	motor1pinE.low();

	// wait 3 seconds
	Thread.sleep(3000);
	System.out.println("Stopping motor 2");
	motor2pinE.low();

	gpio.shutdown();
}