package com.pi4j.io.gpio.impl;
/*
* #%L
* **********************************************************************
* ORGANIZATION : Pi4J
* PROJECT : Pi4J :: Java Library (Core)
* FILENAME : GpioControllerImpl.java
*
* This file is part of the Pi4J project. More information about
* this project can be found here: http://www.pi4j.com/
* **********************************************************************
* %%
* Copyright (C) 2012 - 2014 Pi4J
* %%
* Licensed under the Apache License, Version 2.0 (the "License"); you
* may not use this file except in compliance with the License. You may obtain a copy of the License
* at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the License
* is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
* or implied. See the License for the specific language governing permissions and limitations under
* the License.
* #L%
*/
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import com.pi4j.io.gpio.GpioController;
import com.pi4j.io.gpio.GpioPinAnalog;
import com.pi4j.io.gpio.GpioPinAnalogInput;
import com.pi4j.io.gpio.GpioPinAnalogOutput;
import com.pi4j.io.gpio.GpioPinDigitalInput;
import com.pi4j.io.gpio.GpioPinDigitalMultipurpose;
import com.pi4j.io.gpio.GpioPinDigitalOutput;
import com.pi4j.io.gpio.GpioPinDigital;
import com.pi4j.io.gpio.GpioFactory;
import com.pi4j.io.gpio.GpioPin;
import com.pi4j.io.gpio.GpioPinInput;
import com.pi4j.io.gpio.GpioPinPwmOutput;
import com.pi4j.io.gpio.GpioPinShutdown;
import com.pi4j.io.gpio.GpioProvider;
import com.pi4j.io.gpio.Pin;
import com.pi4j.io.gpio.PinMode;
import com.pi4j.io.gpio.PinPullResistance;
import com.pi4j.io.gpio.PinState;
import com.pi4j.io.gpio.event.GpioPinListener;
import com.pi4j.io.gpio.exception.GpioPinExistsException;
import com.pi4j.io.gpio.exception.GpioPinNotProvisionedException;
import com.pi4j.io.gpio.trigger.GpioTrigger;
public class GpioControllerImpl implements GpioController {
private final List<GpioPin> pins = Collections.synchronizedList(new ArrayList<GpioPin>());
private final GpioProvider defaultProvider;
private boolean isshutdown = false;
/**
* Default Constructor
*/
public GpioControllerImpl() {
// set the local default provider reference
this(GpioFactory.getDefaultProvider());
}
/**
* Default Constructor
*/
public GpioControllerImpl(GpioProvider provider) {
// set the local default provider reference
defaultProvider = provider;
// register shutdown callback hook class
Runtime.getRuntime().addShutdownHook(new ShutdownHook());
}
@Override
public Collection<GpioPin> getProvisionedPins() {
return pins;
}
@Override
public void unexportAll() {
// un-export all GPIO pins that are currently exported
for (GpioPin pin : pins) {
if (pin.isExported()) {
pin.unexport();
}
}
}
@Override
public void export(PinMode mode, GpioPin... pin) {
if (pin == null || pin.length == 0) {
throw new IllegalArgumentException("Missing pin argument.");
}
for (GpioPin p : pin) {
// ensure the requested pin has been provisioned
if (!pins.contains(p)) {
throw new GpioPinNotProvisionedException(p.getPin());
}
// export the pin
p.export(mode);
}
}
/**
*
* @param pin
* @return <p>
* A value of 'true' is returned if the requested pin is exported.
* </p>
*/
@Override
public boolean isExported(GpioPin... pin) {
if (pin == null || pin.length == 0) {
throw new IllegalArgumentException("Missing pin argument.");
}
for (GpioPin p : pin) {
// ensure the requested pin has been provisioned
if (!pins.contains(pin)) {
throw new GpioPinNotProvisionedException(p.getPin());
}
if (!p.isExported()) {
return false;
}
}
// return the pin exported state
return true;
}
@Override
public void unexport(GpioPin... pin) {
if (pin == null || pin.length == 0) {
throw new IllegalArgumentException("Missing pin argument.");
}
for (GpioPin p : pin) {
// ensure the requested pin has been provisioned
if (!pins.contains(p)) {
throw new GpioPinNotProvisionedException(p.getPin());
}
// unexport the pin
p.unexport();
}
}
@Override
public PinMode getMode(GpioPin pin) {
// ensure the requested pin has been provisioned
if (!pins.contains(pin)) {
throw new GpioPinNotProvisionedException(pin.getPin());
}
// return pin edge setting
return pin.getMode();
}
@Override
public boolean isMode(PinMode mode, GpioPin... pin) {
if (pin == null || pin.length == 0) {
throw new IllegalArgumentException("Missing pin argument.");
}
for (GpioPin p : pin) {
if (!p.isMode(mode)) {
return false;
}
}
return true;
}
@Override
public void setMode(PinMode mode, GpioPin... pin) {
if (pin == null || pin.length == 0) {
throw new IllegalArgumentException("Missing pin argument.");
}
for (GpioPin p : pin) {
// ensure the requested pin has been provisioned
if (!pins.contains(pin)) {
throw new GpioPinNotProvisionedException(p.getPin());
}
// set pin mode
p.setMode(mode);
}
}
@Override
public void setPullResistance(PinPullResistance resistance, GpioPin... pin) {
if (pin == null || pin.length == 0) {
throw new IllegalArgumentException("Missing pin argument.");
}
for (GpioPin p : pin) {
// ensure the requested pin has been provisioned
if (!pins.contains(p)) {
throw new GpioPinNotProvisionedException(p.getPin());
}
// set pin pull resistance
p.setPullResistance(resistance);
}
}
@Override
public PinPullResistance getPullResistance(GpioPin pin) {
// ensure the requested pin has been provisioned
if (!pins.contains(pin)) {
throw new GpioPinNotProvisionedException(pin.getPin());
}
// get pin pull resistance
return pin.getPullResistance();
}
@Override
public boolean isPullResistance(PinPullResistance resistance, GpioPin... pin) {
if (pin == null || pin.length == 0) {
throw new IllegalArgumentException("Missing pin argument.");
}
for (GpioPin p : pin) {
// ensure the requested pin has been provisioned
if (!pins.contains(p)) {
throw new GpioPinNotProvisionedException(p.getPin());
}
// set pin pull resistance
if(!p.isPullResistance(resistance))
return false;
}
return true;
}
@Override
public void high(GpioPinDigitalOutput... pin) {
if (pin == null || pin.length == 0) {
throw new IllegalArgumentException("Missing pin argument.");
}
// ensure the requested pin has been provisioned
for (GpioPinDigitalOutput p : pin) {
if (!pins.contains(pin)) {
throw new GpioPinNotProvisionedException(p.getPin());
}
// set pin state high
p.high();
}
}
@Override
public void low(GpioPinDigitalOutput... pin) {
if (pin == null || pin.length == 0) {
throw new IllegalArgumentException("Missing pin argument.");
}
// ensure the requested pin has been provisioned
for (GpioPinDigitalOutput p : pin) {
if (!pins.contains(p)) {
throw new GpioPinNotProvisionedException(p.getPin());
}
// set pin state low
p.low();
}
}
@Override
public boolean isHigh(GpioPinDigital... pin) {
if (pin == null || pin.length == 0) {
throw new IllegalArgumentException("Missing pin argument.");
}
for (GpioPinDigital p : pin) {
if (p.isLow()) {
return false;
}
}
return true;
}
@Override
public boolean isLow(GpioPinDigital... pin) {
if (pin == null || pin.length == 0) {
throw new IllegalArgumentException("Missing pin argument.");
}
for (GpioPinDigital p : pin) {
if (p.isHigh()) {
return false;
}
}
return true;
}
@Override
public void toggle(GpioPinDigitalOutput... pin) {
if (pin == null || pin.length == 0) {
throw new IllegalArgumentException("Missing pin argument.");
}
for (GpioPinDigitalOutput p : pin) {
// ensure the requested pin has been provisioned
if (!pins.contains(p)) {
throw new GpioPinNotProvisionedException(p.getPin());
}
// toggle pin state
p.toggle();
}
}
@Override
public void pulse(long milliseconds, GpioPinDigitalOutput... pin) {
if (pin == null || pin.length == 0) {
throw new IllegalArgumentException("Missing pin argument.");
}
for (GpioPinDigitalOutput p : pin) {
// ensure the requested pin has been provisioned
if (!pins.contains(p)) {
throw new GpioPinNotProvisionedException(p.getPin());
}
// toggle pin state
p.pulse(milliseconds);
}
}
@Override
public void setState(PinState state, GpioPinDigitalOutput... pin) {
if (pin == null || pin.length == 0) {
throw new IllegalArgumentException("Missing pin argument.");
}
for (GpioPinDigitalOutput p : pin) {
// ensure the requested pin has been provisioned
if (!pins.contains(p)) {
throw new GpioPinNotProvisionedException(p.getPin());
}
// set pin state
p.setState(state);
}
}
@Override
public void setState(boolean state, GpioPinDigitalOutput... pin) {
setState((state) ? PinState.HIGH : PinState.LOW, pin);
}
@Override
public PinState getState(GpioPinDigital pin) {
// ensure the requested pin has been provisioned
if (!pins.contains(pin)) {
throw new GpioPinNotProvisionedException(pin.getPin());
}
// return pin state
return pin.getState();
}
@Override
public boolean isState(PinState state, GpioPinDigital... pin) {
if (pin == null || pin.length == 0) {
throw new IllegalArgumentException("Missing pin argument.");
}
for (GpioPinDigital p : pin) {
if (!p.isState(state)) {
return false;
}
}
return true;
}
@Override
public void setValue(double value, GpioPinAnalogOutput... pin) {
if (pin == null || pin.length == 0) {
throw new IllegalArgumentException("Missing pin argument.");
}
for (GpioPinAnalogOutput p : pin) {
// ensure the requested pin has been provisioned
if (!pins.contains(p)) {
throw new GpioPinNotProvisionedException(p.getPin());
}
// set pin PWM value
p.setValue(value);
}
}
@Override
public double getValue(GpioPinAnalog pin) {
return pin.getValue();
}
@Override
public synchronized void addListener(GpioPinListener listener, GpioPinInput... pin) {
if (pin == null || pin.length == 0) {
throw new IllegalArgumentException("Missing pin argument.");
}
for (GpioPinInput p : pin) {
// ensure the requested pin has been provisioned
if (!pins.contains(p)) {
throw new GpioPinNotProvisionedException(p.getPin());
}
p.addListener(listener);
}
}
@Override
public synchronized void addListener(GpioPinListener[] listeners, GpioPinInput... pin) {
if (pin == null || pin.length == 0) {
throw new IllegalArgumentException("Missing pin argument.");
}
for (GpioPinListener listener: listeners) {
addListener(listener, pin);
}
}
@Override
public synchronized void removeListener(GpioPinListener listener, GpioPinInput... pin) {
if (pin == null || pin.length == 0) {
throw new IllegalArgumentException("Missing pin argument.");
}
for (GpioPinInput p : pin) {
// ensure the requested pin has been provisioned
if (!pins.contains(p)) {
throw new GpioPinNotProvisionedException(p.getPin());
}
p.removeListener(listener);
}
}
@Override
public synchronized void removeListener(GpioPinListener[] listeners, GpioPinInput... pin) {
if(pin == null || pin.length == 0) {
throw new IllegalArgumentException("Missing pin argument.");
}
for (GpioPinListener listener : listeners) {
removeListener(listener, pin);
}
}
@Override
public synchronized void removeAllListeners() {
for (GpioPin pin : this.pins) {
if (pin instanceof GpioPinInput) {
((GpioPinInput)pin).removeAllListeners();
}
}
}
@Override
public synchronized void addTrigger(GpioTrigger trigger, GpioPinInput... pin) {
if (pin == null || pin.length == 0) {
throw new IllegalArgumentException("Missing pin argument.");
}
for (GpioPinInput p : pin) {
// ensure the requested pin has been provisioned
if (!pins.contains(p)) {
throw new GpioPinNotProvisionedException(p.getPin());
}
p.addTrigger(trigger);
}
}
@Override
public synchronized void addTrigger(GpioTrigger[] triggers, GpioPinInput... pin) {
if (pin == null || pin.length == 0) {
throw new IllegalArgumentException("Missing pin argument.");
}
for (GpioTrigger trigger : triggers) {
addTrigger(trigger, pin);
}
}
@Override
public synchronized void removeTrigger(GpioTrigger trigger, GpioPinInput... pin) {
if (pin == null || pin.length == 0) {
throw new IllegalArgumentException("Missing pin argument.");
}
for (GpioPinInput p : pin) {
// ensure the requested pin has been provisioned
if (!pins.contains(p)) {
throw new GpioPinNotProvisionedException(p.getPin());
}
p.removeTrigger(trigger);
}
}
@Override
public synchronized void removeTrigger(GpioTrigger[] triggers, GpioPinInput... pin) {
if (pin == null || pin.length == 0) {
throw new IllegalArgumentException("Missing pin argument.");
}
for (GpioTrigger trigger : triggers) {
removeTrigger(trigger, pin);
}
}
@Override
public synchronized void removeAllTriggers() {
for (GpioPin pin : this.pins) {
if (pin instanceof GpioPinInput) {
((GpioPinInput)pin).removeAllTriggers();
}
}
}
@Override
public GpioPin provisionPin(GpioProvider provider, Pin pin, PinMode mode) {
return provisionPin(provider, pin, pin.getName(), mode);
}
@Override
public GpioPin provisionPin(GpioProvider provider, Pin pin, String name, PinMode mode) {
// if an existing pin has been previously created, then throw an error
for(GpioPin p : pins) {
if (p.getProvider().equals(provider) && p.getPin().equals(pin)) {
throw new GpioPinExistsException(pin);
}
}
// create new GPIO pin instance
GpioPin gpioPin = new GpioPinImpl(this, provider, pin);
// set the gpio pin name
if (name != null) {
gpioPin.setName(name);
}
// export this pin
gpioPin.export(mode);
// add this new pin instance to the managed collection
pins.add(gpioPin);
// return new new pin instance
return gpioPin;
}
@Override
public GpioPin provisionPin(Pin pin, String name, PinMode mode) {
return provisionPin(defaultProvider, pin, name, mode);
}
@Override
public GpioPin provisionPin(Pin pin, PinMode mode) {
return provisionPin(defaultProvider, pin, mode);
}
@Override
public GpioPinDigitalMultipurpose provisionDigitalMultipurposePin(GpioProvider provider, Pin pin, String name, PinMode mode) {
// return new new pin instance
return (GpioPinDigitalMultipurpose)provisionPin(provider, pin, name, mode);
}
@Override
public GpioPinDigitalMultipurpose provisionDigitalMultipurposePin(GpioProvider provider, Pin pin, PinMode mode) {
// return new new pin instance
return (GpioPinDigitalMultipurpose)provisionPin(provider, pin, mode);
}
@Override
public GpioPinDigitalMultipurpose provisionDigitalMultipurposePin(Pin pin, String name, PinMode mode) {
return provisionDigitalMultipurposePin(defaultProvider, pin, name, mode);
}
@Override
public GpioPinDigitalMultipurpose provisionDigitalMultipurposePin(Pin pin, PinMode mode) {
return provisionDigitalMultipurposePin(defaultProvider, pin, mode);
}
@Override
public GpioPinDigitalMultipurpose provisionDigitalMultipurposePin(GpioProvider provider, Pin pin, PinMode mode, PinPullResistance resistance) {
// create new GPIO pin instance
return provisionDigitalMultipurposePin(provider, pin, pin.getName(), mode, resistance);
}
@Override
public GpioPinDigitalMultipurpose provisionDigitalMultipurposePin(GpioProvider provider, Pin pin, String name, PinMode mode, PinPullResistance resistance) {
// create new GPIO pin instance
GpioPinDigitalMultipurpose gpioPin = provisionDigitalMultipurposePin(provider, pin, name, mode);
// set the gpio pull resistor
if (resistance != null) {
gpioPin.setPullResistance(resistance);
}
// return new new pin instance
return gpioPin;
}
@Override
public GpioPinDigitalMultipurpose provisionDigitalMultipurposePin(Pin pin, String name, PinMode mode, PinPullResistance resistance) {
return provisionDigitalMultipurposePin(defaultProvider, pin, name, mode, resistance);
}
@Override
public GpioPinDigitalMultipurpose provisionDigitalMultipurposePin(Pin pin, PinMode mode, PinPullResistance resistance) {
return provisionDigitalMultipurposePin(defaultProvider, pin, mode, resistance);
}
@Override
public GpioPinDigitalInput provisionDigitalInputPin(GpioProvider provider, Pin pin, String name) {
// return new new pin instance
return (GpioPinDigitalInput)provisionPin(provider, pin, name, PinMode.DIGITAL_INPUT);
}
@Override
public GpioPinDigitalInput provisionDigitalInputPin(GpioProvider provider, Pin pin) {
// return new new pin instance
return (GpioPinDigitalInput)provisionPin(provider, pin, PinMode.DIGITAL_INPUT);
}
@Override
public GpioPinDigitalInput provisionDigitalInputPin(Pin pin, String name) {
return provisionDigitalInputPin(defaultProvider, pin, name);
}
@Override
public GpioPinDigitalInput provisionDigitalInputPin(Pin pin) {
return provisionDigitalInputPin(defaultProvider, pin);
}
@Override
public GpioPinDigitalInput provisionDigitalInputPin(GpioProvider provider, Pin pin, PinPullResistance resistance) {
// create new GPIO pin instance
return provisionDigitalInputPin(provider, pin, pin.getName(), resistance);
}
@Override
public GpioPinDigitalInput provisionDigitalInputPin(GpioProvider provider, Pin pin, String name, PinPullResistance resistance) {
// create new GPIO pin instance
GpioPinDigitalInput gpioPin = provisionDigitalInputPin(provider, pin, name);
// set the gpio pull resistor
if (resistance != null) {
gpioPin.setPullResistance(resistance);
}
// return new new pin instance
return gpioPin;
}
@Override
public GpioPinDigitalInput provisionDigitalInputPin(Pin pin, String name, PinPullResistance resistance) {
return provisionDigitalInputPin(defaultProvider, pin, name, resistance);
}
@Override
public GpioPinDigitalInput provisionDigitalInputPin(Pin pin, PinPullResistance resistance) {
return provisionDigitalInputPin(defaultProvider, pin, resistance);
}
@Override
public GpioPinDigitalOutput provisionDigitalOutputPin(GpioProvider provider, Pin pin, String name) {
// return new new pin instance
return (GpioPinDigitalOutput)provisionPin(provider, pin, name, PinMode.DIGITAL_OUTPUT);
}
@Override
public GpioPinDigitalOutput provisionDigitalOutputPin(GpioProvider provider, Pin pin) {
// return new new pin instance
return (GpioPinDigitalOutput)provisionPin(provider, pin, PinMode.DIGITAL_OUTPUT);
}
@Override
public GpioPinDigitalOutput provisionDigitalOutputPin(Pin pin, String name) {
return provisionDigitalOutputPin(defaultProvider, pin, name);
}
@Override
public GpioPinDigitalOutput provisionDigitalOutputPin(Pin pin) {
return provisionDigitalOutputPin(defaultProvider, pin);
}
@Override
public GpioPinDigitalOutput provisionDigitalOutputPin(GpioProvider provider, Pin pin, PinState defaultState) {
return provisionDigitalOutputPin(provider, pin, pin.getName(), defaultState);
}
@Override
public GpioPinDigitalOutput provisionDigitalOutputPin(GpioProvider provider, Pin pin, String name, PinState defaultState) {
// create new GPIO pin instance
GpioPinDigitalOutput gpioPin = provisionDigitalOutputPin(provider, pin, name);
// apply default state
if (defaultState != null) {
gpioPin.setState(defaultState);
}
// return new new pin instance
return gpioPin;
}
@Override
public GpioPinDigitalOutput provisionDigitalOutputPin(Pin pin, String name, PinState defaultState) {
return provisionDigitalOutputPin(defaultProvider, pin, name, defaultState);
}
@Override
public GpioPinDigitalOutput provisionDigitalOutputPin(Pin pin, PinState defaultState) {
return provisionDigitalOutputPin(defaultProvider, pin, defaultState);
}
@Override
public GpioPinAnalogInput provisionAnalogInputPin(GpioProvider provider, Pin pin, String name) {
// return new new pin instance
return (GpioPinAnalogInput)provisionPin(provider, pin, name, PinMode.ANALOG_INPUT);
}
@Override
public GpioPinAnalogInput provisionAnalogInputPin(GpioProvider provider, Pin pin) {
// return new new pin instance
return (GpioPinAnalogInput)provisionPin(provider, pin, PinMode.ANALOG_INPUT);
}
@Override
public GpioPinAnalogInput provisionAnalogInputPin(Pin pin, String name) {
return provisionAnalogInputPin(defaultProvider, pin, name);
}
@Override
public GpioPinAnalogInput provisionAnalogInputPin(Pin pin) {
return provisionAnalogInputPin(defaultProvider, pin);
}
@Override
public GpioPinAnalogOutput provisionAnalogOutputPin(GpioProvider provider, Pin pin, String name) {
// return new new pin instance
return (GpioPinAnalogOutput)provisionPin(provider, pin, name, PinMode.ANALOG_OUTPUT);
}
@Override
public GpioPinAnalogOutput provisionAnalogOutputPin(GpioProvider provider, Pin pin) {
// return new new pin instance
return (GpioPinAnalogOutput)provisionPin(provider, pin, PinMode.ANALOG_OUTPUT);
}
@Override
public GpioPinAnalogOutput provisionAnalogOutputPin(Pin pin, String name) {
return provisionAnalogOutputPin(defaultProvider, pin, name);
}
@Override
public GpioPinAnalogOutput provisionAnalogOutputPin(Pin pin) {
return provisionAnalogOutputPin(defaultProvider, pin);
}
@Override
public GpioPinAnalogOutput provisionAnalogOutputPin(GpioProvider provider, Pin pin, double defaultValue) {
return provisionAnalogOutputPin(provider, pin, pin.getName(), defaultValue);
}
@Override
public GpioPinAnalogOutput provisionAnalogOutputPin(GpioProvider provider, Pin pin, String name, double defaultValue) {
// create new GPIO pin instance
GpioPinAnalogOutput gpioPin = provisionAnalogOutputPin(provider, pin, name);
// apply default value
gpioPin.setValue(defaultValue);
// return new new pin instance
return gpioPin;
}
@Override
public GpioPinAnalogOutput provisionAnalogOutputPin(Pin pin, String name, double defaultValue) {
return provisionAnalogOutputPin(defaultProvider, pin, name, defaultValue);
}
@Override
public GpioPinAnalogOutput provisionAnalogOutputPin(Pin pin, double defaultValue) {
return provisionAnalogOutputPin(defaultProvider, pin, defaultValue);
}
@Override
public GpioPinPwmOutput provisionPwmOutputPin(GpioProvider provider, Pin pin, String name) {
// return new new pin instance
return (GpioPinPwmOutput)provisionPin(provider, pin, name, PinMode.PWM_OUTPUT);
}
@Override
public GpioPinPwmOutput provisionPwmOutputPin(GpioProvider provider, Pin pin) {
// return new new pin instance
return (GpioPinPwmOutput)provisionPin(provider, pin, PinMode.PWM_OUTPUT);
}
@Override
public GpioPinPwmOutput provisionPwmOutputPin(Pin pin, String name) {
return provisionPwmOutputPin(defaultProvider, pin, name);
}
@Override
public GpioPinPwmOutput provisionPwmOutputPin(Pin pin) {
return provisionPwmOutputPin(defaultProvider, pin);
}
@Override
public GpioPinPwmOutput provisionPwmOutputPin(GpioProvider provider, Pin pin, int defaultValue) {
return provisionPwmOutputPin(provider, pin, pin.getName(), defaultValue);
}
@Override
public GpioPinPwmOutput provisionPwmOutputPin(GpioProvider provider, Pin pin, String name, int defaultValue) {
// create new GPIO pin instance
GpioPinPwmOutput gpioPin = provisionPwmOutputPin(provider, pin, name);
// apply default value
gpioPin.setPwm(defaultValue);
// return new new pin instance
return gpioPin;
}
@Override
public GpioPinPwmOutput provisionPwmOutputPin(Pin pin, String name, int defaultValue) {
return provisionPwmOutputPin(defaultProvider, pin, name, defaultValue);
}
@Override
public GpioPinPwmOutput provisionPwmOutputPin(Pin pin, int defaultValue) {
return provisionPwmOutputPin(defaultProvider, pin, defaultValue);
}
@Override
public void unprovisionPin(GpioPin... pin) {
if (pin == null || pin.length == 0) {
throw new IllegalArgumentException("Missing pin argument.");
}
for (int index = (pin.length-1); index >= 0; index--) {
GpioPin p = pin[index];
// ensure the requested pin has been provisioned
if (!pins.contains(p)) {
throw new GpioPinNotProvisionedException(p.getPin());
}
// remove all listeners and triggers
if (p instanceof GpioPinInput) {
((GpioPinInput)p).removeAllListeners();
((GpioPinInput)p).removeAllTriggers();
}
// remove this pin instance from the managed collection
pins.remove(p);
}
}
public void setShutdownOptions(GpioPinShutdown options, GpioPin... pin) {
for (GpioPin p : pin) {
if (!pins.contains(p)) {
throw new GpioPinNotProvisionedException(p.getPin());
}
p.setShutdownOptions(options);
}
}
public void setShutdownOptions(Boolean unexport, GpioPin... pin) {
for (GpioPin p : pin) {
if (!pins.contains(p)) {
throw new GpioPinNotProvisionedException(p.getPin());
}
p.setShutdownOptions(unexport);
}
}
public void setShutdownOptions(Boolean unexport, PinState state, GpioPin... pin) {
for (GpioPin p : pin) {
if (!pins.contains(p)) {
throw new GpioPinNotProvisionedException(p.getPin());
}
p.setShutdownOptions(unexport, state);
}
}
public void setShutdownOptions(Boolean unexport, PinState state, PinPullResistance resistance, GpioPin... pin) {
for (GpioPin p : pin) {
if (!pins.contains(p)) {
throw new GpioPinNotProvisionedException(p.getPin());
}
p.setShutdownOptions(unexport, state, resistance);
}
}
public void setShutdownOptions(Boolean unexport, PinState state, PinPullResistance resistance, PinMode mode, GpioPin... pin) {
for (GpioPin p : pin) {
if (!pins.contains(p)) {
throw new GpioPinNotProvisionedException(p.getPin());
}
p.setShutdownOptions(unexport, state, resistance, mode);
}
}
/**
* This class is used to perform any configured shutdown actions
* on the provisioned GPIO pins
*
* @author Robert Savage
*
*/
private class ShutdownHook extends Thread {
public void run() {
// perform shutdown
shutdown();
}
}
/**
* This method returns TRUE if the GPIO controller has been shutdown.
*
* @return shutdown state
*/
@Override
public boolean isShutdown(){
return isshutdown;
}
/**
* This method can be called to forcefully shutdown all GPIO controller
* monitoring, listening, and task threads/executors.
*/
@Override
public synchronized void shutdown()
{
// prevent reentrant invocation
if(isShutdown())
return;
// shutdown all executor services
//
// NOTE: we are not permitted to access the shutdown() method of the individual
// executor services, we must perform the shutdown with the factory
GpioFactory.getExecutorServiceFactory().shutdown();
// shutdown explicit configured GPIO pins
for (GpioPin pin : pins) {
// perform a shutdown on the GPIO provider for this pin
if(!pin.getProvider().isShutdown()){
pin.getProvider().shutdown();
}
// perform the shutdown options if configured for the pin
GpioPinShutdown shutdownOptions = pin.getShutdownOptions();
if (shutdownOptions != null) {
// get shutdown option configuration
PinState state = shutdownOptions.getState();
PinMode mode = shutdownOptions.getMode();
PinPullResistance resistance = shutdownOptions.getPullResistor();
Boolean unexport = shutdownOptions.getUnexport();
// perform shutdown actions
if ((state != null) && (pin instanceof GpioPinDigitalOutput)) {
((GpioPinDigitalOutput)pin).setState(state);
}
if (resistance != null) {
pin.setPullResistance(resistance);
}
if (mode != null) {
pin.setMode(mode);
}
if (unexport != null && unexport == Boolean.TRUE) {
pin.unexport();
}
}
}
// set is shutdown tracking variable
isshutdown = true;
}
}