Multiple (and independant) java processes use pi4j

[chris-class]

I have a setup where multiple and independant java processes listen (and also writes) on different GPIO ports. So these java processes do not share a single GPIO port. What needs to be taken into account? Can this setup have any interferences ?

[FDelporte]

Hi, that's a nice use-case... but not something I didn't try myself yet. Maybe it's a good idea to do a proof-of-concept with two minimal applications that control different GPIOs? Maybe use https://www.pi4j.com/getting-started/minimal-example-application/ and start it two times with different LEDs?

[taartspi]

Like @FDelporte I didn't know the expected behavior so I tested this code using the gpiod provider. I did not test with the Pigpio provider
Using two versions of the program to use different GPIOs, started the two versions executing, both process' saw the Listeners fire and toggle the GPIO state of the LEDs.
Used 2.6.0 SNAPSHOT on a Pi5.

I failed to have markup list all the code as a single piece of java code, sorry, it make it difficult to read/copy.

---

PI4J PROVIDERS

PROVIDERS: [6] "I/O Providers" <com.pi4j.provider.impl.DefaultProviders>
├─SPI: [1] <com.pi4j.io.spi.SpiProvider>
│ └─PROVIDER: "PiGpio SPI Provider" {pigpio-spi} <com.pi4j.plugin.pigpio.provider.spi.PiGpioSpiProviderImpl> {com.pi4j.plugin.pigpio.provider.spi.PiGpioSpiProviderImpl}
├─SERIAL: [1] <com.pi4j.io.serial.SerialProvider>
│ └─PROVIDER: "PiGpio Serial Provider" {pigpio-serial} <com.pi4j.plugin.pigpio.provider.serial.PiGpioSerialProviderImpl> {com.pi4j.plugin.pigpio.provider.serial.PiGpioSerialProviderImpl}
├─DIGITAL_INPUT: [1] <com.pi4j.io.gpio.digital.DigitalInputProvider>
│ └─PROVIDER: "GpioD Digital Input (GPIO) Provider" {gpiod-digital-input} <com.pi4j.plugin.gpiod.provider.gpio.digital.GpioDDigitalInputProviderImpl> {com.pi4j.plugin.gpiod.provider.gpio.digital.GpioDDigitalInputProviderImpl}
├─ANALOG_INPUT: [0] <com.pi4j.io.gpio.analog.AnalogInputProvider>
├─PWM: [1] <com.pi4j.io.pwm.PwmProvider>
│ └─PROVIDER: "LinuxFS PWM Provider" {linuxfs-pwm} <com.pi4j.plugin.linuxfs.provider.pwm.LinuxFsPwmProviderImpl> {com.pi4j.plugin.linuxfs.provider.pwm.LinuxFsPwmProviderImpl}
├─ANALOG_OUTPUT: [0] <com.pi4j.io.gpio.analog.AnalogOutputProvider>
├─DIGITAL_OUTPUT: [1] <com.pi4j.io.gpio.digital.DigitalOutputProvider>
│ └─PROVIDER: "GpioD Digital Output (GPIO) Provider" {gpiod-digital-output} <com.pi4j.plugin.gpiod.provider.gpio.digital.GpioDDigitalOutputProviderImpl> {com.pi4j.plugin.gpiod.provider.gpio.digital.GpioDDigitalOutputProviderImpl}
└─I2C: [1] <com.pi4j.io.i2c.I2CProvider>
└─PROVIDER: "LinuxFS I2C Provider" {linuxfs-i2c} <com.pi4j.plugin.linuxfs.provider.i2c.LinuxFsI2CProviderImpl> {com.pi4j.plugin.linuxfs.provider.i2c.LinuxFsI2CProviderImpl}

``

package com.pi4j.test.devices.dht22;

import com.pi4j.Pi4J;
import com.pi4j.context.Context;
import com.pi4j.io.gpio.digital.Digital;
import com.pi4j.io.gpio.digital.DigitalInput;
import com.pi4j.io.gpio.digital.DigitalOutput;
import com.pi4j.io.gpio.digital.DigitalState;
import com.pi4j.util.Console;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.atomic.AtomicReference;

