Java GpioPinDigitalInput类代码示例

import com.pi4j.io.gpio.GpioPinDigitalInput; //导入依赖的package包/类
private boolean startListenDigitalPin(MessageParsedInfo messageParsedInfo) {
	int pinNum    = (Integer)messageParsedInfo.getParsedValues()[0];
	
	GpioPinListenerDigital listener = digitalListeners.get(pinNum);
	if(listener == null) {
		listener = createDigitalListener(pinNum);
		GpioPinDigitalInput pin = (GpioPinDigitalInput)getPin(pinNum);
		pin.setMode(PinMode.DIGITAL_INPUT);
		pin.setPullResistance(PinPullResistance.PULL_DOWN);
		
		digitalListeners.put(pinNum, listener);
		pin.addListener(listener);
	}
	
	return true;
}
 

import com.pi4j.io.gpio.GpioPinDigitalInput; //导入依赖的package包/类
/**
 * Constructing a software representation of an GPIO connected hardware
 * button.
 * 
 * @param pin
 *            the GPIO pin that the button is connected to.
 */
public GPIOButton(Pin pin) {
	// create gpio controller
	final GpioController gpio = GpioFactory.getInstance();

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

	// register an anonymous listener with the pi4j library to connect to
	// our internal listeners.
	myButton.addListener(new GpioPinListenerDigital() {

		@Override
		public void handleGpioPinDigitalStateChangeEvent(GpioPinDigitalStateChangeEvent event) {
			event.getState();
			if (event.getState() == PinState.HIGH) {
				setState(ButtonState.ON);
			} else {
				setState(ButtonState.OFF);
			}
		}
	});
}
 

import com.pi4j.io.gpio.GpioPinDigitalInput; //导入依赖的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.GpioPinDigitalInput; //导入依赖的package包/类
private GpioPinDigitalInput initializeInputPin(ChannelUID channel) {
    logger.debug("initializing input pin for channel {}", channel.getAsString());
    Pin pin = PinMapper.get(channel.getIdWithoutGroup());

    String pullMode = DEFAULT_PULL_MODE;
    if (thing.getChannel(channel.getIdWithoutGroup()) != null) {
        Configuration configuration = thing.getChannel(channel.getId()).getConfiguration();
        pullMode = ((String) configuration.get(PULL_MODE)) != null ? ((String) configuration.get(PULL_MODE))
                : DEFAULT_PULL_MODE;
    }
    logger.debug("initializing pin {}, pullMode {}, mcpProvider {}", pin, pullMode, mcpProvider);
    GpioPinDigitalInput input = GPIODataHolder.GPIO.provisionDigitalInputPin(mcpProvider, pin,
            channel.getIdWithoutGroup(), PinPullResistance.valueOf(pullMode));
    input.addListener(this);
    logger.debug("Bound digital input for PIN: {}, ItemName: {}, pullMode: {}", pin, channel.getAsString(),
            pullMode);
    return input;

}
 

import com.pi4j.io.gpio.GpioPinDigitalInput; //导入依赖的package包/类
@Override
public void init() throws ServletException
{
    super.init();
    
    takingSnapshot = false;
    
    ServletContext servletContext = getServletContext();
    GpioController gpio = (GpioController) servletContext.getAttribute(PHOTO_BOOTH_GPIO_CONTROLLER_KEY);
    if(gpio == null)
    {
        System.err.println("The foot pedal servlet could not obtain a GPIO contorller from the servlet context");
    }
    else
    {            
        GpioPinDigitalInput photoBoothButton = gpio.provisionDigitalInputPin(RaspiPin.GPIO_17, 
                                                                             "foot pedal button", 
                                                                             PinPullResistance.PULL_UP);
        photoBoothButton.addListener(this);
        servletContext.setAttribute(PHOTO_BOOTH_FOOT_PEDAL_KEY, photoBoothButton);
    }
}
 

import com.pi4j.io.gpio.GpioPinDigitalInput; //导入依赖的package包/类
private static GpioPinDigitalInput[] initializePins(int mapping[], GpioController gpioController,
                                                    final RelayStateChangedListener listener) {
  final GpioPinDigitalInput[] pins = new GpioPinDigitalInput[mapping.length];
  for (int i = 0; i < mapping.length; ++i) {
    pins[i] = gpioController.provisionDigitalInputPin(Pins.GPIO_PIN[mapping[i]],
        PinPullResistance.PULL_UP);
    final int relayNum = i;
    pins[i].addListener((GpioPinListenerDigital) event -> {
      listener.onRelayStateChanged(relayNum, event.getState() == PinState.LOW);
    });

    // Tell the listener about the current state before change events are
    // received.
    listener.onRelayStateChanged(relayNum, pins[i].getState() == PinState.LOW);
  }
  return pins;
}
 

