Les interruptions.

Détails
Catégorie : PCDuino
Affichages : 6770

Vote utilisateur: 5 / 5

Etoiles activesEtoiles activesEtoiles activesEtoiles activesEtoiles actives
 
Sommaire[Masquer]

1.  Activer les interruptions  sur la PCDuino.

Par défaut les interruptions ne sont pas activées il faut donc le faire. Dans une console, tapez donc cela : 

sudo modprobe sw_interrupt
 
echo sw_interrupt | sudo tee -a /etc/modules
 
puis ajouter :
 
KERNEL=="swirq", MODE="0666" 
 
à la fin du fichier /etc/udev/rules.d/99-local.rules en faisant
 
sudo geany /etc/udev/rules.d/99-local.rules 

2.  La librairie interruption.

Placer cette librairie dans le dossier du projet ou dans le dossier contenant les autres librairies.

  1. #!/usr/bin/python
  2. # -*- coding: utf-8 -*-
  3. """Fonctions de gestion des interruptions basées sur le code de cwilt du forum PCDuino (nommage
  4.    compatible Arduino et suppression des prints en cas d'erreur)
  5.    Frank SAURET 2015 - www.electropol.fr
  6.    licence creative common NC-by-sa
  7. """
  8. """ Arduino UNO permet l'utilisation de 2 interruptions nommées Int0 et Int1 respectivement
  9.    disponibles sur les broches 2 et 3. Pour activer ces interruptions sur la PCDuino il faut faire ce qui suit :
  10.       sudo modprobe sw_interrupt
  11.       echo sw_interrupt | sudo tee -a /etc/modules
  12.      
  13.       puis ajouter
  14.          KERNEL=="swirq", MODE="0666"
  15.       à la fin du fichier /etc/udev/rules.d/99-local.rules en faisant     
  16.          sudo geany /etc/udev/rules.d/99-local.rules
  17. """
  18. from fcntl import ioctl
  19. from os import getpid
  20. import signal
  21. import struct
  22. from pyduino_pcduino import *
  23. import threading
  24.  
  25. SWIRQ_START=0X201
  26. SWIRQ_STOP=0X202
  27. SWIRQ_SETPID=0X203
  28. SWIRQ_ENABLE=0X204
  29. SWIRQ_DISABLE=0X205
  30.  
  31. SWIRQ_RISING=0X0
  32. SWIRQ_FALLING=0X1
  33. SWIRQ_HIGH=0X2
  34. SWIRQ_LOW=0X3
  35. SWIRQ_CHANGE=0X4
  36.  
  37. RISING=2
  38. FALLING=3
  39. CHANGE=4
  40.  
  41. SWIRQ_PATH='/dev/swirq'
  42.  
  43. def interrupts():
  44.    """
  45.       En - Re-enables interrupts [after they've been disabled by noInterrupts()]
  46.      
  47.       Fr - Revalide les interruptions [après qu'elles aient été désactivées par noInterrupts()]
  48.    """
  49.    fichier=open(SWIRQ_PATH,'r')
  50.    irqnum=0x0
  51.    ret=ioctl(fichier,SWIRQ_ENABLE,struct.pack("@B",irqnum))
  52.    irqnum=0x1
  53.    ret=ioctl(fichier,SWIRQ_ENABLE,struct.pack("@B",irqnum))
  54.    fichier.close
  55.  
  56. def attachInterrupt(interrupt,ISR,mode):
  57.    """
  58.       En - Specifies a named Interrupt Service Routine (ISR) to call when an interrupt occurs. Replaces any
  59.       previous function that was attached to the interrupt. PCDuino boards have two external
  60.       interrupts : numbers 0 (on digital pin 2) and 1 (on digital pin 3).
  61.      
  62.       Fr - Définis une fonction d'interruption  (ISR) qui sera appelée quand une interruption se produira.
  63.       Cette définition remplace toute ancienne fonction préalablement attachée à cette interruption.
  64.       La PCDuino a 2 interruptions externes : 0 sur la patte 2 et 1 sur la patte 3.
  65.       --------------------------------------------
  66.       En -  Keyword arguments:
  67.       interrupt -- the number of the interrupt (0 or 1)
  68.       ISR -- the ISR (named Interrupt Service Routine ) to call when the interrupt occurs ; this
  69.          function must take no parameters and return nothing. This function is sometimes referred to as an
  70.          interrupt service routine.
  71.       mode -- defines when the interrupt should be triggered.
  72.          Five constants are predefined as valid values :
  73.             - LOW to trigger the interrupt whenever the pin is low,
  74.             - CHANGE to trigger the interrupt when the pin changes value,
  75.             - RISING to trigger when the pin goes from low to high,
  76.             - FALLING for when the pin goes from high to low,
  77.             - HIGH to trigger the interrupt whenever the pin is high.  
  78.      
  79.       Fr - Paramètres nommés :
  80.       interrupt -- le numéro de l'interruption (0 ou 1)
  81.       ISR -- Le nom de la fonction qui sera appelé quand l'interruption se produira ; cette fonction ne reçoit
  82.       aucun paramètre et ne retourne rien.
  83.       mode -- Définis ce qui déclenchera l'interruption.
  84.          Cinq constantes permettent ce choix :
  85.             - LOW l'interruption se produira tant que l'entrée sera à un niveau bas.
  86.             - CHANGE l'interruption se produira à chaque changement sur l'entrée,
  87.             - RISING l'interruption se produira à chaque front montant sur l'entrée,
  88.             - FALLING l'interruption se produira à chaque front descendant sur l'entrée,
  89.             - HIGH l'interruption se produira tant que l'entrée sera à un niveau haut. 
  90.    """
  91.    if mode==LOW:
  92.       hwmode=SWIRQ_LOW
  93.    elif mode==FALLING:
  94.       hwmode=SWIRQ_FALLING
  95.    elif mode==RISING:
  96.       hwmode=SWIRQ_RISING
  97.    elif mode==CHANGE:
  98.       hwmode=SWIRQ_CHANGE
  99.    elif mode==HIGH:
  100.       hwmode=SWIRQ_HIGH
  101.  
  102.    if interrupt==0:
  103.       #signal.signal(signal.SIGUSR1,ISR)
  104.       signal.signal(signal.SIGUSR1, lambda a, b: ISR())
  105.    elif interrupt==1:
  106.       #signal.signal(signal.SIGUSR2,ISR)
  107.       signal.signal(signal.SIGUSR2, lambda a, b: ISR())
  108.      
  109.    mypid=getpid()
  110.    irqnum=interrupt
  111.    fichier=open(SWIRQ_PATH,'r')
  112.    ret=ioctl(fichier,SWIRQ_STOP,struct.pack("@B",irqnum))
  113.    ret=ioctl(fichier,SWIRQ_SETPID,struct.pack("@Bii",irqnum,hwmode,mypid))
  114.    ret=ioctl(fichier,SWIRQ_START,struct.pack("@B",irqnum))
  115.    fichier.close
  116.    
  117. def detachInterrupt(interrupt):
  118.    """
  119.       En - Turns off the given interrupt.
  120.       Fr - Désactive l'interruption.
  121.       -----------------------------
  122.       En -  Keyword arguments:
  123.       interrupt: the number of the interrupt to disable (0 or 1)
  124.      
  125.       Fr - Paramètres nommés :    
  126.       interrupt : le numéro de l'interruption à désactiver (0 ou 1)
  127.    """   
  128.    irqnum=interrupt
  129.    fichier=open(SWIRQ_PATH,'r')
  130.    ret=ioctl(fichier,SWIRQ_STOP,struct.pack("@B",irqnum))
  131.    fichier.close
  132.    
  133. def noInterrupts():
  134.    """
  135.       En - Disables interrupts [you can re-enable them with interrupts()].
  136.      
  137.       Fr - Désactive les interruptions [vous pouvez les réactiver avec interrupts()]
  138.    """
  139.    fichier=open(SWIRQ_PATH,'r')
  140.    irqnum=0x0
  141.    ret=ioctl(fichier,SWIRQ_DISABLE,struct.pack("@B",irqnum))
  142.    irqnum=0x1
  143.    ret=ioctl(fichier,SWIRQ_DISABLE,struct.pack("@B",irqnum))
  144.    fichier.close

