ISR :
L'ISR, ou "Interrupt Service Routine" (routine de service d'interruption), est un élément
fondamental dans la gestion des interruptions au sein d'un système informatique. Voici
quelques points clés concernant l'ISR :
1. Définition et rôle : L'ISR est un morceau de code qui est exécuté en réponse à une
interruption. Lorsqu'un périphérique ou un événement génère une interruption, le
processeur suspend son exécution normale et passe à l'ISR correspondant pour traiter
l'événement. Cela permet de répondre rapidement à des événements externes, comme
des entrées utilisateur ou des signaux de périphériques.
2. Vectorisation : Chaque ISR est associé à un vecteur d'interruption, qui est une entrée
dans une table des vecteurs d'interruption. Cette table permet au processeur d'identifier
rapidement quel ISR exécuter en fonction de l'interruption reçue. Cela est crucial pour
gérer plusieurs sources d'interruptions de manière efficace .
3. Contexte et sauvegarde : Lorsqu'une ISR est appelée, le contexte de l'exécution en
cours (comme les registres et la pile) doit être sauvegardé pour permettre un retour
correct à l'état précédent une fois l'ISR terminée. Cela inclut la sauvegarde des
variables locales et des registres utilisés, ce qui est souvent géré automatiquement par
le matériel ou le compilateur .
4. Fin de l'ISR : Une fois que l'ISR a terminé son traitement, elle doit signaler au
système que l'interruption a été servie. Cela se fait généralement par un signal
d'acquittement (End Of Interrupt, EOI), qui permet au système de reprendre
l'exécution normale .
5. Exécution et masquage : Les ISR doivent être conçues pour être courtes et efficaces,
car elles bloquent d'autres interruptions pendant leur exécution. Le masquage des
interruptions peut être utilisé pour éviter que d'autres interruptions ne soient traitées
pendant qu'une ISR est en cours d'exécution, ce qui est essentiel pour éviter des
conflits .
En résumé, l'ISR est un composant crucial pour la gestion des interruptions, permettant aux
systèmes de réagir rapidement aux événements externes tout en maintenant l'intégrité de
l'exécution des programmes.
Voici les réponses à vos questions basées sur le document fourni :
1. Nom du bit pour écouter ou non les interruptions
Le bit qui permet de contrôler l'écoute des interruptions est souvent appelé bit de masquage
des interruptions (ou interrupt mask bit). Ce bit peut être utilisé pour activer ou désactiver
les interruptions dans une zone critique, afin d'éviter des interruptions indésirables pendant
l'exécution d'une section de code sensible.
Utilisation dans une zone critique :
• Masquage des interruptions : On peut désactiver les interruptions en mettant ce bit à
1.
• Démasquage des interruptions : On peut réactiver les interruptions en mettant ce bit
à 0.
Syntaxes en C :
// Masquer les interruptions
__disable_irq(); // Syntaxe pour désactiver les interruptions
// Démasquer les interruptions
__enable_irq(); // Syntaxe pour activer les interruptions
2. Localisation de la routine d'interruption
La routine d'interruption (ISR) est généralement stockée dans une zone spécifique de la
mémoire, souvent appelée table des vecteurs d'interruption. Le CPU utilise l'adresse de
l'IRQ pour retrouver l'ISR correspondante.
Exemple chiffré pour le Timer 1 : Supposons que l'adresse de l'ISR pour le Timer 1 soit
0x0024. Lorsque le Timer 1 génère une INT, le CPU consulte la table des vecteurs
d'interruption à l'adresse 0x0024 pour exécuter la routine associée.
3. Blocage de la génération de l'INT du Timer 1
La génération de l'INT du Timer 1 peut être bloquée en utilisant un registre de contrôle qui
contient des bits de configuration. Le mot clé utilisé pour cela est souvent "disable" ou
"mask".
Exemple :
TIMER1_CONTROL_REGISTER &= ~(1 << TIMER1_INT_ENABLE_BIT); // Désactiver
l'INT du Timer 1
Dans cet exemple, TIMER1_INT_ENABLE_BIT est le bit qui active l'INT pour le Timer 1. En le
mettant à 0, on bloque la génération de l'INT.
4. Autorisation des interruptions du Timer 1
Pour autoriser les interruptions du Timer 1, on utilise une syntaxe similaire à celle du blocage,
mais en activant le bit correspondant.
Syntaxe :
TIMER1_CONTROL_REGISTER |= (1 << TIMER1_INT_ENABLE_BIT); // Activer l'INT
du Timer 1
Ici, on utilise l'opérateur OR pour mettre à 1 le bit qui active l'INT pour le Timer 1.
5. Mesurer la durée d'une routine d'interruption vide
Pour mesurer la durée d'une routine d'interruption vide, on peut utiliser un compteur de cycles
d'horloge. Voici un schéma simplifié :
+---------------------+
| Début de l'ISR |
| |
| (Code vide) |
| |
| Fin de l'ISR |
+---------------------+
Explication :
1. On démarre un compteur de cycles au début de l'ISR.
2. On exécute le code de l'ISR (qui est vide dans ce cas).
3. On arrête le compteur à la fin de l'ISR.
Évaluation en cycles : La durée d'exécution d'une ISR vide peut être mesurée en cycles
d'horloge. Par exemple, si l'ISR prend 10 cycles d'horloge pour s'exécuter, cela signifie que le
processeur a besoin de 10 cycles pour traiter l'interruption, même si aucune opération n'est
effectuée.
En résumé, la durée d'une routine d'interruption vide peut être influencée par divers facteurs, y
compris la vitesse d'horloge du processeur et l'architecture spécifique. Les valeurs exactes
peuvent varier selon le matériel utilisé.
La localisation de l'ISR (Interrupt Service Routine) par le CPU se fait généralement à travers
un mécanisme bien défini, qui implique plusieurs étapes et structures de données. Voici
comment cela fonctionne :
1. Table des vecteurs d'interruption :
o Le CPU utilise une table des vecteurs d'interruption qui contient des
adresses de toutes les ISRs. Chaque entrée de cette table correspond à une IRQ
spécifique.
o Lorsqu'une IRQ est générée, le CPU consulte cette table pour déterminer
quelle ISR doit être exécutée.
2. Numéro de vecteur :
o Chaque IRQ est associée à un numéro de vecteur unique. Ce numéro est
utilisé pour indexer dans la table des vecteurs d'interruption.
o Par exemple, si un périphérique génère une IRQ avec un numéro de vecteur de
2, le CPU regardera l'entrée 2 dans la table des vecteurs pour trouver l'adresse
de l'ISR correspondante.
3. Mécanisme d'interruption :
o Lorsqu'une interruption se produit, le CPU interrompt son exécution normale
et sauvegarde son contexte (état actuel, registre, etc.).
o Il utilise ensuite le numéro de vecteur de l'IRQ pour accéder à la table des
vecteurs d'interruption et récupérer l'adresse de l'ISR.
4. Exécution de l'ISR :
o Une fois que le CPU a l'adresse de l'ISR, il charge cette adresse dans le registre
d'instruction (Instruction Pointer ou Program Counter) et commence à exécuter
le code de l'ISR.
o Après l'exécution de l'ISR, le CPU restaure le contexte sauvegardé et reprend
l'exécution de la tâche interrompue.
5. Configuration :
o La table des vecteurs d'interruption est généralement configurée au démarrage
du système ou lors de l'initialisation des périphériques. Les adresses des ISRs
doivent être définies dans cette table pour que le CPU puisse les localiser
correctement.
En résumé, le CPU sait quelle ISR exécuter grâce à la table des vecteurs d'interruption, qui
associe chaque IRQ à une adresse d'ISR. Ce mécanisme permet une gestion efficace des
interruptions et assure que le bon code est exécuté en réponse à chaque événement matériel , .
