nz_tick.h

Go to the documentation of this file.

#ifndef _NZDEFAULT_TICK_H_
#define _NZDEFAULT_TICK_H_

//  "Interrupts" - documentation module

//The amount of uticks per micro second, default is 2
#if defined(__PIC24FJ256GB206__) || defined(__PIC24FJ256GB208__) || defined(__PIC24FJ256GB210__) || defined(__PIC24FJ128GB106__) || defined(__PIC24FJ128GB108__) || defined(__PIC24FJ128GB110__)
#ifndef NZ_UTICKS_PER_MS
#define NZ_UTICKS_PER_MS 2000
#endif
#elif defined(__PIC32MX__)
//Default is 80MHz crystal with 64 timer prescaller = 1250 ticks per milli second for timer
#ifndef NZ_UTICKS_PER_MS
#define NZ_UTICKS_PER_MS 1250
#endif
#endif


#ifndef __INLINE_FUNCTION__
#define __INLINE_FUNCTION__ extern inline __attribute__((always_inline))
#endif

#if defined(__C30__)

#ifndef nzINT_PRIORITY_TICK
#define nzINT_PRIORITY_TICK                     ( 5 )   //Define the interrupt priority level, 1-7 (7 is highest)
#endif

#ifndef nzINT_PRIORITY_UTICK
#define nzINT_PRIORITY_UTICK                    ( 6 )   //Define the interrupt priority level, 1-7 (7 is highest)
#endif

#if !defined(NZSYS_TICK_TMR2AND3_UTICK)
#define NZSYS_TICK_TMR2AND3_UTICK               ( 0 )   //Use Timer 2 and 3 for a dedicated uTick counter - for utickXxx() functions
#endif


#elif defined(__PIC32MX__)
    #if !defined(_T1IF)
        #define _T1IF   IFS0bits.T1IF
    #endif
    //IFS0CLR = _IFS0_T1IF_MASK;  //Clear interrupt flag
#endif

typedef WORD    TICK16;     //Used for tick16 and utick16 variables
typedef DWORD   TICK32;     //Used for tick32 and utick32 variables


extern volatile DWORD_VAL tick_val;


#define tickService() {     \
    /* Increment tick */    \
    tick_val.Val++;         \
}


void tickInit(void);



// Standard 16-bit, 1ms tick functions

TICK16 __INLINE_FUNCTION__ tick16Get(void)
{
    return tick_val.w[0];
}


#define tick16TestTmr(tmr)          ( (((((tmr) - (tick_val.w[0]) ) & 0x8000))==0) ? 0 : 1)
//#define tick16HasTmrExpired(tmr)    ( (((((tmr) - (tick_val.w[0]) ) & 0x8000))==0) ? 0 : 1)


#define tick16SetTmrMS(tmr, msVal) (tmr = (tick16Get() + msVal))


#define tick16GetElapsedMS(oldTick) ((WORD)((tick_val.w[0]) - (oldTick)))


//The method below DOES NOT work for TRUE comparison!!!! Because value will be 0 or 0x8000, and TRUE is 1!
//For example, this will NEVER return qualify:  if (tick16TestTmr(100) == TRUE)
//#define tick16TestTmr(tmr)      ( ((tmr) - (tick_val.w[0]) ) & 0x8000)

#define tick16UpdateTmrMS(tmr, msVal) (tmr += msVal)


#define tick16ConvertFromMS(msVal) (msVal)



// Long 32-bit, 1ms tick functions

DWORD tick32Get(void);


#define tick32Get_noDisi()  (tick_val.Val)


BOOL tick32TestTmr(DWORD tmr);


#define tick32SetTmrMS(tmr, msVal) (tmr = (tick32Get() + msVal))


#define  tick32TestTmr_noDisi(tmr)  ((((tmr-tick_val.Val)&0x80000000)==0) ? 0 : 1)


#define tick32UpdateTmrMS(tmr, msVal) (tmr += msVal)


#define tick32UpdateTmrSec(tmr, secVal) (tmr += (((DWORD)secVal)*1000))


#define tick32UpdateTmrMin(tmr, minVal) (tmr += ( ((DWORD)minVal)*60000))


#define tick32ConvertFromMS(msVal) ((DWORD)(msVal))



// Micro Tick functions

#if (NZSYS_TICK_TMR2AND3_UTICK==1)
#define utick16Get()    (TMR2)
#else
WORD utick16Get(void);
#endif


