使用 pi4j 随机调用 Raspberry PI 的 GPIO 侦听器

Question

我已将我的 RFID 阅读器连接到树莓派 3 的 GPIO 引脚。RFID 阅读器有 4 根电线。 vcc、gnd、data0 和 data1。这里 data0 和 data1 设置为 pull_up (HIGH)，当读取 0bit 时，data0 边沿为 LOW，当读取 1 时，data1 边沿为 LOW。我写了python和java程序。它适用于python，但不适用于java。这是 Python 代码：

import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(True)
chan_list = [17,27]
GPIO.setup(chan_list, GPIO.IN, pull_up_down=GPIO.PUD_UP)
counter = 0
test_counter = 0
def my_callback(channel):
    global counter
    counter += 1

GPIO.add_event_detect(17, GPIO.FALLING, callback=my_callback)
GPIO.add_event_detect(27, GPIO.FALLING, callback=my_callback)
while(True):
    print "counter =",counter

当阅读器读取一个位时，此处的计数器会更新。所以，这里的计数器值为 26，当我尝试在 java 中使用 pi4j 时，没有调用监听器 26 次意味着计数器没有更新 26 次：这是 java 中的代码。

import com.pi4j.io.gpio.GpioController;
import com.pi4j.io.gpio.GpioFactory;
import com.pi4j.io.gpio.GpioPinDigitalInput;
import com.pi4j.io.gpio.PinPullResistance;
import com.pi4j.io.gpio.RaspiPin;
import com.pi4j.io.gpio.event.GpioPinDigitalStateChangeEvent;
import com.pi4j.io.gpio.event.GpioPinListenerDigital;
import com.pi4j.wiringpi.GpioInterrupt;
import com.pi4j.io.gpio.PinState;
import com.pi4j.io.gpio.*;
import com.pi4j.util.CommandArgumentParser;

public class ListenGpioExample {
    public static void main(String args[]) throws InterruptedException {
            ListenGpio listenGpio = new ListenGpio();
            listenGpio.run(args);
   }
}
class ListenGpio{
    int counter  ;
    public void run(String[] args){

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

            final GpioController gpio = GpioFactory.getInstance();

            Pin pin = CommandArgumentParser.getPin(RaspiPin.class, RaspiPin.GPIO_00,  args);

            Pin pin2 = CommandArgumentParser.getPin(RaspiPin.class, RaspiPin.GPIO_02,  args);

            PinPullResistance pull = CommandArgumentParser.getPinPullResistance(PinPullResistance.PULL_UP,  args);

            final GpioPinDigitalInput myButton = gpio.provisionDigitalInputPin(pin,pull);

            final GpioPinDigitalInput myButton2 = gpio.provisionDigitalInputPin(pin2,pull);

            myButton.setShutdownOptions(true);

            myButton2.setShutdownOptions(true);
            myButton.addListener(new GpioPinListenerDigital() {
                    @Override
                    public void handleGpioPinDigitalStateChangeEvent(GpioPinDigitalStateChangeEvent event) {
                            counter += 1;
                    }
             });

            myButton2.addListener(new GpioPinListenerDigital() {
                    @Override
                    public void handleGpioPinDigitalStateChangeEvent(GpioPinDigitalStateChangeEvent event) {
                            counter += 1;
                    }
            });

            for (;;) {
                    System.out.println("counter =="+counter);
            }
    }
}

在这个 java 代码中，Counter 的值是随机的 1 或 2。它必须是 26，因为我正在发送 26 位数据。谁能帮我解决这个问题。电路连接很好，因为它适用于 python 代码。

Answer 1

我尝试用不同的方式使用wiringpi 来解决上述问题，它给出了我正在寻找的输出。不过，我没有得到上述例程中的问题。这是我发布的解决方案：

import com.pi4j.wiringpi.Gpio;
import com.pi4j.wiringpi.GpioInterruptCallback;
public class RFIDAndroid {
public static void main(String args[]) throws InterruptedException{
    RFIDReader rfidReader = new RFIDReader(0,2);
    rfidReader.readRFID();
}

}

class RFIDReader{
    int cardCode;
    int facilityCode;
    int data0;
    int data1;
    int counter =0;
    int flagDone = 0;
    int timer_count = 3000;
    int[] databits = new int[100];

    RFIDReader(int data0,int data1){
            this.data0= data0;
            this.data1=data1;
    }

    int getCardCode(){
            return cardCode;
    }
    int facilityCode(){
            return facilityCode;
    }

    void readRFID() throws InterruptedException{
            if (Gpio.wiringPiSetup() == -1) {
                    System.out.println(" ==>> GPIO SETUP FAILED");
                    return;
            }
            Gpio.pinMode(data0, Gpio.INPUT) ;
            Gpio.pinMode(data1, Gpio.INPUT) ;
            Gpio.pullUpDnControl(data0, Gpio.PUD_UP);
            Gpio.pullUpDnControl(data1, Gpio.PUD_UP);

            Gpio.wiringPiISR(data0, Gpio.INT_EDGE_FALLING, new GpioInterruptCallback() {
                    @Override
                    public void callback(int pin) {
                            flagDone = 0;
                            databits[counter] = 1;
                            counter +=1;
                            timer_count = 3000;
                    }
            });

            Gpio.wiringPiISR(data1, Gpio.INT_EDGE_FALLING, new GpioInterruptCallback() {
                    @Override
                    public void callback(int pin) {
                            flagDone = 0;
                            databits[counter] = 0;
                            counter +=1;
                            timer_count = 3000;
                    }
            });

            while(true){
                    if (flagDone ==0 ) {
                            timer_count -= 1;
                            if (timer_count == 0){
                                    flagDone = 1;
                            }
                    }
                    if (counter > 0 && flagDone ==1) {
                        int i;
                        if (counter == 35)
                        {
                          for (i=2; i<14; i++)
                          {
                             facilityCode <<=1;
                             facilityCode |= databits[i];
                          }
                          for (i=14; i<34; i++)
                          {
                             cardCode <<=1;
                             cardCode |= databits[i];
                          }
                        }
                        else if (counter == 26)
                        {
                          for (i=1; i<9; i++)
                          {
                             facilityCode <<=1;
                             facilityCode |= databits[i];
                          }
                          for (i=9; i<25; i++)
                          {
                             cardCode <<=1;
                             cardCode |= databits[i];
                          }
                        }
                        else {
                            facilityCode = -1;
                            cardCode = -1;
                        }

                         System.out.println("cardCode ="+cardCode);
                         System.out.println("facility Code="+facilityCode);
                         counter = 0;
                         facilityCode = 0;
                         cardCode = 0;
                         for (i=0; i< 100; i++)
                         {
                           databits[i] = 0;
                         }

                             }
                     }
             }
     }