There are several things going on in your code. I suspect that what's really causing the problem is that you need to exit the interrupt handler before another interrupt callback can be triggered...but there is also a confusing mix of callback-based handlers and the GPIO.event_detected method.

I think you can simplify things by performing less manipulation of your interrupt configuration. Just have a state variable that starts at 0, increment it to 1 on the first interrupt, so the next time the interrupt method is called you know it's the second interrupt. No need to try setting multiple handlers like that.

Keeping in mind that I don't actually know what you're trying to do...I imagine something like this:

import RPi.GPIO as GPIO
import time

state = 0

GPIO.setmode(GPIO.BCM)
GPIO.setup(26, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(19, GPIO.IN, pull_up_down=GPIO.PUD_UP)


def interrupt_handler(channel):
    global state

    print("interrupt handler")

    if channel == 19:
        if state == 1:
            state = 0
            print("state reset by event on pin 19")
    elif channel == 26:
        if state == 0:
            state = 1
            print("state set by event on pin 26")


GPIO.add_event_detect(26, GPIO.RISING,
                      callback=interrupt_handler,
                      bouncetime=200)

GPIO.add_event_detect(19, GPIO.RISING,
                      callback=interrupt_handler,
                      bouncetime=200)


while (True):
    time.sleep(0)

Interrupts are not supported in the python version of wiringPi2 because it's a wrapper of the original wiringPi C library. To quote the publisher of the module in issue 8 of it's github:

... I will have to look at implementing Python-wrapped interrupts in a different manner. At the moment your only choice is to set up a polling loop. Sorry!

Try using RPI.GPIO if you want a python module with interrupt support. I think it comes with the standard Raspbian image as well, here's the Inputs page that has the interrupt function.

If you still want to use wiringPi the solution would be as you have already done, a while loop that pools constantly the desired pin then breaks out when it changes.

wiringPi-python doesn't define the constants like INPUT, OUTPUT and INT_EDGE_BOTH, you will need to define them beforehand referring to them. Those constants are defined in the C library.

Good luck!

Python may not be the best choice if you have high or sustained data rates. You would be much better off using C.

Try the following Python. It should capture all the interrupts although if you have sustained high interrupt rates it may take time for them all to be processed.

#!/usr/bin/env python

import time

import pigpio # http://abyz.me.uk/rpi/pigpio/python.html

pi = pigpio.pi()
if not pi.connected:
   exit(0)

cb = pi.callback(21)

while True:
   print(cb.tally())
   cb.reset_tally()
   time.sleep(1)

Linux as shipped with the Pi is not a real time operating system but version do exist called RTOS or RT Linux and some kernel mods for the Pi have been seen in the wild to give some added ability.

Add onto this, Python is an interpreted language and can suffer from the Global Interpreter locking threads let alone from the OS wanting the CPU for its own tasks.

Python brings its own multi-threading and multi-process libraries to help getting more than one thing done.

You are always limited by the OS, devices attached to the CPU and native programming so ‘real-time’ is not something a multitasking computer is very good at.

In your case, it is always possible to lose data (see Tom Scott on YouTube for why no message can be 100% guaranteed) and this is why check routines and hardware signalling has been part of computing since day one.

Remember some communications subsystems on the Pi are handled by the OS (disk / serial / USB) and they operate at speeds in excess of normal GPIO based data transfers by building in checks and correct hardware design.

If you are looking for robust communication, you need to look at:

• Interrupt driven capture so the link disrupts the normal program flow not the other way around.
• Limiting what the machine is doing outside of data communications
• Have a fast enough processor and memory and disk etc etc to handle all the demands
• Building control signalling (either hardware or software) into the link
• Building checks into the data so you know it’s correct or not
• Look at using buffers (Python Queues being one way) where processing is separate from capture
• Look at using extra hardware to provide a buffer between the high speed data and the slow speed data.

I think you will be surprised as to the amount of data and speed the Pi can handle BUT it depends on the application and connections.