WORD __INLINE_FUNCTION__ utick16Get_noDisi(void) {
#if (NZSYS_TICK_TMR2AND3_UTICK==0)
    WORD tmrCpy;
    tmrCpy  = TMR1;

    //No tick ISR got triggered while we disabled interrupts. This means TMR1 did
    //NOT roll over!
    if (_T1IF == 0) {
        return ((tick_val.word.LW*NZ_UTICKS_PER_MS) + tmrCpy);
    }
    //ELSE
    //The TMR1 IF got triggered recently, and TMR1 ISR has not been executed yet! This
    //means that TMR1 can be = PR value, or reset to 0. It also means that tick_val was NOT
    //incremented yet, and will be incremented once TMR ISR is entered.

    #if (NZ_UTICKS_PER_MS==2000)
        //T1IF is triggered when TRM1=PR=1999. It will only reset to 0 at next TMR1 clock!
        tmrCpy = TMR1+1;            //Convert from 0-1999 to 1-2000
        if (tmrCpy==2000) tmrCpy=0; //Convert from 1-2000 to 0-1999

        return (((tick_val.word.LW+1)*NZ_UTICKS_PER_MS) + tmrCpy);
    #else
        #error "NZ_UTICKS_PER_MS not supported!"
    #endif
#else
    return TMR2;
#endif
}


#if (NZSYS_TICK_TMR2AND3_UTICK==1)
DWORD __INLINE_FUNCTION__ utick32Get(void) {
    DWORD_VAL ret;
    ret.word.LW = TMR2;
    ret.word.HW = TMR3HLD;
    return ret.Val;
}
#else
DWORD utick32Get(void);
#endif  //#if (NZSYS_TICK_TMR2AND3_UTICK==1)



DWORD __INLINE_FUNCTION__ utick32Get_noDisi(void) {
#if (NZSYS_TICK_TMR2AND3_UTICK==1)
    DWORD_VAL ret;
    ret.word.LW = TMR2;
    ret.word.HW = TMR3HLD;
    return ret.Val;
#else
    WORD  tmrCpy;
    tmrCpy  = TMR1;

    //No tick ISR got triggered while we disabled interrupts. This means TMR1 did
    //NOT roll over!
    if (_T1IF == 0) {
        return (DWORD)( ((DWORD)(tick_val.Val*NZ_UTICKS_PER_MS)) + tmrCpy);
    }
    //ELSE
    //The TMR1 IF got triggered recently, and TMR1 ISR has not been executed yet! This
    //means that TMR1 can be = PR value, or reset to 0. It also means that tick_val was NOT
    //incremented yet, and will be incremented once TMR ISR is entered.

    #if (NZ_UTICKS_PER_MS==2000)
        //T1IF is triggered when TRM1=PR=1999. It will only reset to 0 at next TMR1 clock!
        tmrCpy = TMR1+1;            //Convert from 0-1999 to 1-2000
        if (tmrCpy==2000) tmrCpy=0; //Convert from 1-2000 to 0-1999

        return (DWORD)( ((DWORD)((tick_val.Val+1)*NZ_UTICKS_PER_MS)) + tmrCpy);
    #else
        #error "NZ_UTICKS_PER_MS not supported!"
    #endif
#endif  //#if (NZSYS_TICK_TMR2AND3_UTICK==1)
}


#define utick16TestTmr(tmr)      ( (((((tmr) - (utick16Get()) ) & 0x8000))==0) ? 0 : 1)


#define utick16GetElapsedUS(oldTick) utick16ConvertToUS(((WORD)((utick16Get()) - (oldTick))))


#define utick16ConvertToUS(utickVal) ( ((WORD)utickVal) / ((WORD)(NZ_UTICKS_PER_MS/1000)) )


#define utick16ConvertFromUS(usVal) (WORD)( ((WORD)usVal) * (NZ_UTICKS_PER_MS/1000) )


#define utick32TestTmr(tmr)      ((((tmr-utick32Get())&0x80000000)==0) ? 0 : 1)


#define utick32ConvertToUS(utickVal) ( ((DWORD)utickVal) / ((DWORD)(NZ_UTICKS_PER_MS/1000)) )


#define utick32ConvertFromUS(usVal) (DWORD)( ((DWORD)usVal) * (NZ_UTICKS_PER_MS/1000) )



// 8us tick functions


#if (NZSYS_TICK_TMR2AND3_UTICK==1)
WORD __INLINE_FUNCTION__ tick16Get_8us(void) {
    DWORD_VAL dw;
    dw.word.LW = TMR2;
    dw.word.HW = TMR3HLD;
    #if (NZ_UTICKS_PER_MS==2000)
        return ((WORD)(dw.Val/16));
    #else
        #error "NZ_UTICKS_PER_MS not supported!"
    #endif
}
#else
WORD tick16Get_8us(void);
#endif


