@RequestMapping("/left.html")
public String left() throws InterruptedException {
leftFrontMotor.toggle();
rightFrontMotor.toggle();
return "Moving left...";
}
public static void main(String[] args) throws InterruptedException {
System.out.println("works");
GpioController gpio = GpioFactory.getInstance();
GpioPinDigitalOutput pin1 =
gpio.provisionDigitalOutputPin(RaspiPin.GPIO_01, "MyLed", PinState.HIGH);
pin1.setShutdownOptions(true, PinState.LOW);
Thread.sleep(5000);
System.out.println("pin low");
pin1.low();
Thread.sleep(5000);
System.out.println("pin toggle");
pin1.toggle();
Thread.sleep(5000);
System.out.println("pin pulse");
pin1.pulse(1000, true);
Thread.sleep(2000);
System.out.println("pin blink");
pin1.blink(500, 5000);
Thread.sleep(2000);
System.out.println("koniec");
gpio.shutdown();
}
@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();
}
}
public static void main(String[] args) throws InterruptedException {
// START SNIPPET: usage-create-controller-snippet
// create gpio controller instance
final GpioController gpio = GpioFactory.getInstance();
// END SNIPPET: usage-create-controller-snippet
// START SNIPPET: usage-provision-input-pin-snippet
// provision gpio pin #02 as an input pin with its internal pull down resistor enabled
// (configure pin edge to both rising and falling to get notified for HIGH and LOW state
// changes)
GpioPinDigitalInput myButton =
gpio.provisionDigitalInputPin(
RaspiPin.GPIO_02, // PIN NUMBER
"MyButton", // PIN FRIENDLY NAME (optional)
PinPullResistance.PULL_DOWN); // PIN RESISTANCE (optional)
// END SNIPPET: usage-provision-input-pin-snippet
// START SNIPPET: usage-provision-output-pin-snippet
// provision gpio pins #04 as an output pin and make sure is is set to LOW at startup
GpioPinDigitalOutput myLed =
gpio.provisionDigitalOutputPin(
RaspiPin.GPIO_04, // PIN NUMBER
"My LED", // PIN FRIENDLY NAME (optional)
PinState.LOW); // PIN STARTUP STATE (optional)
// END SNIPPET: usage-provision-output-pin-snippet
// START SNIPPET: usage-shutdown-pin-snippet
// configure the pin shutdown behavior; these settings will be
// automatically applied to the pin when the application is terminated
// ensure that the LED is turned OFF when the application is shutdown
myLed.setShutdownOptions(true, PinState.LOW, PinPullResistance.OFF);
// END SNIPPET: usage-shutdown-pin-snippet
// START SNIPPET: usage-control-pin-snippet
// explicitly set a state on the pin object
myLed.setState(PinState.HIGH);
// use convenience wrapper method to set state on the pin object
myLed.low();
myLed.high();
// use toggle method to apply inverse state on the pin object
myLed.toggle();
// use pulse method to set the pin to the HIGH state for
// an explicit length of time in milliseconds
myLed.pulse(1000);
// END SNIPPET: usage-control-pin-snippet
// START SNIPPET: usage-read-pin-snippet
// get explicit state enumeration for the GPIO pin associated with the button
PinState myButtonState = myButton.getState();
// use convenience wrapper method to interrogate the button state
boolean buttonPressed = myButton.isHigh();
// END SNIPPET: usage-read-pin-snippet
// START SNIPPET: usage-register-listener-snippet
// create and register gpio pin listener
myButton.addListener(new GpioUsageExampleListener());
// END SNIPPET: usage-register-listener-snippet
// START SNIPPET: usage-trigger-snippet
// create a gpio synchronization trigger on the input pin
// when the input state changes, also set LED controlling gpio pin to same state
myButton.addTrigger(new GpioSyncStateTrigger(myLed));
// END SNIPPET: usage-trigger-snippet
// keep program running until user aborts (CTRL-C)
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
}
/** Process the message */
@Override
public void process(Exchange exchange) throws Exception {
if (log.isTraceEnabled()) {
log.trace(exchange.toString());
}
GPIOAction messageAction =
exchange.getIn().getHeader(Pi4jConstants.CAMEL_RBPI_PIN_ACTION, action, GPIOAction.class);
if (messageAction == null) {
log.trace("No action pick up body");
this.output(exchange, exchange.getIn().getBody());
} else {
log.trace("action= {} ", action);
switch (messageAction) {
case TOGGLE:
if (pin.getMode() == PinMode.DIGITAL_OUTPUT) {
((GpioPinDigitalOutput) pin).toggle();
}
break;
case LOW:
if (pin.getMode() == PinMode.DIGITAL_OUTPUT) {
((GpioPinDigitalOutput) pin).low();
}
break;
case HIGH:
if (pin.getMode() == PinMode.DIGITAL_OUTPUT) {
((GpioPinDigitalOutput) pin).high();
}
break;
case BLINK:
if (pin.getMode() == PinMode.DIGITAL_OUTPUT) {
pool.submit(
new Runnable() {
@Override
public void run() {
try {
Thread.sleep(getEndpoint().getDelay());
((GpioPinDigitalOutput) pin).toggle();
Thread.sleep(getEndpoint().getDuration());
((GpioPinDigitalOutput) pin).toggle();
} catch (InterruptedException e) {
log.error("Thread interruption into BLINK sequence", e);
}
}
});
}
break;
default:
log.error("Any action set found");
break;
}
}
}
/**
* [ARGUMENT/OPTION "--pin (#)" | "-p (#)" ] This example program accepts an optional argument for
* specifying the GPIO pin (by number) to use with this GPIO listener example. If no argument is
* provided, then GPIO #1 will be used. -- EXAMPLE: "--pin 4" or "-p 0".
*
* @param args
* @throws InterruptedException
* @throws PlatformAlreadyAssignedException
*/
public static void main(String[] args)
throws InterruptedException, PlatformAlreadyAssignedException {
// ####################################################################
//
// since we are not using the default Raspberry Pi platform, we should
// explicitly assign the platform as the BananaPi platform.
//
// ####################################################################
PlatformManager.setPlatform(Platform.BANANAPI);
// create Pi4J console wrapper/helper
// (This is a utility class to abstract some of the boilerplate code)
final Console console = new Console();
// print program title/header
console.title("<-- The Pi4J Project -->", "GPIO Output Example");
// allow for user to exit program using CTRL-C
console.promptForExit();
// create gpio controller
final GpioController gpio = GpioFactory.getInstance();
// ####################################################################
//
// When provisioning a pin, use the BananaPiPin class.
//
// ####################################################################
// by default we will use gpio pin #01; however, if an argument
// has been provided, then lookup the pin by address
Pin pin =
CommandArgumentParser.getPin(
BananaPiPin.class, // pin provider class to obtain pin instance from
BananaPiPin.GPIO_01, // default pin if no pin argument found
args); // argument array to search in
// provision gpio pin as an output pin and turn on
final GpioPinDigitalOutput output =
gpio.provisionDigitalOutputPin(pin, "My Output", PinState.HIGH);
// set shutdown state for this pin: keep as output pin, set to low state
output.setShutdownOptions(false, PinState.LOW);
// create a pin listener to print out changes to the output gpio pin state
output.addListener(
new GpioPinListenerDigital() {
@Override
public void handleGpioPinDigitalStateChangeEvent(GpioPinDigitalStateChangeEvent event) {
// display pin state on console
console.println(
" --> GPIO PIN STATE CHANGE: "
+ event.getPin()
+ " = "
+ ConsoleColor.conditional(
event.getState().isHigh(), // conditional expression
ConsoleColor.GREEN, // positive conditional color
ConsoleColor.RED, // negative conditional color
event.getState())); // text to display
}
});
// prompt user that we are ready
console.println(" ... Successfully provisioned output pin: " + output.toString());
console.emptyLine();
console.box("The GPIO output pin states will cycle HIGH and LOW states now.");
console.emptyLine();
// notify user of current pin state
console.println(
"--> ["
+ output.toString()
+ "] state was provisioned with state = "
+ ConsoleColor.conditional(
output.getState().isHigh(), // conditional expression
ConsoleColor.GREEN, // positive conditional color
ConsoleColor.RED, // negative conditional color
output.getState())); // text to display
// wait
Thread.sleep(500);
// --------------------------------------------------------------------------
// tset gpio pin state to LOW
console.emptyLine();
console.println("Setting output pin state is set to LOW.");
output.low(); // or ... output.setState(PinState.LOW);
// wait
Thread.sleep(500);
// --------------------------------------------------------------------------
// tset gpio pin state to HIGH
console.emptyLine();
console.println("Setting output pin state from LOW to HIGH.");
output.setState(PinState.HIGH); // or ... output.high();
// wait
Thread.sleep(500);
// --------------------------------------------------------------------------
// toggle the current state of gpio pin (from HIGH to LOW)
console.emptyLine();
console.println("Toggling output pin state from HIGH to LOW.");
output.toggle();
// wait
Thread.sleep(500);
// --------------------------------------------------------------------------
// pulse gpio pin state for 1 second HIGH and then return to LOW
console.emptyLine();
console.println("Pulsing output pin state HIGH for 1 second.");
output.pulse(1000, true); // set second argument to 'true' use a blocking call
Thread.sleep(50);
// --------------------------------------------------------------------------
// blink gpio pin state for 1 second between HIGH and LOW states
console.emptyLine();
console.println(
"Blinking output pin state between HIGH and LOW for 3 seconds with a blink rate of 250ms.");
Future future = output.blink(250, 3000);
// --------------------------------------------------------------------------
// wait for blinking to finish; we are notified in a future object
while (!future.isDone()) {
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();
}
