Java GpioFactory.getInstance方法代碼示例

import com.pi4j.io.gpio.GpioFactory; //導入方法依賴的package包/類
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;
}
 

import com.pi4j.io.gpio.GpioFactory; //導入方法依賴的package包/類
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
    }
 

import com.pi4j.io.gpio.GpioFactory; //導入方法依賴的package包/類
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;
}
 

import com.pi4j.io.gpio.GpioFactory; //導入方法依賴的package包/類
/**
 * Creates new form MainWindow
 *
 * @throws com.pi4j.io.i2c.I2CFactory.UnsupportedBusNumberException
 * @throws java.io.IOException
 */
public PumpDiagGuiSingle() throws I2CFactory.UnsupportedBusNumberException, IOException, IOException, InterruptedException {
    gpio = GpioFactory.getInstance(); // Singleton instance
    mcpProvider = new MCP23017GpioProvider(I2CBus.BUS_1, 0x23);

    // Provision direction control pins as outputs
    System.out.println("Provisioning direction pin");
    dir = gpio.provisionDigitalOutputPin(mcpProvider, MCP23017Pin.GPIO_A7, "Direction", PinState.LOW);

    // Provision step control pins as outputs
    System.out.println("Provisioning step pin");
    step = gpio.provisionDigitalOutputPin(mcpProvider, MCP23017Pin.GPIO_A6, "Step", PinState.LOW);

    // Provision enable pins as outputs. 
    // Note that the pin state "high" means the pump is disabled;
    // the enable pump on the chip is inverted.
    System.out.println("Provisioning enable pin");
    enable = gpio.provisionDigitalOutputPin(mcpProvider, MCP23017Pin.GPIO_A5, "~Enable", PinState.HIGH);
}
 

import com.pi4j.io.gpio.GpioFactory; //導入方法依賴的package包/類
public MotorControllerImpl(PWMOutput output,
		MotorControllerConfiguration configuration) {

	this.output = output;
	this.configuration = configuration;
	this.gpio = GpioFactory.getInstance();

	try {
		Pin myGPIOMotorPin = (Pin) FieldUtils.readDeclaredStaticField(
				RaspiPin.class, configuration.gpioPin());

		motorPin = gpio.provisionDigitalOutputPin(myGPIOMotorPin,
				configuration.name(), PinState.LOW);
		motorPin.setShutdownOptions(true, PinState.LOW);

	} catch (IllegalAccessException e) {
		LOGGER.error("Error on construct MotorControllerImpl", e);
	}

}
 

import com.pi4j.io.gpio.GpioFactory; //導入方法依賴的package包/類
public RasPi(String n) {
	super(n);

	Platform platform = Platform.getLocalInstance();
	log.info(String.format("platform is %s", platform));
	if ("arm".equals(platform.getArch())) {
		// init I2C
		gpio = GpioFactory.getInstance();
		gpio01 = gpio.provisionDigitalOutputPin(RaspiPin.GPIO_01);
		gpio03 = gpio.provisionDigitalOutputPin(RaspiPin.GPIO_03);

	} else {
		// we should be running on a Raspberry Pi
		log.error("architecture is not arm");
	}

}
 

import com.pi4j.io.gpio.GpioFactory; //導入方法依賴的package包/類
public void init(){
	try {
		_gpioController = GpioFactory.getInstance();
		_i2cbus = I2CFactory.getInstance(I2CBus.BUS_1);

		_temperatureSensor = _i2cbus.getDevice(0x40);
		_lightActuator = _gpioController.provisionDigitalMultipurposePin(RaspiPin.GPIO_00, "led", PinMode.DIGITAL_OUTPUT);
		_lightActuator.setShutdownOptions(true); // unexport on shutdown

		// monitor temperature changes
		// every change of more than 0.1C will notify SensorChangedListeners
		_scheduledThreadPoolExecutor = new ScheduledThreadPoolExecutor(1);
		_handle = _scheduledThreadPoolExecutor.scheduleAtFixedRate(temperatureReader, 0, 100, TimeUnit.MILLISECONDS);

	} catch (IOException e) {
		log.error("An error occurred whilst trying to read temperature from GPIO Pins.");
	}
}
 