WORD __INLINE_FUNCTION__ tick16Get_8us_noDisi(void) {
#if (NZSYS_TICK_TMR2AND3_UTICK==1)
    DWORD_VAL dw;
    dw.word.LW = TMR2;
    dw.word.HW = TMR3HLD;
    #if (NZ_UTICKS_PER_MS==2000)
        return ((WORD)(dw.Val/16));
    #else
        #error "NZ_UTICKS_PER_MS not supported!"
    #endif
#else
    WORD tmrCpy;
#if defined(__C30__)
    tmrCpy = TMR1;
    if (_T1IF == 0) {
        //This function is ONLY called from and ISR with higher priority than
        //the TMR1 interrupt, so not TMR1 interrupt will occur while processing!
        //At this stage we know that tmrCpy did NOT reset to 0, use it!
        #if (NZ_UTICKS_PER_MS==2000)
            /* Convert 1ms resolution to 8us = x * (1000/8) = x * 125 */
            /* Convert 500ns to 8us */
            return ((tick_val.word.LW*125) + (tmrCpy/16));
        #else
            #error "NZ_UTICKS_PER_MS not supported!"
        #endif
    }
    //ELSE
    //The TMR1 IF got triggered recently, and TMR1 ISR has not been executed yet! This
    //means that TMR1 can be = PR value, or reset to 0. It also means that tick_val was NOT
    //incremented yet, and will be incremented once TMR ISR is entered.

    #if (NZ_UTICKS_PER_MS==2000)
        //T1IF is triggered when TRM1=PR=1999. It will only reset to 0 at next TMR1 clock!
        tmrCpy = TMR1+1;            //Convert from 0-1999 to 1-2000
        if (tmrCpy==2000) tmrCpy=0; //Convert from 1-2000 to 0-1999

        return (( ((WORD)(tick_val.word.LW+1))*125) + (tmrCpy/16));
    #else
        #error "NZ_UTICKS_PER_MS not supported!"
    #endif
#elif defined(__PIC32MX__)
    return 0;
#endif
#endif  //#if (NZSYS_TICK_TMR2AND3_UTICK==1)
}



#if (NZSYS_TICK_TMR2AND3_UTICK==1)
WORD __INLINE_FUNCTION__ tick32Get_8us(void) {
    DWORD_VAL dw;
    dw.word.LW = TMR2;
    dw.word.HW = TMR3HLD;
    #if (NZ_UTICKS_PER_MS==2000)
        return (dw.Val/16);
    #else
        #error "NZ_UTICKS_PER_MS not supported!"
    #endif
}
#else
WORD tick32Get_8us(void);
#endif


WORD __INLINE_FUNCTION__ tick32Get_8us_noDisi(void) {
#if (NZSYS_TICK_TMR2AND3_UTICK==1)
    DWORD_VAL dw;
    dw.word.LW = TMR2;
    dw.word.HW = TMR3HLD;
    #if (NZ_UTICKS_PER_MS==2000)
        return (dw.Val/16);
    #else
        #error "NZ_UTICKS_PER_MS not supported!"
    #endif
#else
    WORD  tmrCpy;
#if defined(__C30__)
    tmrCpy  = TMR1;
    //No tick ISR got triggered while we disabled interrupts. This means TMR1 did
    //NOT roll over! Convert 1ms resolution to 8us = x * (1000/8) = x * 125
    if (_T1IF == 0) {
        #if (NZ_UTICKS_PER_MS==2000)
            return (DWORD)( ((DWORD)(tick_val.Val*125)) + tmrCpy/16);
        #else
            #error "NZ_UTICKS_PER_MS not supported!"
        #endif
    }
    //ELSE
    //The TMR1 IF got triggered recently, and TMR1 ISR has not been executed yet! This
    //means that TMR1 can be = PR value, or reset to 0. It also means that tick_val was NOT
    //incremented yet, and will be incremented once TMR ISR is entered.

    #if (NZ_UTICKS_PER_MS==2000)
        //T1IF is triggered when TRM1=PR=1999. It will only reset to 0 at next TMR1 clock!
        tmrCpy = TMR1+1;            //Convert from 0-1999 to 1-2000
        if (tmrCpy==2000) tmrCpy=0; //Convert from 1-2000 to 0-1999

        return ( ((DWORD)((tick_val.Val+1)*125)) + (tmrCpy/16));
    #else
        #error "NZ_UTICKS_PER_MS not supported!"
    #endif
#elif defined(__PIC32MX__)
#endif
#endif  //#if (NZSYS_TICK_TMR2AND3_UTICK==1)
}

#endif  //end of #define _NZDEFAULT_TICK_H_