com.pi4j.io.gpio.GpioController Java Examples

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        
}
 

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

private GpioPinPwmOutput[] provisionPwmOutputs(final PCA9685GpioProvider gpioProvider) {
    GpioController gpio = GpioFactory.getInstance();
    GpioPinPwmOutput myOutputs[] = {
            gpio.provisionPwmOutputPin(gpioProvider, PCA9685Pin.PWM_00, "Servo 00"),
            gpio.provisionPwmOutputPin(gpioProvider, PCA9685Pin.PWM_01, "not used"),
            gpio.provisionPwmOutputPin(gpioProvider, PCA9685Pin.PWM_02, "not used"),
            gpio.provisionPwmOutputPin(gpioProvider, PCA9685Pin.PWM_03, "not used"),
            gpio.provisionPwmOutputPin(gpioProvider, PCA9685Pin.PWM_04, "not used"),
            gpio.provisionPwmOutputPin(gpioProvider, PCA9685Pin.PWM_05, "not used"),
            gpio.provisionPwmOutputPin(gpioProvider, PCA9685Pin.PWM_06, "not used"),
            gpio.provisionPwmOutputPin(gpioProvider, PCA9685Pin.PWM_07, "not used"),
            gpio.provisionPwmOutputPin(gpioProvider, PCA9685Pin.PWM_08, "not used"),
            gpio.provisionPwmOutputPin(gpioProvider, PCA9685Pin.PWM_09, "not used"),
            gpio.provisionPwmOutputPin(gpioProvider, PCA9685Pin.PWM_10, "not used"),
            gpio.provisionPwmOutputPin(gpioProvider, PCA9685Pin.PWM_11, "not used"),
            gpio.provisionPwmOutputPin(gpioProvider, PCA9685Pin.PWM_12, "not used"),
            gpio.provisionPwmOutputPin(gpioProvider, PCA9685Pin.PWM_13, "not used"),
            gpio.provisionPwmOutputPin(gpioProvider, PCA9685Pin.PWM_14, "not used"),
            gpio.provisionPwmOutputPin(gpioProvider, PCA9685Pin.PWM_15, "not used")};
    return myOutputs;
}
 

private static GpioPinPwmOutput[] provisionPwmOutputs(final PCA9685GpioProvider gpioProvider) {
    GpioController gpio = GpioFactory.getInstance();
    GpioPinPwmOutput myOutputs[] = {
            gpio.provisionPwmOutputPin(gpioProvider, PCA9685Pin.PWM_00, "Pulse 00"),
            gpio.provisionPwmOutputPin(gpioProvider, PCA9685Pin.PWM_01, "Pulse 01"),
            gpio.provisionPwmOutputPin(gpioProvider, PCA9685Pin.PWM_02, "Pulse 02"),
            gpio.provisionPwmOutputPin(gpioProvider, PCA9685Pin.PWM_03, "Pulse 03"),
            gpio.provisionPwmOutputPin(gpioProvider, PCA9685Pin.PWM_04, "Pulse 04"),
            gpio.provisionPwmOutputPin(gpioProvider, PCA9685Pin.PWM_05, "Pulse 05"),
            gpio.provisionPwmOutputPin(gpioProvider, PCA9685Pin.PWM_06, "Pulse 06"),
            gpio.provisionPwmOutputPin(gpioProvider, PCA9685Pin.PWM_07, "Pulse 07"),
            gpio.provisionPwmOutputPin(gpioProvider, PCA9685Pin.PWM_08, "Pulse 08"),
            gpio.provisionPwmOutputPin(gpioProvider, PCA9685Pin.PWM_09, "Pulse 09"),
            gpio.provisionPwmOutputPin(gpioProvider, PCA9685Pin.PWM_10, "Always ON"),
            gpio.provisionPwmOutputPin(gpioProvider, PCA9685Pin.PWM_11, "Always OFF"),
            gpio.provisionPwmOutputPin(gpioProvider, PCA9685Pin.PWM_12, "Servo pulse MIN"),
            gpio.provisionPwmOutputPin(gpioProvider, PCA9685Pin.PWM_13, "Servo pulse NEUTRAL"),
            gpio.provisionPwmOutputPin(gpioProvider, PCA9685Pin.PWM_14, "Servo pulse MAX"),
            gpio.provisionPwmOutputPin(gpioProvider, PCA9685Pin.PWM_15, "not used")};
    return myOutputs;
}
 