public class GpioTest2 {

private static final Logger logger = LoggerFactory.getLogger(GpioTest.class);

// Connect a LED to PIN 15 = BCM 22
private static final int PIN_LED_YELLOW = 23;//17;
private static final int PIN_LED_RED = 24; //27;
private static final int PIN_LED_GREEN = 25;//22;
private static final int PIN_BTN_RED = 12;//5;
private static final int MYDOUT = 6;// 18;
private static final int PIN_SWAP = 16; //13;

public static void main(String[] args) throws InterruptedException, ExecutionException {

  //  System.setProperty("org.slf4j.simpleLogger.defaultLogLevel", "OFF");   no worky
    Context pi4j = Pi4J.newAutoContext();

    var console = new Console();
    System.out.println("----------------------------------------------------------");
    System.out.println("PI4J PROVIDERS");
    System.out.println("----------------------------------------------------------");
    pi4j.providers().describe().print(System.out);
    System.out.println("----------------------------------------------------------");

    DigitalOutput ledRed = pi4j.dout().create(PIN_LED_RED);
    DigitalOutput ledYellow = pi4j.dout().create(PIN_LED_YELLOW);
    DigitalOutput ledGreen = pi4j.dout().create(PIN_LED_GREEN);
    DigitalInput redBtn = pi4j.din().create(PIN_BTN_RED);

// ledRed.blink(1, 5, TimeUnit.SECONDS);
// ledYellow.pulse(1, TimeUnit.SECONDS);
// Future blinkRed = ledRed.blinkAsync(1, 5, TimeUnit.SECONDS); // Future pulseYellow = ledYellow.pulseAsync(1, TimeUnit.SECONDS);
// blinkRed.get();
// pulseYellow.get();

    var ledConfig = DigitalOutput.newConfigBuilder(pi4j)
            .id("my-dout")
            .name("My LED")
            .address(MYDOUT)
            .shutdown(DigitalState.LOW)
            .initial(DigitalState.HIGH);

    var led = pi4j.create(ledConfig);

    logger.info("pin detail " + led);

    AtomicReference<Digital> greenBtnRef = new AtomicReference<>();

    redBtn.addListener(e -> {
        if (e.state().isHigh())
            return;

        logger.info("Toggling state...");
        Digital<?, ?, ?> digital = greenBtnRef.get();
        if (digital != null && pi4j.hasIO(digital.id())) {
            logger.info("Shutting down " + digital.id() + "...");
            pi4j.shutdown(digital.id());
            logger.info("Done.");
        }

        // toggle PIN_SWAP between output or input
        if (digital instanceof DigitalInput) {
            // set to output
            logger.info("Setting pin " + PIN_SWAP + " to output.");
            digital = pi4j.dout().create(PIN_SWAP);
            logger.info("Pin " + PIN_SWAP + " is now output " + digital.id());
        } else {
            // set to input
            logger.info("Setting pin " + PIN_SWAP + " to input.");
            digital = pi4j.din().create(PIN_SWAP);
            digital.addListener(e1 -> {
                if (e1.state().isHigh()) {
                    logger.info("Drive  : " + PIN_LED_RED + " HIGH");
                    ledRed.high();
                }
                else {
                    logger.info("Drive  : " + PIN_LED_RED + " LOW");
                    ledRed.low();
                }
            });
            logger.info("Toggle  : " + PIN_LED_RED );
            ledRed.toggle();
            logger.info("Pin " + PIN_SWAP + " is now input " + digital.id());
        }

        greenBtnRef.set(digital);
        logger.info("");
        logger.info("");
    });

    ledRed.low();
    ledYellow.low();
    ledRed.high();
    ledYellow.high();
    Thread.sleep(2000L);
    ledRed.low();
    ledYellow.low();

    Runtime.getRuntime().addShutdownHook(new Thread() {
        public void run() {
            try {
                logger.info("Shutting down...");
                pi4j.shutdown();
            } catch (Exception e) {
                logger.error("Failed to shutdown", e);
            }
        }
    });

    synchronized (Thread.currentThread()) {
        Thread.currentThread().wait();
    }
}

}

``

[eitch]

As long as the different processes use different GPIOs, then there shouldn't be any problem. The same situation can arise when running a pi4j java app and a shell script or something else accessing a port the app doesn't access.