Svenska ElektronikForumet

Kod: Markera allt

program Extended_Timer

' ************************************************************************************
'  ***********   EXTENDED EVENT TIMER USING 18F4550 @ 48MHz and TIMER0  *************
'  *********** ReWritten with mikroBASIC 5.0.2 by XOR November 23, 2006 *************
'  ***********          Tested Using EasyPIC4 and 16x2 LCD              *************
' ************************************************************************************
'
' The object of this program is to create an event with accurate 100ms (0.01 second)
' resolution timing.  In the example below we will invert PORTB every 19.8 seconds.
'
' To create 100ms divisions we will use a PIC timer that can provide a count to at
' least 100ms with a 48MHz oscillator.  If we create an interrupt every 100ms we can
' use a second counter to accumulate the total time and further create an event when
' we've reached the desired total time.  The code below will use this method and
' create extended timing events with the smallest timing errors possible.
'
' PIC Timers increment...that is, they count up to their maximum value and then
' rollover to 0.  At this point the Timer sets an overflow flag which can be simply
' read for status or enabled in a way to create a program interrupt.  We will
' implement the interrupt feature for our extended timer.
'
' We will choose Timer0 which can be set up as a 16-bit counter.  It increments to a
' maximum of 65,535 counts before starting over at 0.  Timer0 gives us the most
' timing flexibility due to it's broad range of prescaler settings, which can be set
' from 2 to 256 in steps of powers of 2.  That means Timer0 can be set to increment/
' advance a single count every 256 machine cycles if we choose.
'
' So how do we get to 100ms interrupt cycles?  The internal clock of a 48MHz PIC is
' actually 12MHz, or one machine cycle every 83ns, or 12 machine cycles is exactly 1us.
' Therefore, to get a 100ms timing cycle we must set up Timer0 to rollover every
' 1,200,000 machine cycles.  Just using the 16-bit Timer0 count we can only achieve a
' maximum count of 65,636 machine cycles.  So, we must use the prescaler.  We need a
' prescaler value of at least 32, which will extend Timer0 to a possible full count
' 32 x 65,536 = 2,097,152 machine cycles.
'
' But...we want exactly 1,200,000 machine cycles (100ms) for accuracy.  Now that we
' have a prescaler value, and know the timer will increment every 32 machine cycles,
' we can simply divide to find our counter setting: 1200000/32 = 37,500 exactly! So,
' set Timer0 to 37,500?  No!  Timer0 increments up to rollover, or 0.  We need 37,500
' counts less than 0, or  0 - 37,500 = -37,500.  You can use this negative number since
' the compiler translates it in 16-bit terms and will create the correct hex value.
'
' We are not done.  We need to make some adjustments for the jump to the interrupt
' Service Routine (ISR).  There is additional time that elapses from the moment the
' timer interrupt is triggered and when we can reload our timer to start counting
' for the next 100ms.  When the Timer0 rollover interrupt occurs 2 machine cycles
' are necessary for the jump to the ISR, 11 cycles for saving important registers,
' and 4 cycles for reloading Timer0.  These 17 machine cycles of overcount will
' result in a cumulative error of 1.4us every 100ms if not compensated for in some
' way. A way to compensate is by reducing the Timer0 count by 1, or -32 machine cycles,
' but that now leaves an undercount error of 15 machine cycles (32 - 17). Undercount
' is easier to compensate for than overcount.  So we will reduce the timer count by 1
' (-37,499) and make up 15 machine cycles by adding a 1us delay (12 machine cycles) and
' also adding 3 NOP's (NOP = 1 machine cycle).
'
' "Tally" is the Word variable used to accumulate 100ms counts.  This 16-bit variable
' helps create an extended timing range of 0.1 to 6,553.5 seconds (1.8 hours).  A user
' can make Tally a Long Integer variable and extend 1.8 hours by a multiple of 32767,
' or 59,650.5 hours, or approximately 6.8 years.  That should be enough for most users.
'
' The following program uses the LCD to help visualize the Timer changes in 0.1 second
' increments.  It does not need to be implemented in an actual application.
'
' ***************************************************************************************
' ***************************************************************************************

dim Tally_Str as string[5] absolute $20
dim Tally_Dec_Str as string[6] absolute $20
dim Tally, Old_Tally as Word

sub procedure DoEvent
   LATB = Not(LATB)
end sub

sub procedure Interrupt
   delay_us(1)                                  ' Jump to ISR timing compensation
   NOP
   NOP
   NOP
   TMR0H = Hi(-37499)                           ' load TIMER0 for 100ms cycle
   TMR0L = -37499                               '  with 1 count compensation for jump to ISR
   If inc(Tally) = 198 Then                     ' if 19.8 seconds have passed
      DoEvent                                   ' do event
      Tally = 0                                 ' reset Tally
   End If
   INTCON.TMR0IF = 0                            ' clear Timer0 Interrupt Flag
end sub

sub procedure Init
   TRISB = 0                                    ' PortB is used to demonstrate event
   LATB = 15
   ADCON1 = 15                                  ' all IO is digital
   LCD_INIT(PORTD)                              ' LCD on PortD
   LCD_CMD(LCD_CURSOR_OFF)
   Tally = 0                                    ' initialize 0.1 second accumulator
   Old_Tally = 0
end sub

sub procedure Timer0_Init
   T0CON = %00000100                            ' Timer0 prescaler = 32; Timer0 is OFF
   INTCON = %10100000                           ' GIE and TMR0IE enabled; TMR0IF is cleared
   TMR0H = Hi(-37499)                           ' load TIMER0 for 100ms cycle
   TMR0L = -37499                               '  with 1 count compensation for jump to ISR
   T0CON.TMR0ON = 1                             ' start Timer0
end sub

main:

   Init
   Timer0_Init

   While 1=1
     If Tally xor Old_Tally <> 0 Then           ' display the new value on the LCD
        WordToStr(Tally, Tally_Str)
        Tally_Dec_Str[5] = Tally_Dec_Str[4]
        Tally_Dec_Str[4] = 46                   ' add a decimal
        LCD_OUT(1, 6, Tally_Dec_Str)
        LCD_OUT(2, 7, "SECONDS")
     End If
   Wend

end.
 

Kod: Markera allt

   LATB = Not(LATB)
   TMR0H = Hi(-37499)                           ' load TIMER0 for 100ms cycle
   TMR0L = -37499                               '  with 1 count compensation for jump to ISR
   INTCON.TMR0IF = 0                            ' clear Timer0 Interrupt Flag
   TRISB = 0                                    ' PortB is used to demonstrate event
   LATB = 15
   ADCON1 = 15                                  ' all IO is digital
   LCD_INIT(PORTD)                              ' LCD on PortD
   LCD_CMD(LCD_CURSOR_OFF)
   T0CON = %00000100                            ' Timer0 prescaler = 32; Timer0 is OFF
   INTCON = %10100000                           ' GIE and TMR0IE enabled; TMR0IF is cleared
   TMR0H = Hi(-37499)                           ' load TIMER0 for 100ms cycle
   TMR0L = -37499                               '  with 1 count compensation for jump to ISR
   T0CON.TMR0ON = 1                             ' start Timer0