Docstoc

HC RTI effacement

Document Sample
HC RTI effacement Powered By Docstoc
					                                                                                            HC12RTI
     RTI, Interruptions, EEPROM
                                                                                            Laboratoire HC12



         Objectif           Comprendre le fonctionnement des interruptions
         Moyens             Microcontrôleur HC12, robot Cyclope
         Préalables         Cours de base HC12
         Théorie            Interruptions, plan mémoire du HC12
         Matériel           Cart es labo HC12,
                            Outils de cross développement Hiware, module BDI
                              30
         Durée              1h

1 Introduction
Pour traiter les interfaces programmables très rapidement et sans que le processeur ne passe son
temps à scruter les fanions des événements activés, le processeur peut être interrompu. Le principe
de fonctionnement est le suivant :
    Le processeur exécute son programme normalement séquentiellement
    Un événement externe arrive
          Activation du fanion dans le registre de contrôle associé
                Si le fanion associé d'autorisation des int erruptions est activé (au préalable par le
                 programmeur) ET
                Si le processeur a son fanion d'autorisation générale des interruptions activé :
                    Recherche dans la table des vecteurs d'int erruptions, l'adresse de la routine à
                     exécuter
                        Masquage des interruptions générales
                        Sauvetage des registres du processeur (P C, IY, IX, IY, B, A, CCR)
                    Exécution de la routine d'interruption
                        Traitement de l'interruption
                        Désactivation du fanion de requête d'interruption
                    RTI  Fin de la routine
                        Récupération des registres par le proc esseur
                        Reprise du programme interrompu
    Le programme principal continue

