Merci à @ user451777 pour le conseil sur le filetage. J'ai modifié le script Signalisation entre les threads et j'ai trouvé ce qui suit:

  import threading, timefrom random import randintdef flashLed (e, t): "" "flash the led spécifié toutes les secondes "" "alors que ce n'est pas le cas e.isSet (): print (couleur) time.sleep (0.5) event_is_set = e.wait (t) if event_is_set: print ('stop led from flashing') else: print (' leds off ') time.sleep (0.5) color = "red" e = threading.Event () t = threading.Thread (name =' non-block ', target = flashLed, args = (e, 2)) t. start () for i in range (0, 10): # Attribuer aléatoirement rouge ou vert toutes les 10 secondes randomNumber = randint (0,10) print (randomNumber) if (randomNumber < 5): color = "green" else: color = "red" time.sleep (10) e.set ()  

Ceci simule l'allumage / extinction de la led correspondante dans un thread pendant que l'exécution du programme continue dans le thread principal. Surtout, la fonction flashLed ne verrouille pas l'exécution pendant que les voyants clignotent.

Le thread principal utilise une variable globale pour définir la couleur de la LED, avec l'autre thread utilisant le variable globale pour allumer la led correspondante. Je pense que les variables globales sont généralement mal vues, je serais donc intéressé d’entendre parler de meilleures approches.

Je suis relativement nouveau dans Python, mais j'ai pu faire clignoter les LED tout en poursuivant l'exécution en utilisant la modulation de largeur d'impulsion (PWM) qui est intégrée au module RPi.GPIO. C'était à mon avis un moyen beaucoup plus facile et plus simple que le threading comme le suggèrent d'autres réponses, mais les deux méthodes fonctionneraient bien.

Créez simplement un objet PWM avec la fréquence souhaitée, puis appelez PWM.start (DC) et PWM.ChangeDutyCycle (DC) pour démarrer / modifier le cycle de service des LED. Continuez avec votre code puis appelez PWM.stop () pour arrêter la LED.

  #setup GPIO pins et importez le module GPIO g = GPIO.PWM (pin1,1) r = GPIO. PWM (pin2,1) g.start (0) r.start (0) greenStatus = False redStatus = False def flashLED (couleur): global greenStatus, redStatus if color == 'green': if redStatus: r.ChangeDutyCycle (0 ) redStatus = False sinon greenStatus: g.ChangeDutyCycle (50) greenStatus = True elif color == 'red': if greenStatus: g.ChangeDutyCycle (0) greenStatus = False sinon redStatus: r.ChangeDutyCycle (50) redStatus = True essayez: while True: if newMail (): flashLED ('green') else: flashLED ('red') #do faites d'autres choses ici et la LED continuera à clignoter sauf KeyboardInterrupt: g.stop () r.stop () GPIO.cleanup ()  

Fondamentalement, ce code démarre les deux LED avec un cycle de service de 0 pour qu'elles apparaissent éteintes. Chaque fois que flashLED (couleur) est appelé, il vérifie que la LED opposée est éteinte, si ce n'est pas le cas, son cycle de service est remis à 0. Ensuite, il allume l'autre LED si elle n'est pas déjà allumée. Le code est enveloppé dans un try / sauf pour qu'à la fin les deux objets PWM soient arrêtés et les broches GPIO nettoyées.

Je recommanderais le filetage. Je ne l'ai pas utilisé en Python pour donner l'exemple, mais cela créera un autre thread d'exécution qui sera parallèle au thread principal d'exécution. J'espère que quelques exemples de code suivront pour vous.

http://pymotw.com/2/threading/

@Stephen Lead, vous avez des questions sur les globaux. Parfois, avec des choses comme les fonctions de threading, les globaux semblent être des options raisonnables car les alternatives peuvent être plus compliquées. Cependant, c'est une bonne habitude de toujours les déclarer explicitement comme globales

  def flashLed (e, t): "" "clignote la led spécifiée toutes les secondes" "" couleur globale sans e.isSet ( ):  

car à un moment donné, vous essaierez d'assigner la variable et vous aurez du mal à comprendre pourquoi elle ne semble pas avoir d'effet.

Vous pouvez passez des arguments à la fonction qui sont modifiés par d'autres parties de votre programme ou qui sont modifiés par votre fonction mais les arguments doivent être des objets mutables. L'exemple le plus simple serait une liste, puis vous vous retrouvez avec la, à peine artificielle:

  def flashLed (e, t, color): ... print (color [0]) color = ["red"] e = threading.Event () t = threading.Thread (name = 'non-block', target = flashLed, args = (e, 2, color)) ... if (randomNumber < 5) : color [0] = "green"  

Si vous aviez des informations plus complètes à communiquer entre les deux threads, une liste pourrait sembler plus logique. Les files d'attente sont également assez simples à utiliser et méritent d'être vérifiées dans la documentation.

Vous pouvez faire quelque chose comme ceci:

  while True: if newMail (): # renvoie true si nouveau mail, false sinon flashLED ("green") else: flashLED ("red ") def flashLED (color): if color ==" red ": pin = 18 # remplace le numéro par le numéro GPIO si color ==" green ": pin = 24 # remplace le numéro par le GPIO number GPIO.output (pin, True) # remplace le pin par le numéro GPIO time.sleep (1) GPIO.output (pin, False)  

L'avantage de ceci est qu'il n'y a pas de threading impliqué. Vous devriez construire newMail () vous-même, sauf si une fonction similaire est disponible dans une bibliothèque ( cette réponse fournit une solution pour Gmail et POP)