CodeWarrior: Déclaration des Interruptions [Forums - Astuces]
CodeWarrior: Déclaration des Interruptions [Forums - Astuces]
Pseudo Pass se souvenir de moi     Créer un compte
ARTICLES et TELECHARGEMENTS ~ FORUMS ~ LIENS  
 
             
 
Recherche
 
   
 

Parcourir ce sujet :   1 Utilisateur(s) anonymes



(1) 2 »


CodeWarrior: Déclaration des Interruptions
Accro
Inscrit:
06/07/2007 09:17
Messages: 697
Hors Ligne
Bonjour à tous.

J'ouvre ce sujet pour que l'on puisse discuter des méthodes de déclaration des interruptions.
Oui il y a plusieurs méthodes qui sont plus ou moins bonnes...

1) Méthode du fichier PRM:
VECTOR 0 _Startup /* Reset vector: this is the default entry point for an application. */
VECTOR ADDRESS 0xFF90 vIT_TrapInterrupt
VECTOR ADDRESS 0xFF92 vIT_TrapInterrupt
...

et le fichier de déclaration des fonctions
#pragma CODE_SEG NON_BANKED
    
void vIT_TrapInterrupt(void);
...
#pragma CODE_SEG DEFAULT


2) Méthode "Inline" :
interrupt VectorNumber_Vsci0 void ISR_SCI0(void// VectorNumber_Vsci0 fournit par les header du micro
{
...
}



Avez-vous d'autres méthodes?
Quel est votre préférence? Pourquoi? :)

Merci d'avance.

Posté le : 31/05/2016 11:23
Transférer la contribution vers d'autres applications Transférer


Re: CodeWarrior: Déclaration des Interruptions
Pilier de la communauté
Inscrit:
23/10/2005 11:40
De Aix les Bains (73)
Messages: 1929
Hors Ligne
Bonjour

oh la belle et grande question !

Perso dans CW je passais par le PRM. C’était simple et clair mais je n'étais pas fan parce que c’était en dehors du répertorie "source" et quand ça quitte le répertoire source je stresse...