3.  Le programme d'exemple.

  1. #!/usr/bin/python
  2. # -*- coding: utf-8 -*-
  3.  
  4. from pyduino_pcduino import * # importe les fonctions Arduino pour Python
  5.  
  6. # exemple pyDuino - par Frank SAURET www.electropol.fr
  7. # Un interrupteur sur les entrées 2 et 3 (avec un pull up éventuellement)
  8. # Une LED avec sa résistance de 1k sur la broche 7
  9.  
  10. #import de la librairie interruption
  11. from interruption import *
  12.  
  13. # entete declarative
  14. LED=7  # declare la broche à utiliser
  15. CompteTour=0
  16. #--- setup ---
  17. def setup():
  18.    pinMode(LED,OUTPUT) # met la broche en sortie
  19.    noInterrupts()  #Inhibe les interruptions
  20.    """ Pour éviter une première interruption intempestive on désactive les interruptions avant l'attachement"""
  21.    attachInterrupt(0,interruption0,RISING)
  22.    attachInterrupt(1,interruption1,FALLING)
  23.    interrupts() #Valide les interruptions
  24.  
  25. # -- fin setup --
  26.  
  27. # -- loop --
  28. def loop():
  29.    global CompteTour
  30.    CompteTour=CompteTour+1
  31.    if CompteTour==2000000 :
  32.       interrupts()
  33.       print("""Pendant que la LED rouge est éteinte les interruptions sont autorisée""")
  34.       digitalWrite(LED,LOW)
  35.    if CompteTour==4000000 :
  36.       CompteTour=0
  37.       noInterrupts()
  38.       print("""Pendant que la LED rouge est allumée les interruptions sont interdites""")
  39.       digitalWrite(LED,HIGH)
  40.    
  41. # -- fin loop --
  42.  
  43. # Code exécuté lors de l'interruption  0 sur la patte 2
  44. def interruption0():
  45.    print ("""Front montant sur interruption 0""")
  46.    
  47. # Code exécuté lors de l'interruption  1 sur la patte 3
  48. def interruption1():
  49.    print ("""Front descendant sur interruption 1""")
  50.  
  51. #--- obligatoire pour lancement du code --
  52. if __name__=="__main__": # pour rendre le code executable
  53.    setup() # appelle la fonction setup
  54.    while not noLoop: loop() # appelle fonction loop sans fin

4.  Le cablage pour l'exemple.

​

 

 

Fichiers:
Interruption
  •  
  •  
  •  
  •  
  •  
  •  
(0 votes)

Librairie interruption et exemple + schéma de câblage.
Date mercredi 22 avril 2015 14:14 Taille du fichier 332.31 KB Téléchargement 35 Télécharger

 

Vous n'avez pas le droit de commenter cet article.

Commentaires   

Tony04
# Tony04 25-10-2015 03:37
Une aide précieuse ce site, bravo et merci à son concepteur.
Petite erreur me semble-t-il sur le câblage des interruptions, pin 2 et 3 à relier sur inter et non 1 et 2 comme sur l'image.
Frank SAURET
# Frank SAURET 25-10-2015 12:19
Je confirme pin 2 et 3. Mais je ne refais pas l'image tout de suite.
Merci
Frank SAURET
# Frank SAURET 30-10-2015 13:59
Image actualisée.