import com.pi4j.io.gpio.GpioFactory; //導入方法依賴的package包/類
public static void main(String[] args) throws InterruptedException, FileNotFoundException {
	
	lp0 = new FileOutputStream(new File("/dev/usb/lp0"));

	GpioController gpio;
	GpioPinDigitalInput printButton;

	gpio = GpioFactory.getInstance();
	printButton = gpio.provisionDigitalInputPin(RaspiPin.GPIO_04, PinPullResistance.PULL_DOWN);
	printButton.addListener(new ButtonListener());

	System.out.println("Start pi cam");
	picam = new Camera();
	new Thread(picam).start();

	try {
		printer = new TMT20();
	} catch (SecurityException | UsbException e) {
		e.printStackTrace();
	}
	
	System.out.println("Press the big button !");

}
 

import com.pi4j.io.gpio.GpioFactory; //導入方法依賴的package包/類
/**
 * Constructor for the OpenSprinkler PI class to create a connection to the OpenSprinkler PI
 * device for control and obtaining status info using the GPIO.
 *
 * @param stations The number of stations to control on the OpenSprinkler PI device.
 */
public OpenSprinklerGpioApi(int stations) {
    this.numberOfStations = stations;
    this.stationState = new boolean[stations];

    for (int i = 0; i < stations; i++) {
        stationState[i] = false;
    }

    gpio = GpioFactory.getInstance();

    /* Initialize the OpenSprinkler Pi */
    SR_CLK_OUTPUT_PIN = gpio.provisionDigitalOutputPin(SR_CLK_PIN);
    SR_NOE_OUTPUT_PIN = gpio.provisionDigitalOutputPin(SR_NOE_PIN);
    SR_NOE_OUTPUT_PIN.high(); /* Disable shift register output */
    SR_DAT_OUTPUT_PIN = gpio.provisionDigitalOutputPin(SR_DAT_PIN);
    SR_LAT_OUTPUT_PIN = gpio.provisionDigitalOutputPin(SR_LAT_PIN);
    SR_NOE_OUTPUT_PIN.low(); /* Disable shift register output */

    pullStationState();
}
 

import com.pi4j.io.gpio.GpioFactory; //導入方法依賴的package包/類
public PhotoramaKeypadTesting() 
{
    logger = Logger.getLogger( getClass().getName() );
    
    try 
    {
        camera = new RaspberryPiCamera();

        
        
        Thread.sleep(1000);

        gpio = GpioFactory.getInstance();

        configureKeypadPins(gpio, camera);
    } 
    catch (Exception ex) 
    {
        logger.log(Level.SEVERE, null, ex);
    }
}
 

import com.pi4j.io.gpio.GpioFactory; //導入方法依賴的package包/類
/**
 * PiService creator. Record itself as a managed service.
 * 
 */
public PiService() {
	
	gpioController = GpioFactory.getInstance();

	String[] clazzes = new String[] { ManagedService.class.getName() };
	// register the class as a managed service.
	Hashtable<String, Object> properties = new Hashtable<String,Object>();
	properties.put(Constants.SERVICE_PID, this.getClass().getName());

	Activator.bc.registerService(clazzes, this, properties);
	
	Activator.log(LogService.LOG_INFO, "Registered "
			+ this.getClass().getName() +  ", Pid = "
			+ (String) properties.get(Constants.SERVICE_PID));
}
 