Là je suis dans KDS et ça s'est compliqué pour simplifier. Les kinetis récents disposent d'un bootloader intégré et d'un mécanisme d'offset qui permet de recopier en RAM les vecteurs et de pointer naturellement dessus.
Le startup prévoit donc par défaut cette copie des vecteurs en RAM et va même jusqu'à imposer un nom à des fonctions correspondant à chaque IT. Il suffit d'ajouter dans son code la fonction du même nom et hop on saute dedans sur it. Simple à mettre en oeuvre mais de mon point de vu crado (les noms qu'ils ont mis ne me plaisent pas) et à ce jour j'ai pas bien compris donc je m'abstiens d'essayer de faire autrement.

Peut être que ce post m'aidera à mieux comprendre tous ces mécanismes !

Merci à toi

Posté le : 31/05/2016 11:50
Mieux vaut marcher dans la bonne direction que courir dans la mauvaise
Transférer la contribution vers d'autres applications Transférer


Re: CodeWarrior: Déclaration des Interruptions
Accro
Inscrit:
06/07/2007 09:17
Messages: 697
Hors Ligne
la méthode "Inline" permet d'éviter de toucher au PRM.
Cependant:
-Elle n'est pas ANSI
-On maitrise mal la liste des IT qui sont gérer ou non (genre forcer un trap sur les IT non pilotées...)

Je suis actuellement sur un projet ou non utilisons la méthode 1. Mais nous sommes en train d'inclure une stack externe qui utilise la méthode 2...
Nous allons avoir gros travail d'analyse et de doc pour clarifier l'ensemble...

Posté le : 31/05/2016 13:38
Transférer la contribution vers d'autres applications Transférer


Re: CodeWarrior: Déclaration des Interruptions
Accro
Inscrit:
06/07/2007 09:17
Messages: 697
Hors Ligne
Personne ne souhaite s'exprimer sur le sujet?
Pourtant il me semble important :/

Posté le : 01/06/2016 13:40
Transférer la contribution vers d'autres applications Transférer


Re: CodeWarrior: Déclaration des Interruptions
Accro
Inscrit:
28/09/2005 14:02
De Catalunya (66)
Messages: 541
Hors Ligne
Et bien moi, vous m'avez appris récemment à utiliser la méthode 2. Et je trouve que ça reste facile.

Posté le : 01/06/2016 14:07
Les octets s'envolent, les écrits restent !
Transférer la contribution vers d'autres applications Transférer


Re: CodeWarrior: Déclaration des Interruptions
Pilier de la communauté
Inscrit:
23/10/2005 11:40
De Aix les Bains (73)
Messages: 1929
Hors Ligne
Une question subsidiaire est :
Quoi faire des it dont on ne se sert pas dans son appli ? les intercepter, OK mais comment et pour faire quoi ?

Posté le : 01/06/2016 14:18
Mieux vaut marcher dans la bonne direction que courir dans la mauvaise
Transférer la contribution vers d'autres applications Transférer


Re: CodeWarrior: Déclaration des Interruptions
Pilier de la communauté
Inscrit:
13/10/2005 10:06
De haute-savoie (74)
Messages: 1163
Hors Ligne
Bonjour,

Sous S08 les deux méthodes sont bonnes car de toute façon elles ne sont pas portables ! Donc l'une ou l'autre ne permettra pas de porter le logiciel sans modification.
Sous Coldfire, c'est encore différent. Il y a le fichier exception.c qui permet de les gérer et je trouve pas mal cette méthode. Sous Kinetis je ne sais pas.

Les routines d'exception restent liées au CPU utilisé et donc très proche du matériel. C'est typiquement la couche HAL (Hardware Abstraction Level) qui sera à modifier en fonction du CPU.

Pour S08 je préfère la méthode du PRM qui permet de les voir globalement plutôt que de les disséminer dans le code.

A noter que c'est là qu'on se rend compte de l'intérêt de couper les fichiers bas niveau en deux couches : HAL et HIL.... car typiquement pour déclarer mes routines d'interruption, désormais je fais un passage par paramètre du pointeur sur la fonction d'interruption.

par exemple pour ma fonction TPM, dans la couche HAL, je déclare ma fonction d'interruption ainsi :

Au début de mon fichier TPM.c
/*** Global variables ***/
static TPM_CallbackType TPM_Callback [21];


et dans le TPM.h
typedef void(*TPM_CallbackType)(void);


Ensuite dans mon TPM.c :

/*--------------------------------------------------------------------------------
Description    : TPM module overflow Interrupts 

Call           : hardware interrupt routine. Jump to the callback function 
Input(s)       : none
Output(s)      : none
Return         : none
--------------------------------------------------------------------------------*/
#ifdef TPM1SC
interrupt VectorNumber_Vtpm1ovf void TPM1_Overflow_isr (void)
{
    
TPM1SC_TOF 0;                              /* Clear IT flag */     
    
TPM_Callback [TPM1OVFISR]();                /* Jump to callback */
}
#endif

#ifdef TPM2SC
interrupt VectorNumber_Vtpm2ovf void TPM2_Overflow_isr (void)
{
    
TPM2SC_TOF 0;                              /* Clear IT flag */     
    
TPM_Callback [TPM2OVFISR]();                /* Jump to callback */
}
#endif

#ifdef TPM3SC
interrupt VectorNumber_Vtpm3ovf void TPM3_Overflow_isr (void)
{
    
TPM3SC_TOF 0;                              /* Clear IT flag */     
    
TPM_Callback [TPM3OVFISR]();                /* Jump to callback */
}
#endif


Au passage on voit que j'utilise des #define pour activier le nombre de canaux selon le type de CPU utilisé. Ces #define sont dans un fichier plateforme.h

Ensuite dans ce même fichier TPM.c qui est dans la couche HAL, j'ai une fonction pour assigner ma routine d'interruption à une fonction quelconque ailleurs dans mon logiciel.

/*--------------------------------------------------------------------------------
Description    : Assign callback function to the ISR
Call           : TPM_AssignCallback (TPMIsrNumber, ISRFunctionName);
                  - TPMIsrNumber = enum (TPM1OVERFLOW, TPM1CH0-TPM1CH5 
                                                   TPM2OVERFLOW, TPM2CH0-TPM2CH5
                                                   TPM3OVERFLOW, TPM3CH0-TPM3CH5)
Input(s)       :  - ISRFunctionName = name of the ISR function to assign
Output(s)      : none
Return         : none
--------------------------------------------------------------------------------*/
void TPM_AssignCallback(eISRNUMBER eTPMIsrNumbervoid (*ISRFunctionName)(void))
{
    
TPM_Callback[eTPMIsrNumber] = ISRFunctionName;
}



Maintenant depuis mon fichier dans la couche HIL ou supérieure, il me suffit d'initialiser cette assignation ainsi :
... // routine d'init
...
    
/* Assign the ISR callback function */
    
TPM_AssignCallback (TPM3OVFISRRegularRuntimeExecutive);
    
    
/* Sequencer timer tick to 1 ms */
    
TPMModuleInit (TPM3TPM_BUSRATE_CLOCKCLOCK_DIVIDEBY_4TPM_ENABLE_INTERRUPTDISABLE_CENTER_ALIGNED_PWMRREX_TICK);
...


On voit ici que j'associe l'interruption TPM3OVFISR à la fonction RegularRuntimeExecutive ()

Cette fonction RegularRuntimeExecutive (qui est le scheduler de mon séquenceur de tâche qui s'exécute donc sous IT du TPM toutes les x ms est définie toute simplement comme n'importe quelle fonction dans un fichier RREX.c de couche supérieure (ma couche SERVICE) :

void RegularRuntimeExecutive (void)
{
 ...
}


Cela signifie que lorsque l'IT se déclenche, mon logiciel saute directement à la fonction RegularRuntimeExecutive qui elle est une fonction quelconque avec un prototype standard et j'en ai fais une routine d'interruption, sans avoir à appeler du hardware. cette fonction RegularRuntimeExecutive est donc ANSI et totalement portable sur n'importe quelle plateforme !



C'est assez puissant comme façon de faire je trouve.
Je ne l'ai pas inventée. Je m'en suis inspiré depuis un bout de code Freescale je crois.




Posté le : 01/06/2016 15:18
Transférer la contribution vers d'autres applications Transférer


Re: CodeWarrior: Déclaration des Interruptions
Accro
Inscrit:
06/07/2007 09:17
Messages: 697
Hors Ligne
Merci Stephane pour le temps pris pour cette réponse :).

Pas évident à comprendre au premier coup, mais c'est pas mal.
Je vais relire afin de bien comprendre ton archi ;)