2 Table des vecteurs d'interruptions
La rec herc he de la routine d'interruption a exécut er s'effectue à travers une table, appelée table des
vecteurs d'interruptions. A chaque source possible d'interruption est associé un vecteur. Ce vecteur
permet de trouver directement au moy en d'une table l'adresse de la routine d'int erruption.
Pour le 68HC12, cette table se trouve à une adresse fixe qui va de $FF80 à $FFFF.
Les interruptions sont masquables individuellement par un bit se trouvant dans un registre de contrôle
spécifique (Registre d'aut orisation, table suivante).
Un bit du registre CCR (Condition Code Register), registre des fanions généraux du processeur
masque globalement toutes les interruptions: bit I.
Dans ce tableau, se trouvent également les adresses pour les cas de Reset qui ne sont pas
masquables globalement :
    Reset, initialisation totale ! pas de retour d'un Reset
    COP (2x )

LAP-EPFL / RB                                      D:\Docstoc\Working\pdf\d6da666b-20d5-4024-8e73-1a72e0aaa345.doc
LSN-EIG_HESSO / RB
Créé le 12/03/05                                                                                      Version [0.4]
Modifié le 09/09/10 04:09                                                                    Impression le 09/09/10
                                                      2


Deux interruptions logicielles permettent de détecter les codes des instructions non implémentées, ou
une interruption logicielle
     Trap
     SWI
Deux interruptions en provenances de pins externes :
     XIRQ, masquable par bit X de CCR
     IRQ
Bit I = 1 : interruption masquée, non acceptée

    Adresses                                          Masque
                     Source d'interruption                         Registre d'autorisation (Bit)      HPRIO
     vecteur                                           CCR
    $FF80- $FFC3   Reserved                               I bit                                       $80-$C4
    $FFC4- $FFC5   MSCAN Transmit                         I bit   CTCR (TXEIE[2:0])                     $C4
    $FFC6- $FFC7   MSCAN Receive                          I bit   CRIER (RXFIE)                         $C6
    $FFC8- $FFC9   MSCAN Errors                           I bit   CRIER (RWRNIE, TWRNIE,                $C8
                                                                  RERRIE,TERRIE, BOFFIE, OVRIE)
$FFCA- $FFCF       Reserved                               I bit                                      $CA-$CF
    $FFD0- $FFD1   MSCAN Wake-Up                          I bit   CRIER (WUPIE)                         $D0
    $FFD2- $FFD3   ATD                                    I bit   ATDCTL2 (ASCIE)                       $D2
    $FFD4- $FFD5   Reserved                               I bit                                         $D5
    $FFD6- $FFD7   SCI 0                                  I bit   SC0CR2 (TIE, TCIE, RIE, ILIE)         $D6
    $FFD8- $FFD9   SPI Serial Trans fer Complete          I bit   SP0CR1 (SPIE)                         $D8
$FFDA- $FFDB       Pulse Accumulator Input Edge           I bit   PACTL (PAI)                           $DA
$FFDC- $FFDD Pulse Accumulator Overflow                   I bit   PACTL (PAOVI)                         $DC
$FFDE- $FFDF       Timer Overflow                         I bit   TMSK2 (TOI)                           $DE
    $FFE0- $FFE1   Timer Channel 7                        I bit   TMSK1 (C7I)                           $E0
    $FFE2- $FFE3   Timer Channel 6                        I bit   TMSK1 (C6I)                           $E2
    $FFE4- $FFE5   Timer Channel 5                        I bit   TMSK1 (C5I)                           $E4
    $FFE6- $FFE7   Timer Channel 4                        I bit   TMSK1 (C4I)                           $E6
    $FFE8- $FFE9   Timer Channel 3                        I bit   TMSK1 (C3I)                           $E8
$FFEA- $FFEB       Timer Channel 2                        I bit   TMSK1 (C2I)                           $EA
$FFEC- $FFED       Timer Channel 1                        I bit   TMSK1 (C1I)                           $EC
    $FFEE- $FFEF   Timer Channel 0                        I bit   TMSK1 (C0I)                           $EE
    $FFF0- $FFF1   Real Time Interrupt                    I bit   RTICTL (RTIE)                         $F0
    $FFF2- $FFF3   IRQ                                    I bit   INTCR (IRQEN)                         $F2
    $FFF4- $FFF5   XIRQ                                   X bit   none                                    –
    $FFF6- $FFF7   SWI, Software Interrupt                none    none                                    –
    $FFF8- $FFF9   Unimplemented Instruction Trap         none    none                                    –
    $FFFA- $FFFB   COP Failure Reset                      none    COP rate selected                       –
$FFFC- $FFFD       COP Clock Monitor Fail Reset           none    COPCTL (CME, FC ME)                     –
    $FFFE- $FFFF   Reset                                  none    none                                    –

                                       Figure 1 Table des interruptions
La priorité en cas de requête non masquées simult anées va du Reset (plus haute priorité) à XIRQ
dans l'ordre du tableau.
La priorité d'une int erface peut être mise au plus haut des masquables par le registre HPRIO ($1F). La
valeur indiquée dans la colonne de droite permet de placer l'interruption correspondante en tête de
priorité.
L'interruption matérielle IRQ à la plus haute priorité par défaut, suit le RTI (Real Time Interrupt ), etc…

LAP-EPFL / RB                                                                         Laboratoire HC12 / HC12RTI
                                                  3



3 Plan mémoire du HC12
Selon le mode de démarrage, le 68HC12 possède divers plans mémoire. Le problème avec les
interruptions est d'initialiser les vecteurs en mémoire de $FF80 -$FFFF.
Cas possibles :
   Mode ét endu
       Vecteurs en mémoire externe
   Mode Single Chip normal
       Vecteurs en Flas h EEprom au démarrage
   Mode single chip special (B DI, développement)
       Démarrage par BDI, code du logiciel caché en $FF00 --$FFFF




                                  Figure 2 Plan mémoire du 68HC12


   La mémoire RAM de 1k octets peut être déplacée pa r pas de 2Koctets :
       ($0000-$03FF)+n*$0800 avec n: 0--31
                                                                                    er
Elle ne peut pas être déplacée dans la zone des vecteurs, car elle n'accède que le 1 koctets sur les
2 qu'il est possible de "mapper".
   La mémoire EEPROM de 768 octets peut être déplac ée par pas de 4Koctets :
      ($0D00-$0FFF)+n*$1000 avec n: 0--15
Elle peut être déplacée dans la zone des vecteurs, car elle accède que les derniers 768 octets sur les
4k qu'il est possible de "mapper". Elle peut être placée entre $FD00 -$FFFF.
Attention, dans le ca s des carte s du labos, le démarrage est effectué par le debugger ou en
mode single-chip. Dans ce dernier cas, le passage en mode étendu est réalisé par logiciel au
démarrage en programmant les registres de contrôle associés (P EAR, MODE, MISC).


LAP-EPFL / RB                                                                 Laboratoire HC12 / HC12RTI
                                                    4


Le registre INITEE permet d’autoriser l’utilisation de cette mémoire et de la « déplacer » dans une
autre zone de 4k.
INITEE      0x0012 Mapping EEPROM           EE15     EE14   EE13   EE12     0       0        0    EEON
                                  Reset :     0         0     0       0     0       0        0       1
      EE15..EE12     Page de 4k             4 bits de poids fort de l'adresse de la page EEPROM
                                             0     EEPROM désactivée
         EEON        Autorise EEPROM
                                             1     EEPROM autorisée



4 Accès à la table des vecteurs
Pour permettre une programmation des adresses des routines d'interruptions, il faut placer la mémoire
EEPROM dans la dernière page de la mémoire pour quelle soit accessible de $FD00 -$FFFF.


                                            $F1  INITEE
Pour écrire dans la zone EEPROM, il faut effacer et programmer avec un algorithme spécifique cette
mémoire. Comme elle n'est garantie que 10'000 fois, il est préférable de vérifier si la nouvelle valeur
n'est pas égale à celle déjà programmée.

4.1   Base pour les interruptions
Le module base.h définit des procédures pour la gestion des interruptions et l'initialisation des
registres des ports et de mapping des zones mémoire.
Le module .h définit les prototypes des procédures et le fichier .c le source des fonctions.
A noter la définition du type InterruptRoutine qui est défini comme l'adresse d'une routine qui rend un
type void.
//
// base.h
//

#ifndef base
#define base

// Définition d'un type pour l'adresse d' une fonction retournant
// void. Typiquement une routine d'interruptions.
typedef void (*InterruptRoutine)();

void InitMap(void);
void disable_interrupts();
void enable_interrupts();
unsigned char WrEEPROM_W(unsigned short *Adrs, unsigned short Data);
InterruptRoutine InitIntVect(unsigned short Vector, InterruptRoutine FnctAdrs);

#endif



#include <6812b32.h>
#include <base.h>

//
// Initialise des ports par défaut pour la carte ROKHC12
//
void InitPort(){

à modifier selon application…

}




LAP-EPFL / RB                                                                   Laboratoire HC12 / HC12RTI
                                              5



// Initialise le plan mémoire selon les définitions ci-dessous.
// L'EEPROM est notamment placée en haut du plan, de manière à
// comprendre les vecteurs d'interruptions.
//
#define BaseReg           0x0000
#define BaseInternalRAM   0x0800
#define BaseEEPROM        0xF000

void InitMap(void){
//   MISC = 0x3b; // Stretch externe pér 3 clock, mémoire     1 stretch, Flash enable
8000->ffff
     MISC = 0x3A; // Stretch externe pér 3 clock, mémoire     1 stretch, Flash DISABLE
8000->ffff
     PEAR = (0<<7)+(0<<4)+(1<<2)                              //   NBDE, E-Clk, R//W
     MODE = (1<<7)+(1<<5)+(1<<4)+(0<<3)+(0<<2)+(0<<0);        //   Mode Expanded Narrow
     MODE = (1<<7)+(1<<5)+(1<<4)+(0<<3)+(0<<2)+(0<<0);        //   Mode Expanded Narrow
//   INITRG = ((BaseReg >> 8) & 0xF8) + (1<<0);               //   Mapping Registres
//   INITRM = ((BaseInternalRAM >> 8) & 0xF8);                //   Mapping RAM interne
     INITEE = ((BaseEEPROM >> 8) & 0xF0) + (1<<0);            //   Mapping EEPROM
     return;
}

void disable_interrupts(){
     asm {
           SEI;
     }
}

void enable_interrupts(){
     asm {
           CLI;
     }
}

//
// Ecrit un mot de 16 bits, Data, à l'adresse Adrs qui doit
// correspondre à une zone mémoire mappée dans l'EEPROM.
// Algorithme d'écriture dans l'EEPROM: Effacer, attendre, écrire, attendre.
// Retourne 0 si Data n'a pas été écrit.
//
unsigned char WrEEPROM_W(unsigned short *Adrs, unsigned short Data){
     volatile int i;            // Compteur pour boucles d'attente actives

      // Refuse l'écriture d'un mot à un adresse impaire
      if ((unsigned short)Adrs & 0x01)
           return 0;

      // On préfère interdire les interruptions durant l'écriture
      disable_interrupts();

      EEPROT = 0xFE;              // Autorise écriture dans block BPROT0

      // Effacement
      EEPROG =    (1<<4)          //   One Byte or Word aligned erase
           |(1<<2);               //   Erase
      EELAT = 1;                  //   Latch Address and Data
      *Adrs = Data ;              //   Write Data
      EEPGM = 1;                  //   Programme
      for (i=0;i<10000;i++) {;}   //   Boucle d'attente
      EEPGM = 0;
      EELAT = 0;

      // Ecriture
      EEPROG =    (1<<4)          //   One Byte or Word aligned program
                  |(0<<2);        //   Programme
      EELAT = 1;                  //   Latch Address and Data
      *Adrs = Data ;              //   Write Data
      EEPGM = 1;                  //   Program

LAP-EPFL / RB                                                           Laboratoire HC12 / HC12RTI
                                                 6


      for (i=0;i<10000;i++) {;} // Boucle d'attente
      EEPGM = 0;
      EELAT = 0;

      EEPROG = 0x80;                 // Fin programmation

      // Teste le résultat en lisant ce qui a vient d'être écrit
      return (*Adrs == Data);      // Retourne TRUE si lecture OK
}

//
// Initialise un vecteur d'interruptions à l'adresse Vector, avec
// l'adresse d'une fonction.
// Retourne l'adresse de fonction qui était précédemment stockée dans
// ce vecteur.
//
InterruptRoutine InitIntVect(unsigned short Vector, InterruptRoutine FnctAdrs){
    unsigned short *VectorAdrs = (unsigned short *)Vector;
     InterruptRoutine OldFnct = *VectorAdrs;

      // Vecteur déjà OK ?
      if ((unsigned short)FnctAdrs == *VectorAdrs)
         return OldFnct;   // Déjà bon

    // EEPROM mappée correctement ?
    if (INITEE == ((BaseEEPROM/0x100) &0xF0) + (1<<0)) {
         if (! WrEEPROM_W(VectorAdrs, (unsigned short)FnctAdrs))
            return 0;
    }
    else
         return 0;

    return OldFnct;
}



5 Real Time Interrupt
// main.c
//
// Module principal
//
#include <6812b32.h>      // R:\Hiware\Exec\HC12\Lib\hc12\include\
#include <base.h>
#include <stdio.h>

volatile unsigned char Mubus[64] @0x200;

void main(){
     COPCTL = 0x00; // Enlève Watch-Dog -> pour version Flash
     InitMap();       // Mapping: Registres internse, RAM interne, EEPROM interne
     InitIntVect(0xFFF0, IntRTI);          // Init Int vector RTI
     InitPort();
     enable_interrupts();                  //autorise interruptions globales
     while(1){
           printf("essai");
     }
}
A vec le logiciel de développement Hiware, une procédure d'interruption est spécifiée avec le pragma
de compilation #pragma TRAP_PROC
//
// Interruption périodique
#pragma TRAP_PROC
void IntRTI(void){
    static uchar Cnt;
    char i;
     . . .            //traitement et quittance
}

LAP-EPFL / RB                                                                Laboratoire HC12 / HC12RTI
                                                      7




Manipulation 1            Interruption périodique
     Mettez en œuvre le système d'interruption périodique RTI
     Dans la procédure RTI, incrément ez un compteur que vous affichez sur Mubus

5.1     Registres en relation avec les fonctions d'horloge




    RTIE          Activation de l'interruption temps réel. Ecriture ou lecture en tout temps
                  0      interruptions dues au RTI désactivées
                  1     interruptions dues au RTI activées
    RTR[ 2:0]     Sélection de la fréquence de répétition de l'interruption temps réel. Ecriture et lecture
                  en tout temps. L'horloge E est utilisée dans ce module.




                               Figure 3 Sélection de la période d'interruption




    RTIF          Fanion d'interruption temps réel. Ce bit est automatiquement remis à 0 lors de
                  l'écriture dans ce registre avec ce bit à ‘1’. (Ecrire RTIFLG =0x80 ; )
                  0       le dépassement de temps n'est pas encore arrivé
                  1     le dépassement de temps s'est produit


Manipulation 2
     Mise ensemble des labos ATD, PWM et RTI :
          Dans la routine d’interruption RTI, lancez une conversion du convertisseur A TD avec
      interruption
          Dans la routine d’interruption A TD, modifiez le « duty » du PWM en fonction du c onvertisseur
      ATD, copiez cette valeur sur Mubus[1]
     Le programme principal est une boucle qui copie les interrupteurs du Mubus sur l’affichage de
      gauche (Mubus[0])




LAP-EPFL / RB                                                                       Laboratoire HC12 / HC12RTI
                                                   8


5.2   Registres de Watch Dog
Pour permettre un fonctionnement plus sécurisé d’un système embarqué, un watch-dog (chien de
garde) est implémenté sur les microcontrôleurs. S’il n’est pas servi régulièrement, il provoque un
Reset du processeur. P ratique s’il est utilisé, mais ne permet pas au système de fonctionner s’il n’est
pas servi.
Donc pour nos exemples, il doit être désactivé au démarrage. (0 CR2..0)




   CME          Activation de la surveillance d'horloge. Ecriture et lecture en tout temps. Si le bit
                FCME est positionné, ce bit n'a aucune signification ni aucun effet
                0      la surveillance d'horloge est désactivée. On peut utiliser les horloges lent es de
                       même que l'instruction stop
                1      les horloges lent es ou arrêtées (y compris l'instruction stop) provoquent une
                       séquence de reset
   FCME         Activation de la surveillance d'horloge forcée. Ecriture une seule fois dans les modes
                normaux, en tout temps dans les modes spéciaux. Lecture en tout temps. Dans les
                modes normaux, quand ce bit est positionné, la fonction de surveillance d'horloge ne
                peut être désactivée jusqu'à ce qu'un reset se produise.
                0      la surveillanc e d'horloge suit l'état du bit CME
                1      les horloges lent es ou arrêtées provoquent une séquence de reset d'horloge
   CR[2: 0]     Sélection de la fréquence de répétition de l'horloge de garde. Le système COP est
                                                                13
                conduit par une fréquence constante de E/2 . Ces bits spécifient un facteur de
                division supplémentaire. Une seule écriture dans les modes normaux, en tout temps
                dans les modes spéciaux. Lecture en tout temps. La figure 27 montre les différentes
                périodes qui peuvent être sélectionnées.




                           Figure 4 Périodes de répétition du système COP




LAP-EPFL / RB                                                                    Laboratoire HC12 / HC12RTI
                                                   9




HC12RTI                      Nom :                     Prénom:                      Section :


Réponse 1
1.1 Effectuez une démonstration à l’assistant et expliquez ce que vous avez fait.




Réponse 2

2.1 Effectuez une démonstration avec oscilloscope pour vérifier le PWM




LAP-EPFL / RB                                                                  Laboratoire HC12 / HC12RTI

				
DOCUMENT INFO
Shared By:
Categories:
Tags: effacement
Stats:
views:18
posted:9/9/2010
language:English
pages:9
Description: HC RTI effacement