Pi4jPwmOutputDevice(String key, DeviceFactoryInterface deviceFactory, GpioController gpioController,
		PwmType pwmType, int gpio, float initialValue, int range) throws RuntimeIOException {
	super(key, deviceFactory);
	
	this.pwmType = pwmType;
	this.gpio = gpio;
	this.value = initialValue;
	this.range = range;
	
	//pin = RaspiBcmPin.getPinByAddress(gpio);
	//pin.getSupportedPinModes().contains(PinMode.PWM_OUTPUT);
	
	switch (pwmType) {
	case HARDWARE:
		//pwmOutputPin = gpioController.provisionPwmOutputPin(pin, "PWM output for BCM GPIO " + gpio,
		//		Math.round(value * range));
		Gpio.pinMode(gpio, Gpio.PWM_OUTPUT);
		// Have to call this after setting the pin mode! Yuck
		Gpio.pwmSetMode(Gpio.PWM_MODE_MS);
		Gpio.pwmWrite(gpio, Math.round(initialValue * range));
		break;
	case SOFTWARE:
		//pwmOutputPin = gpioController.provisionSoftPwmOutputPin(
		//		pin, "PWM output for BCM GPIO " + gpio, Math.round(initialValue * range));
		int status = SoftPwm.softPwmCreate(gpio, Math.round(initialValue * range), range);
		if (status != 0) {
			throw new RuntimeIOException("Error setting up software controlled PWM GPIO on BCM pin " +
					gpio + ", status=" + status);
		}
	}
}
 

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--> ADS1115 GPIO Example ... started.");

    // number formatters
    final DecimalFormat df = new DecimalFormat("#.##");
    final DecimalFormat pdf = new DecimalFormat("###.#");
    
    // create gpio controller
    final GpioController gpio = GpioFactory.getInstance();
    
    // create custom ADS1115 GPIO provider
    final ADS1115GpioProvider gpioProvider = new ADS1115GpioProvider(I2CBus.BUS_1, ADS1115GpioProvider.ADS1115_ADDRESS_0x48);
    
    // provision gpio analog input pins from ADS1115
    GpioPinAnalogInput myInputs[] = {
            gpio.provisionAnalogInputPin(gpioProvider, ADS1115Pin.INPUT_A0, "MyAnalogInput-A0"),
            gpio.provisionAnalogInputPin(gpioProvider, ADS1115Pin.INPUT_A1, "MyAnalogInput-A1"),
            gpio.provisionAnalogInputPin(gpioProvider, ADS1115Pin.INPUT_A2, "MyAnalogInput-A2"),
            gpio.provisionAnalogInputPin(gpioProvider, ADS1115Pin.INPUT_A3, "MyAnalogInput-A3"),
        };
    
    // ATTENTION !!          
    // It is important to set the PGA (Programmable Gain Amplifier) for all analog input pins. 
    // (You can optionally set each input to a different value)    
    // You measured input voltage should never exceed this value!
    //
    // In my testing, I am using a Sharp IR Distance Sensor (GP2Y0A21YK0F) whose voltage never exceeds 3.3 VDC
    // (http://www.adafruit.com/products/164)
    //
    // PGA value PGA_4_096V is a 1:1 scaled input, 
    // so the output values are in direct proportion to the detected voltage on the input pins
    gpioProvider.setProgrammableGainAmplifier(ProgrammableGainAmplifierValue.PGA_4_096V, ADS1115Pin.ALL);
            
    
    // Define a threshold value for each pin for analog value change events to be raised.
    // It is important to set this threshold high enough so that you don't overwhelm your program with change events for insignificant changes
    gpioProvider.setEventThreshold(500, ADS1115Pin.ALL);

    
    // Define the monitoring thread refresh interval (in milliseconds).
    // This governs the rate at which the monitoring thread will read input values from the ADC chip
    // (a value less than 50 ms is not permitted)
    gpioProvider.setMonitorInterval(100);
    
    
    // create analog pin value change listener
    GpioPinListenerAnalog listener = new GpioPinListenerAnalog()
    {
        @Override
        public void handleGpioPinAnalogValueChangeEvent(GpioPinAnalogValueChangeEvent event)
        {
            // RAW value
            double value = event.getValue();

            // percentage
            double percent =  ((value * 100) / ADS1115GpioProvider.ADS1115_RANGE_MAX_VALUE);
            
            // approximate voltage ( *scaled based on PGA setting )
            double voltage = gpioProvider.getProgrammableGainAmplifier(event.getPin()).getVoltage() * (percent/100);

            // display output
            System.out.print("\r (" + event.getPin().getName() +") : VOLTS=" + df.format(voltage) + "  | PERCENT=" + pdf.format(percent) + "% | RAW=" + value + "       ");
        }
    };
    
    myInputs[0].addListener(listener);
    myInputs[1].addListener(listener);
    myInputs[2].addListener(listener);
    myInputs[3].addListener(listener);
    
    // keep program running for 10 minutes 
    for (int count = 0; count < 600; count++) {

        // display output
        //System.out.print("\r ANALOG VALUE (FOR INPUT A0) : VOLTS=" + df.format(voltage) + "  | PERCENT=" + pdf.format(percent) + "% | RAW=" + value + "       ");
        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.print("");
    System.out.print("");
}
 

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 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 and register gpio pin listener
    myButton.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());
        }
        
    });
    
    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)
    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 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 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();
}
 