Posté le : 01/06/2016 15:36
Transférer la contribution vers d'autres applications Transférer


Re: CodeWarrior: Déclaration des Interruptions
Pilier de la communauté
Inscrit:
13/10/2005 10:06
De haute-savoie (74)
Messages: 1163
Hors Ligne
Pour faire simple cette méthode consiste à créer un tableau dans lequel on stocke grâce à la fonction xxx_AssignCallback les pointeurs vers les fonctions que l'on va assigner aux IT.
et depuis l'IT, on saute dans ce tableau qui contient donc le pointeur vers une fonction et du coup le CPU saute dans la dite fonction
Donc lorsque l'IT matérielle se présente, on saute bien dans la fonction d'IT qui ne fait que faire un clear du flag puis appeler la fonction dont on a associé le pointeur dans le tableau

Posté le : 01/06/2016 15:53
Transférer la contribution vers d'autres applications Transférer


Re: CodeWarrior: Déclaration des Interruptions
Accro
Inscrit:
06/07/2007 09:17
Messages: 697
Hors Ligne
Oui, au lieu de faire un tableau de pointeur placer sur les vecteurs, tu fais un tableau de fonctions utilisé(es) par les handlers...
Et tu peux attraper les ISR non désirées en faisant:
-l'assignation de tout les handler (interrupt VectorNumber_xxx...) vers ton tableau.
-l'initialisation tout ton tableau avec un pointeur vers une fonction Trap...

C'est pas mal :)

Posté le : 01/06/2016 16:18
Transférer la contribution vers d'autres applications Transférer



 Haut   Précédent   Suivant
(1) 2 »



Vous pouvez voir les sujets.
Vous ne pouvez pas débuter de nouveaux sujets.
Vous ne pouvez pas répondre aux contributions.
Vous ne pouvez pas éditer vos contributions.
Vous ne pouvez pas effacez vos contributions.
Vous ne pouvez pas ajouter de nouveaux sondages.
Vous ne pouvez pas voter en sondage.
Vous ne pouvez pas attacher des fichiers à vos contributions.
Vous ne pouvez pas poster sans approbation.

[Recherche avancée]


Powered by XOOPS© The XOOPS Project
Contacter les administrateurs

CodeWarrior: Déclaration des Interruptions [Forums - Astuces]