import com.pi4j.io.gpio.GpioPinDigitalInput; //导入依赖的package包/类
private void mapearPino(int endereco, GrappaPin pinoDigitalGrappa) {
	GpioPinDigital pino = null;
	switch(pinoDigitalGrappa.getType()){
	case INPUT:
	case MONITOR:
		GpioPinDigitalInput entrada = this.gpio.provisionDigitalInputPin(getPinoMapeado(endereco), "GRAPPA_" + endereco,PinPullResistance.PULL_DOWN);
		pino = entrada;
		break;
	case OUTPUT:
		pino = this.gpio.provisionDigitalOutputPin(getPinoMapeado(endereco), "GRAPPA_" + endereco);
		pino.setShutdownOptions(true, PinState.LOW);
		break;
	default:
		throw new RuntimeException();
	}
	this.pinos.put(endereco, pino);
}
 

import com.pi4j.io.gpio.GpioPinDigitalInput; //导入依赖的package包/类
@Override
public List<PinService> registerServices(List<Class<PinService>> templates) {
	List<PinService> servicos = new ArrayList<>();
	try{
		for(Class<PinService> t : templates){
			PinListener anotacao = t.getAnnotation(PinListener.class);
			int[] enderecos = anotacao.addresses();
			PinService servico = t.newInstance();
			registrarHardware(servico);
			for(int i = 0; i < enderecos.length; i++){
				this.mapeamento.getPins().get(enderecos[i]).registerServices(servico);
				registrarServico(servico, (GpioPinDigitalInput) this.pinos.get(enderecos[i]));
			}
			servicos.add(servico);
			
		}
	}catch(Exception ex){
		throw new RuntimeException(ex);
	}
	return servicos;
}
 

import com.pi4j.io.gpio.GpioPinDigitalInput; //导入依赖的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.GpioPinDigitalInput; //导入依赖的package包/类
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)
        while(true) {
            Thread.sleep(500);
        }

        // stop all GPIO activity/threads by shutting down the GPIO controller
        // (this method will forcefully shutdown all GPIO monitoring threads and scheduled tasks)
        // gpio.shutdown();   <--- implement this method call if you wish to terminate the Pi4J GPIO controller
    }
 

import com.pi4j.io.gpio.GpioPinDigitalInput; //导入依赖的package包/类
/**
* 
* @param dirPin Pin used to choose direction.
* @param stepPin Pin used to take steps
* @param enablePin Pin used to DISABLE the motor
* @param endHigh Pin that goes high when at the end
* @param endLow Pin that goes high when at the end
* @param rate Number of steps for 1 mL fluid moved
*/
public SyringePump(GpioPinDigitalOutput dirPin, GpioPinDigitalOutput stepPin, GpioPinDigitalOutput enablePin, 
        GpioPinDigitalInput endHigh, GpioPinDigitalInput endLow, double rate){
    this.rate = rate;
    this.dirPin = dirPin;
    this.stepPin = stepPin;
    this.enablePin = enablePin;
    this.endHigh = endHigh;
    this.endLow = endLow;
}
 

import com.pi4j.io.gpio.GpioPinDigitalInput; //导入依赖的package包/类
public static void main(String[] args) 
           throws IOException, InterruptedException {
       
       // Create a GPIO controller instance
final GpioController gpio = GpioFactory.getInstance();	
       
       // Pi4J 22 = 6
       final GpioPinDigitalInput inputPin = gpio.provisionDigitalInputPin(RaspiPin.GPIO_22, PinPullResistance.PULL_DOWN);
       PinState inputState = inputPin.getState();
       /*
       while(System.in.available() == 0) {
           System.out.println(inputPin.isHigh());
           inputState = inputPin.getState();
           System.out.println(inputState.toString());
           Thread.sleep(1000);
       }*/
       
       System.out.println("Pulled down pin 22/6");

       int samples = 100000;
       
       // Take a bunch of samples and report
       while(System.in.available() == 0) {
           double sample = 0;
           for(int k = 0; k < samples ; k++) {
               if(inputPin.isHigh()) {
                   sample++;
               }
           }
           
           System.out.println(sample/samples);
       }
       
       System.out.println("Done");
   }
 

import com.pi4j.io.gpio.GpioPinDigitalInput; //导入依赖的package包/类
public GpioPinDigitalInput getNextInput(PinPullResistance ppr) {
    // No pins are left
    if (this.availablePins.isEmpty()) {
        return null;
    }

    NamedPin temp = this.availablePins.get(0);
    this.assignedPins.add(temp);
    this.availablePins.remove(temp);

    GpioPinDigitalInput result = this.gpio.provisionDigitalInputPin(temp.provider, temp.pin, temp.name, ppr);
    return result;
}
 

import com.pi4j.io.gpio.GpioPinDigitalInput; //导入依赖的package包/类
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        
}
 

import com.pi4j.io.gpio.GpioPinDigitalInput; //导入依赖的package包/类
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        
}