@Override
public void stop(LocalDateTime now) {
    logger.debug("{}: Stopping {} for {}", getApplianceId(), getClass().getSimpleName(), getGpio());
    GpioController gpioController = getGpioController();
    if(gpioController != null) {
        gpioController.unprovisionPin(inputPin);
    }
    else {
        logGpioAccessDisabled(logger);
    }
}
 

private GpioController getGpioController() {
    if(System.getProperty("os.arch").equals("arm")) {
        try {
            return GpioFactory.getInstance();
        }
        catch(Error e) {
            // warning will be logged later on only if GPIO access is required
        }
    }
    else {
        logger.warn("GPIO access disabled - not running on Raspberry Pi.");
    }
    return null;
}
 

@Override
public void stop(LocalDateTime now) {
    logger.debug("{}: Stopping {} for {}", getApplianceId(), getClass().getSimpleName(), getGpio());
    GpioController gpioController = getGpioController();
    if (gpioController != null) {
        gpioController.unprovisionPin(outputPin);
    } else {
        logGpioAccessDisabled(logger);
    }
}
 

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

@Override
public void start(LocalDateTime now, Timer timer) {
    logger.debug("{}: Starting {} for {}", getApplianceId(), getClass().getSimpleName(), getGpio());
    GpioController gpioController = getGpioController();
    if(gpioController != null) {
        try {
            inputPin = gpioController.provisionDigitalInputPin(getGpio(), getPinPullResistance());
            inputPin.addListener(new GpioPinListenerDigital() {
                @Override
                public void handleGpioPinDigitalStateChangeEvent(GpioPinDigitalStateChangeEvent event) {
                    logger.debug("{}: GPIO {} changed to {}", getApplianceId(), event.getPin(), event.getState());
                    if(event.getState() == PinState.HIGH) {
                        pulsePowerMeter.addTimestampAndMaintain(System.currentTimeMillis());
                        pulseEnergyMeter.increasePulseCounter();
                        powerMeterListeners.forEach(listener -> listener.onPowerUpdate(getAveragePower()));
                    }
                }
            });
            logger.debug("{}: {} uses {}", getApplianceId(), getClass().getSimpleName(), getGpio());
        }
        catch(Exception e) {
            logger.error("{}: Error start metering using {}", getApplianceId(), getGpio(), e);
        }
    }
    else {
        logGpioAccessDisabled(logger);
    }
}
 

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--> ADS1015 Distance Sensor Example ... started.");

    // number formatters
    final DecimalFormat df = new DecimalFormat("#.##");
    final DecimalFormat pdf = new DecimalFormat("###.#");
    
    // create gpio controller
    final GpioController gpio = GpioFactory.getInstance();
    
    // create custom ADS1015 GPIO provider
    final ADS1015GpioProvider gpioProvider = new ADS1015GpioProvider(I2CBus.BUS_1, ADS1015GpioProvider.ADS1015_ADDRESS_0x48);
    
    // provision gpio analog input pins from ADS1015
    final GpioPinAnalogInput distanceSensorPin = gpio.provisionAnalogInputPin(gpioProvider, ADS1015Pin.INPUT_A0, "DistanceSensor-A0");
    
    // ATTENTION !!          
    // It is important to set the PGA (Programmable Gain Amplifier) for all analog input pins. 
    // (You can optionally set each input to a different value)    
    // You measured input voltage should never exceed this value!
    //
    // In my testing, I am using a Sharp IR Distance Sensor (GP2Y0A21YK0F) whose voltage never exceeds 3.3 VDC
    // (http://www.adafruit.com/products/164)
    //
    // PGA value PGA_4_096V is a 1:1 scaled input, 
    // so the output values are in direct proportion to the detected voltage on the input pins
    gpioProvider.setProgrammableGainAmplifier(ProgrammableGainAmplifierValue.PGA_4_096V, ADS1015Pin.ALL);
            
    
    // Define a threshold value for each pin for analog value change events to be raised.
    // It is important to set this threshold high enough so that you don't overwhelm your program with change events for insignificant changes
    gpioProvider.setEventThreshold(150, ADS1015Pin.ALL);

    
    // Define the monitoring thread refresh interval (in milliseconds).
    // This governs the rate at which the monitoring thread will read input values from the ADC chip
    // (a value less than 50 ms is not permitted)
    gpioProvider.setMonitorInterval(100);
    
    // create a distance sensor based on an analog input pin
    DistanceSensorComponent distanceSensor = new DistanceSensorComponent(distanceSensorPin);
    
    // build a distance coordinates mapping (estimated distance at raw values)
    distanceSensor.addCalibrationCoordinate(21600, 13);
    distanceSensor.addCalibrationCoordinate(21500, 14);
    distanceSensor.addCalibrationCoordinate(21400, 15);
    distanceSensor.addCalibrationCoordinate(21200, 16);
    distanceSensor.addCalibrationCoordinate(21050, 17);
    distanceSensor.addCalibrationCoordinate(20900, 18); 
    distanceSensor.addCalibrationCoordinate(20500, 19);
    distanceSensor.addCalibrationCoordinate(20000, 20); 
    distanceSensor.addCalibrationCoordinate(15000, 30);  
    distanceSensor.addCalibrationCoordinate(12000, 40); 
    distanceSensor.addCalibrationCoordinate(9200,  50); 
    distanceSensor.addCalibrationCoordinate(8200,  60); 
    distanceSensor.addCalibrationCoordinate(6200,  70); 
    distanceSensor.addCalibrationCoordinate(4200,  80); 

    distanceSensor.addListener(new DistanceSensorListener()
    {
        @Override
        public void onDistanceChange(DistanceSensorChangeEvent event)
        {
            // RAW value
            double value = event.getRawValue();

            // Estimated distance
            double distance =  event.getDistance();
            
            // percentage
            double percent =  ((value * 100) / ADS1015GpioProvider.ADS1015_RANGE_MAX_VALUE);
            
            // approximate voltage ( *scaled based on PGA setting )
            double voltage = gpioProvider.getProgrammableGainAmplifier(distanceSensorPin).getVoltage() * (percent/100);

            // display output
            System.out.print("\r DISTANCE=" + df.format(distance) + "cm : VOLTS=" + df.format(voltage) + "  | PERCENT=" + pdf.format(percent) + "% | RAW=" + value + "       ");
        }
    });
    
    // keep program running for 10 minutes 
    for (int count = 0; count < 600; count++) {
        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.print("");
}
 

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, IOException {
    
    System.out.println("<--Pi4J--> ADS1115 Distance Sensor Example ... started.");

    // number formatters
    final DecimalFormat df = new DecimalFormat("#.##");
    final DecimalFormat pdf = new DecimalFormat("###.#");
    
    // create gpio controller
    final GpioController gpio = GpioFactory.getInstance();
    
    // create custom ADS1115 GPIO provider
    final ADS1115GpioProvider gpioProvider = new ADS1115GpioProvider(I2CBus.BUS_1, ADS1115GpioProvider.ADS1115_ADDRESS_0x48);
    
    // provision gpio analog input pins from ADS1115
    final GpioPinAnalogInput distanceSensorPin = gpio.provisionAnalogInputPin(gpioProvider, ADS1115Pin.INPUT_A0, "DistanceSensor-A0");
    
    // ATTENTION !!          
    // It is important to set the PGA (Programmable Gain Amplifier) for all analog input pins. 
    // (You can optionally set each input to a different value)    
    // You measured input voltage should never exceed this value!
    //
    // In my testing, I am using a Sharp IR Distance Sensor (GP2Y0A21YK0F) whose voltage never exceeds 3.3 VDC
    // (http://www.adafruit.com/products/164)
    //
    // PGA value PGA_4_096V is a 1:1 scaled input, 
    // so the output values are in direct proportion to the detected voltage on the input pins
    gpioProvider.setProgrammableGainAmplifier(ProgrammableGainAmplifierValue.PGA_4_096V, ADS1115Pin.ALL);
            
    
    // Define a threshold value for each pin for analog value change events to be raised.
    // It is important to set this threshold high enough so that you don't overwhelm your program with change events for insignificant changes
    gpioProvider.setEventThreshold(150, ADS1115Pin.ALL);

    
    // Define the monitoring thread refresh interval (in milliseconds).
    // This governs the rate at which the monitoring thread will read input values from the ADC chip
    // (a value less than 50 ms is not permitted)
    gpioProvider.setMonitorInterval(100);
    
    // create a distance sensor based on an analog input pin
    DistanceSensorComponent distanceSensor = new DistanceSensorComponent(distanceSensorPin);
    
    // build a distance coordinates mapping (estimated distance at raw values)
    distanceSensor.addCalibrationCoordinate(21600, 13);
    distanceSensor.addCalibrationCoordinate(21500, 14);
    distanceSensor.addCalibrationCoordinate(21400, 15);
    distanceSensor.addCalibrationCoordinate(21200, 16);
    distanceSensor.addCalibrationCoordinate(21050, 17);
    distanceSensor.addCalibrationCoordinate(20900, 18); 
    distanceSensor.addCalibrationCoordinate(20500, 19);
    distanceSensor.addCalibrationCoordinate(20000, 20); 
    distanceSensor.addCalibrationCoordinate(15000, 30);  
    distanceSensor.addCalibrationCoordinate(12000, 40); 
    distanceSensor.addCalibrationCoordinate(9200,  50); 
    distanceSensor.addCalibrationCoordinate(8200,  60); 
    distanceSensor.addCalibrationCoordinate(6200,  70); 
    distanceSensor.addCalibrationCoordinate(4200,  80); 

    distanceSensor.addListener(new DistanceSensorListener()
    {
        @Override
        public void onDistanceChange(DistanceSensorChangeEvent event)
        {
            // RAW value
            double value = event.getRawValue();

            // Estimated distance
            double distance =  event.getDistance();
            
            // percentage
            double percent =  ((value * 100) / ADS1115GpioProvider.ADS1115_RANGE_MAX_VALUE);
            
            // approximate voltage ( *scaled based on PGA setting )
            double voltage = gpioProvider.getProgrammableGainAmplifier(distanceSensorPin).getVoltage() * (percent/100);

            // display output
            System.out.print("\r DISTANCE=" + df.format(distance) + "cm : VOLTS=" + df.format(voltage) + "  | PERCENT=" + pdf.format(percent) + "% | RAW=" + value + "       ");
        }
    });
    
    // keep program running for 10 minutes 
    for (int count = 0; count < 600; count++) {
        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.print("");
}
 

public GpioController getGpioController() {
  return gpioController;
}
 

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 {

        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, IOException {
    
    System.out.println("<--Pi4J--> ADS1015 GPIO Example ... started.");

    // number formatters
    final DecimalFormat df = new DecimalFormat("#.##");
    final DecimalFormat pdf = new DecimalFormat("###.#");
    
    // create gpio controller
    final GpioController gpio = GpioFactory.getInstance();
    
    // create custom ADS1015 GPIO provider
    final ADS1015GpioProvider gpioProvider = new ADS1015GpioProvider(I2CBus.BUS_1, ADS1015GpioProvider.ADS1015_ADDRESS_0x48);
    
    // provision gpio analog input pins from ADS1015
    GpioPinAnalogInput myInputs[] = {
            gpio.provisionAnalogInputPin(gpioProvider, ADS1015Pin.INPUT_A0, "MyAnalogInput-A0"),
            gpio.provisionAnalogInputPin(gpioProvider, ADS1015Pin.INPUT_A1, "MyAnalogInput-A1"),
            gpio.provisionAnalogInputPin(gpioProvider, ADS1015Pin.INPUT_A2, "MyAnalogInput-A2"),
            gpio.provisionAnalogInputPin(gpioProvider, ADS1015Pin.INPUT_A3, "MyAnalogInput-A3"),
        };
    
    // ATTENTION !!          
    // It is important to set the PGA (Programmable Gain Amplifier) for all analog input pins. 
    // (You can optionally set each input to a different value)    
    // You measured input voltage should never exceed this value!
    //
    // In my testing, I am using a Sharp IR Distance Sensor (GP2Y0A21YK0F) whose voltage never exceeds 3.3 VDC
    // (http://www.adafruit.com/products/164)
    //
    // PGA value PGA_4_096V is a 1:1 scaled input, 
    // so the output values are in direct proportion to the detected voltage on the input pins
    gpioProvider.setProgrammableGainAmplifier(ProgrammableGainAmplifierValue.PGA_4_096V, ADS1015Pin.ALL);
            
    
    // Define a threshold value for each pin for analog value change events to be raised.
    // It is important to set this threshold high enough so that you don't overwhelm your program with change events for insignificant changes
    gpioProvider.setEventThreshold(500, ADS1015Pin.ALL);

    
    // Define the monitoring thread refresh interval (in milliseconds).
    // This governs the rate at which the monitoring thread will read input values from the ADC chip
    // (a value less than 50 ms is not permitted)
    gpioProvider.setMonitorInterval(100);
    
    
    // create analog pin value change listener
    GpioPinListenerAnalog listener = new GpioPinListenerAnalog()
    {
        @Override
        public void handleGpioPinAnalogValueChangeEvent(GpioPinAnalogValueChangeEvent event)
        {
            // RAW value
            double value = event.getValue();

            // percentage
            double percent =  ((value * 100) / ADS1015GpioProvider.ADS1015_RANGE_MAX_VALUE);
            
            // approximate voltage ( *scaled based on PGA setting )
            double voltage = gpioProvider.getProgrammableGainAmplifier(event.getPin()).getVoltage() * (percent/100);

            // display output
            System.out.print("\r (" + event.getPin().getName() +") : VOLTS=" + df.format(voltage) + "  | PERCENT=" + pdf.format(percent) + "% | RAW=" + value + "       ");
        }
    };
    
    myInputs[0].addListener(listener);
    myInputs[1].addListener(listener);
    myInputs[2].addListener(listener);
    myInputs[3].addListener(listener);
    
    // keep program running for 10 minutes 
    for (int count = 0; count < 600; count++) {

        // display output
        //System.out.print("\r ANALOG VALUE (FOR INPUT A0) : VOLTS=" + df.format(voltage) + "  | PERCENT=" + pdf.format(percent) + "% | RAW=" + value + "       ");
        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.print("");
    System.out.print("");
}
 

public static void main(String args[]) throws InterruptedException {
    
    System.out.println("<--Pi4J--> GPIO Listen Example ... started.");
    
    // create GPIO controller
    final GpioController gpio = GpioFactory.getInstance();

    // create GPIO 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());
        }        
    };
    
    // provision gpio input pins with its internal pull down resistor enabled
    GpioPinDigitalInput[] pins = {
        gpio.provisionDigitalInputPin(RaspiPin.GPIO_00, PinPullResistance.PULL_DOWN),
        gpio.provisionDigitalInputPin(RaspiPin.GPIO_01, PinPullResistance.PULL_DOWN),
        gpio.provisionDigitalInputPin(RaspiPin.GPIO_02, PinPullResistance.PULL_DOWN),
        gpio.provisionDigitalInputPin(RaspiPin.GPIO_03, PinPullResistance.PULL_DOWN),
        gpio.provisionDigitalInputPin(RaspiPin.GPIO_04, PinPullResistance.PULL_DOWN),
        gpio.provisionDigitalInputPin(RaspiPin.GPIO_05, PinPullResistance.PULL_DOWN),
        gpio.provisionDigitalInputPin(RaspiPin.GPIO_06, PinPullResistance.PULL_DOWN),
        gpio.provisionDigitalInputPin(RaspiPin.GPIO_07, PinPullResistance.PULL_DOWN)
    };

    // create and register gpio pin listener
    gpio.addListener(listener, pins);
    
    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)
    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 {
	// 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();
}