Core Timer ; PIC32MX360F512L
Répondre à la discussion
Affichage des résultats 1 à 7 sur 7

Core Timer ; PIC32MX360F512L



  1. #1
    armand25

    Question Core Timer ; PIC32MX360F512L


    ------

    Bonjour,

    Voilà mon soucis : Je communique d'un pic18 à un pic32. Le pic18 envoie une trame à un débit de 125us/bits sur un port d'entrée de mon pic32. Je scrute le port d'entrée de mon pic32 une fois le bit de start reçu, a savoir le premier bit de la trame. Une fois reçu je stocke toutes les valeurs de la trame dans un tableau et Pour cela je dois scruter toutes les 125 us pour être synchro avec le pic18.


    Mon problème c'est qu'il n'y a pas de fonction wait assez précise, qui permettrait d'attendre exactement cette période de temps. Comme sur le pic18 où on aurait les fonctions Delay1KTCYX(unsigned char). Comment faire ?


    Sinon j'avais penser à utiliser le core timer :


    #define SYS_FREQ (80000000L)
    #define TOGGLES_PER_SEC 1
    #define CORE_TICK_RATE 1600000000 //(SYS_FREQ/2/TOGGLES_PER_SEC)

    void attente()
    {

    static int count=0;
    //configure the core timer
    OpenCoreTimer(CORE_TICK_RATE); // on définit la fréquence de réference du timer

    mConfigIntCoreTimer((CT_INT_ON | CT_INT_PRIOR_7 | CT_INT_SUB_PRIOR_0)); //active le timer, priorité élevé par defaut, pas de sous priorité

    INTEnableSystemMultiVectoredIn t(); // active multi-vector interruption



    while(count<125) { }

    mPORTDClearBits(BIT_0); //on éteind la led verte pour vérifier qu'on a bien quitter l'instruction de la boucle



    mConfigIntCoreTimer((CT_INT_OF F | CT_INT_PRIOR_0 | CT_INT_SUB_PRIOR_0)); // on désactive le timer

    }

    void __ISR(_CORE_TIMER_VECTOR, ipl2) CoreTimerHandler(void)
    {
    // clear the interrupt flag
    mCTClearIntFlag();

    // .. things to do
    count++;

    // update the period
    UpdateCoreTimer(CORE_TICK_RATE );


    // Toggle the LED
    //mPORTDSetBits(BIT_0);
    //wait();
    }

    En gros l'idée de mon code pour faire un compteur précis serait de :
    Je règle la fréquence du core_timer pour qu'il génère une interruption toutes les us.

    Dans la fonction attente :
    -J'active le timer, je le configure...
    -Mon count est initialiser à 0
    -J'active les interruptions donc toutes les us je fais un saut dans mon programme interruption qui incrémente count
    -Je rentre dans ma boucle while car count=0 donc <125 et je ne fais rien
    -Au bout de 125 us j'aurai incrémenter 125 fois mon count donc je devrai quitter ma boucle et éteindre donc la led verte.


    Cependant j'ai tester mon code dans la main est celui ci reste bloqué indéfiniment dans ma boucle, cela veut dire que count ne s'incrémente pas. Qu'en pensez vous ?


    Quels conseils pouvez vous me donnez, car je suis dans une impasse depuis plus d'1 semaine.


    Merci, bonne soirée, et merci pour la lecture en tout cas !

    -----

  2. #2
    satinas

    Re : Core Timer ; PIC32MX360F512L

    Salut,
    Pour détecter le début de trame tu peux déclencher une interruption sur changement de niveau sur la pin utilisée.
    Pour la mesure, le core timer ou l'un des nombreux autres timers.
    Si tu utilises le core timer, il faut mettre la même prioité à la déclaration et dans l'ISR, donc ipl7 à mettre dans la fonction ISR.

  3. #3
    RISC

    Re : Core Timer ; PIC32MX360F512L

    Salut Armand,

    Le core timer tourne en permanence à la moitié de la fréquence du PIC32 ;=)

    J'ai l'impression que tu as mal configuré l'interruption du core timer.

    Il faut absolument affecter la même priorité au core timer dans l'interruption ET dans la macro de configuration.

    Tu as donné la priorité 7 au core timer dans la macro de configuration :
    Code:
    mConfigIntCoreTimer((CT_INT_ON | CT_INT_PRIOR_7 | CT_INT_SUB_PRIOR_0)); //active le timer, priorité élevé par defaut, pas de sous priorité
    alors que tu donnes la priorité 2 dans l'interruption :
    Code:
    void __ISR(_CORE_TIMER_VECTOR, ipl2) CoreTimerHandler(void)
    Il suffit, je pense de donner le même niveau de priorité :
    Code:
    void __ISR(_CORE_TIMER_VECTOR, ipl7) CoreTimerHandler(void)
    Il existe je crois un exemple de code qui montre comment utiliser le core timer ici : http://www.microchip.com/codeexamples

    si tu veux accélerer le traitement, utilise le shadow registers dans ton interruption.


    a+
    Dernière modification par RISC ; 11/04/2012 à 23h43.

  4. #4
    armand25

    Re : Core Timer ; PIC32MX360F512L

    Bonjour, merci pour les conseils c'est vrai que j'ai oublié de changer la priorité dans la fonction interruption.

    void attente()
    {
    static int count=0;
    //configure the core timer

    OpenCoreTimer(CORE_TICK_RATE); // on définit la fréquence de réference du timer

    mConfigIntCoreTimer((CT_INT_ON | CT_INT_PRIOR_7 | CT_INT_SUB_PRIOR_0)); //active le timer, priorité élevé par defaut, pas de sous priorité
    INTEnableSystemMultiVectoredIn t(); // active multi-vector interruption
    while(count<10) { }
    mPORTDClearBits(BIT_0); //on éteind la led verte pour vérifier qu'on a bien quitter l'instruction de la boucle
    mConfigIntCoreTimer((CT_INT_OF F | CT_INT_PRIOR_0 | CT_INT_SUB_PRIOR_0)); // on désactive le timer
    }

    La fonction d'attente ci dessus à été modifié pour générer 10 changements de led par seconde puis ensuite eteindre le timer.

    J'ai testé avec la fonction exemple pour générer 10 changements de leds pas sec. Pour cela j'appelle ma fonction attente() cependant j'ai remarqué en testant que je ne quittais jamais ma fonction attente. De plus mon compteur ne s'incrémente pas, pq dont ? Si j'ai bien compris toutes les 0,1 s on fait un saut dans la fonction interruption dans lequel j'incrémente count. Donc à la fin count=10 donc on devrait ca devrait désactiver le timer puis quitter la fonction attente et donc eteindre ma led ?

  5. A voir en vidéo sur Futura
  6. #5
    RISC

    Re : Core Timer ; PIC32MX360F512L

    Salut Armand,

    Que cherches-tu à faire EXACTEMENT....

    Tu veux simplement un délai ? de combien ?
    Si tu génères des interruptions toutes les us tu vas assommer pour rien le PIC32 ;=)

    Si tu initialises correctement le core_timer et que tu testes le flag au bout du délai tu pourras implémenter le délai que tu veux.
    Cela dit c'est dommage de ne pas utiliser les interruptions pour gérer les attentes et de faire autre chose pendant ce temps.

    Quel type de trame envoie ton PIC18 ?
    Tu pourrais faire la gestion de la trame par DMA dans le PIC32, c'est à dire que ton PIC32 vient échantillonner régulièrement un port par DMA et range cela en mémoire. Quand la trame est finie tu fait un petit traitement pour récupérer les bits.

    C'est la technique utilisée dans le code d'exemple qui permet d'ajouter 8 UARTs par DMA au PIC32 en consommant seulement 5 à 10 MIPS ;=)
    Cet exemple se trouve ici : http://www.microchip.com/forums/m361004.aspx

    a+

  7. #6
    armand25

    Re : Core Timer ; PIC32MX360F512L

    Salut,

    J'ai réussie à faire marcher le coretimer et faire ce que je voulais. En faite le pic 18 m'envoyait une trame du type {1,0,0,0,1,0,1,1,0,1,0,0,1} avec un débit de donnée de : 500us/bit à mon pic 32. Je scrupte un bit de sortie de mon pic32 sur lequel j'envoie la trame du pic18 et je veux la réceptionner pour la stocker dans un tableau. Pour cela j'attends un état 1 bit de start de mon début de trame et je commence a stocker les valeurs dans le tableau et pour cela je cherchais une fonction d'attente très précise qui me permettrait d'attendre 500 us entre chaque scruptation. Cependant sur le pic 32 il n'existe pas de fonction nop() comme sur le pic18 qui permet d'attendre un cycle d'horloge et de plus sur le pic32 une fonction wait à la main avec une boucle for simple n'est pas assez précise, car si je n'ai pas le temps exacte, je loupe les valeurs de ma trame.

    C'est pour cela que j'utilisais le coretimer dans lequel j'active les interrutpions une fois le bit voulu recu et qui compte mes 500us. As tu compris ce que je voulais faire?

    Mais merci beaucoup pour les infos, je peux essayer d'optimiser mon code, pour gagner peut etre du temps de traitement.

  8. #7
    RISC

    Re : Core Timer ; PIC32MX360F512L

    Salut,

    Il existe aussi une fonction nop dans le C32 : Nop() mais attention...à cause de l'unité PREFETCH et du CACHE il est impossible de prévoir le temps d'exécution au cycle près (12.5ns)...Il faut utiliser des timers. Le Core Timer à une résolution de 25ns alors si tu dois faire une tempo de 500us c'est du gateau ;=)

    Cependant tu peux faire beaucoup mieux. Tu programmes un canal de DMA qui va échantillonner toutes les 500us un PORT d'entrée. La valeur est rangée en RAM automatiquement quand tous tes bit sont en mémoire il te suffit de venir traiter les échantillons par une interruption qui viendra extraire le bit de chaque mot. Si tu veux valider de façon plus sérieuse tu peux suréchantillonner chaque bit plusieurs fois et faire du vote majoritaire.

    J'ai en plus l'impression que tu as oublié de configurer ton PIC32 en mode optimal et que tu tournes pas du tout à 80MHz...
    Peux-tu fait voir tout ton code ?

    a+

Discussions similaires

  1. Programmation en C avec Timer 0 et Timer 1
    Par invite6844fe5f dans le forum Électronique
    Réponses: 43
    Dernier message: 20/04/2010, 13h27
  2. [Biochimie] Core virus
    Par Psedonyme dans le forum Biologie
    Réponses: 3
    Dernier message: 26/01/2010, 10h40
  3. INTEL CORE DUO ou CORE 2 DUO
    Par inviteb4d8c3b4 dans le forum Matériel - Hardware
    Réponses: 12
    Dernier message: 23/10/2006, 22h18
  4. Dual-core?
    Par invitea3a83812 dans le forum Technologies
    Réponses: 2
    Dernier message: 10/08/2004, 20h31
Découvrez nos comparatifs produits sur l'informatique et les technologies.