How can I escape from a GPIO.wait_for_edge?

I have this code:

while True:
  try:
    Stat1 = GPIO.input(WPIN)
    time.sleep(WARNST)
    Stat2 = GPIO.input(WPIN)
    if Stat1 == Stat2: SendWarnStat(Stat2)
    Event = None
    while Event != WPIN: Event = GPIO.wait_for_edge(WPIN, GPIO.BOTH)
  except:
    break

Is there a way to make my script exist when I press Ctrl+C or the system ask it to terminate ? It seems that everything is blocked by the wait_for_edge function... I want to send some messages when the state of the pin is changed, and I want to do this without bother the CPU constantly checking that pin, so I have to use the wait function... Can I move the wait function in a thread and wait for multiple objects, one of them being a flag that is swiched from the main thread ? I am verry new to Python...

As described in a wiki, you could replace the blocking wait_for_edge by a threaded non-blocking add_event_detect + add_event_callback

Quote:

> RPi.GPIO runs a second thread for callback functions. This means that callback functions can be run at the same time as your main program, in immediate response to an edge.

Exemplary code (untested)

# define callback for event
def do_something(channel):
    print(f"Channel {channel} detected an event!")

# add event trigger and link callback outside of loop
GPIO.add_event_detect(WPIN, GPIO.BOTH)
GPIO.add_event_callback(WPIN, do_something)

# your code
while True:
  try:
    Stat1 = GPIO.input(WPIN)
    time.sleep(WARNST)
    Stat2 = GPIO.input(WPIN)
    if Stat1 == Stat2: SendWarnStat(Stat2)
  except:
    break

You then can either call this function directly from any place in your code, or trigger it with the defined event.

This is how I solved the problem...

The callback_thread, although it doesn't seem to do anything, it must be present so that my_callback can be executed asynchronously, not in the main thread. I don't understand what is the connection between them, but that's what AI told me.

import RPi.GPIO as GPIO
import threading
import time
import signal
import sys

def my_callback(channel):
  global OldStat
  time.sleep(3)
  NewStat = GPIO.input(channel)
  if NewStat != OldStat:
    if NewStat == True: print("Channel {} is HIGH".format(channel))
    else: print("Channel {} is LOW".format(channel))
    OldStat = NewStat

def callback_thread(event):
  event.wait()

def Exit_Handler(signum, frame):
  event.set()
  GPIO.cleanup()
  thread.join()
  sys.exit(0)

signal.signal(signal.SIGTERM, Exit_Handler)
signal.signal(signal.SIGINT, Exit_Handler)

event = threading.Event()
thread = threading.Thread(target=callback_thread, args=(event,))
thread.start()

GPIO.setmode(GPIO.BCM)
GPIO.setup(4, GPIO.IN, pull_up_down=GPIO.PUD_UP)
OldStat = GPIO.input(4)
if OldStat == True: print("Channel 4 is HIGH")
else: print("Channel 4 is LOW")
GPIO.add_event_detect(4, GPIO.BOTH, callback=my_callback, bouncetime=100)
event.wait()