import com.pi4j.io.gpio.GpioFactory; //導入方法依賴的package包/類
public static void main(String [] args) throws Exception
{        
    GpioController gpio = GpioFactory.getInstance();
    
    String outpath = System.getProperty("user.home") + "/lizard-enclosure/photos";
    Camera camera = new RaspberryPiCamera();
    camera.setOutputPath(outpath);
            
    LizardEnclosureSevice lizardEnclosureSevice = new RaspberryPiLizardEnclosureSevice(camera);
    
    GpioPinListenerDigital selfieListener = lizardEnclosureSevice.newSelfieListener();
    
    GpioPinDigitalInput selfieSensorPin = lizardEnclosureSevice.provisionSelfiePin(gpio);
    selfieSensorPin.addListener(selfieListener);
    
    System.out.println("Ctrl+C to quit");
    while(true)
    {
        Sleeper.sleepo(1000);
    }
}
 

import com.pi4j.io.gpio.GpioFactory; //導入方法依賴的package包/類
public void initializeIO() {
	GpioController controller = GpioFactory.getInstance();
	m_controlPin = controller.provisionDigitalOutputPin(
			PinTable2.get(controlPin), PinStateTable2.get(controlPinState));
	m_statePin = controller.provisionDigitalInputPin(
			PinTable2.get(statePin),
			PinPullResistanceTable2.get(statePinResistance));

	m_statePin.addListener(m_stateListener);

	if (m_statePin.isHigh())
		m_doorState = doorStateEnum.CLOSED;
	else
		m_doorState = doorStateEnum.OPEN;

}
 

import com.pi4j.io.gpio.GpioFactory; //導入方法依賴的package包/類
/**
 * Constructor of class.
 * 
 * @param pin1
 *            Pin for first line of led.
 * @param pin2
 *            Pin for second line of led.
 * @param pin3
 *            Pin for third line of led.
 */
public LedManager(Pin pin1, Pin pin2, Pin pin3) {
	GpioController gpio = GpioFactory.getInstance();
	this.pin1 = gpio.provisionDigitalOutputPin(pin1, "MyLED", PinState.LOW);

	this.pin2 = gpio.provisionDigitalOutputPin(pin2, "MyLED", PinState.LOW);

	this.pin3 = gpio.provisionDigitalOutputPin(pin3, "MyLED", PinState.LOW);

	List<GpioPinDigitalOutput> gpioLed = new ArrayList<GpioPinDigitalOutput>();
	gpioLed.add(this.pin1);
	gpioLed.add(this.pin2);
	gpioLed.add(this.pin3);

	ledBlinking = new LedBlinking(gpioLed);
}
 

import com.pi4j.io.gpio.GpioFactory; //導入方法依賴的package包/類
public static void main(String args[]) throws InterruptedException, UnsupportedBusNumberException, IOException {

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

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

        // create custom MCP3424 GPIO provider
        final MCP3424GpioProvider provider = new MCP3424GpioProvider(I2CBus.BUS_1, 0x6C, 18, 1);

        // provision gpio input pins from MCP3424
        GpioPinAnalogInput inputs[] = { gpio.provisionAnalogInputPin(provider, MCP3424Pin.GPIO_CH0, "Channel-0"),
                gpio.provisionAnalogInputPin(provider, MCP3424Pin.GPIO_CH1, "Channel-1"),
                gpio.provisionAnalogInputPin(provider, MCP3424Pin.GPIO_CH2, "Channel-2"),
                gpio.provisionAnalogInputPin(provider, MCP3424Pin.GPIO_CH3, "Channel-3") };

        // Keep this sample program running for 10 minutes
        for (int count = 0; count < 600; count++) {
            StringBuilder sb  = new StringBuilder();

            // Print current analog input conversion values from each input channel
            for(GpioPinAnalogInput input : inputs){
                double analog = provider.getAnalogValue(input.getPin());
                sb.append(" \t[" + input.getValue() + " -> " + analog + " V] ");
            }

            // Print out all analog input conversion values
            System.out.println("<MCP3424 VALUES> " + sb.toString());

            Thread.sleep(1000);
        }

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

        System.out.println("<--Pi4J--> Exiting MCP3424 GPIO Example.");
    }