Interrupts
Interrupts can be easily handled by means of reserved word interrupt. mikroC implictly declares function interrupt which cannot be redeclared. Its prototype is:
void interrupt(void);For P18 low priorty interrupts reserved word is interrupt_low:
void interrupt_low(void);You are expected to write your own definition (function body) to handle interrupts in your application.
mikroC saves the following SFR on stack when entering interrupt and pops them back upon return:
PIC12 family: W, STATUS, FSR, PCLATH
PIC16 family: W, STATUS, FSR, PCLATH
PIC18 family: FSR (fast context is used to save WREG, STATUS, BSR)
Use the #pragma disablecontexsaving to instruct the compiler not to automatically perform context-switching. This means that no regiser will be saved/restored by the compiler on entrance/exit from interrupt service routine. This enables the user to manually write code for saving registers upon entrance and to restore them before exit from interrupt.
P18 priority interrupts
Note: For the P18 family both low and high interrupts are supported.
function with name interrupt will be linked as ISR (interrupt service routine) for high level interrupt
function with name interrupt_low will be linked as ISR for low level interrupt_low
If interrupt priority feature is to be used then the user should set the appropriate SFR bits to enable it. For more information refer to datasheet for specific device.
Function Calls from Interrupt
Calling functions from within the interrupt() routine is now possible. The compiler takes care about the registers being used, both in "interrupt" and in "main" thread, and performs "smart" context-switching between the two, saving only the registers that have been used in both threads.Check functions reentrancy.
Interrupt Examples
Here is a simple example of handling the interrupts from TMR0 (if no other interrupts are allowed):
void interrupt() {
counter++;
TMR0 = 96;
INTCON = $20;
}//~
In case of multiple interrupts enabled, you need to test which of the interrupts occurred and then proceed with the appropriate code (interrupt handling):
void interrupt() {
if (INTCON.TMR0IF) {
counter++;
TMR0 = 96;
INTCON.TMR0F = 0;
}
else if (INTCON.RBIF) {
counter++;
TMR0 = 96;
INTCON.RBIF = 0;
}
}///*
* SIMPLE SERIAL FREQUENCY METER
*
* this program writes one time per second to the RS232 communication line,
* the frequency of the input signal on the RB0 pin
*
* PIC16F84A
* 16 Mhz crystal, HS clock
*
* PORTB.0, in : counter input
* PORTB.1, out : RS232 tx
* PORTB.2, in : RS232 rx
*
* Author : Bruno Gavand, november 2005
* see more details on [url]www.micro-examples.com[/url]
*
*/
/*
* RAM variables
*/
unsigned long cntr ; // number of RB0 transition
unsigned int ovrflw ; // number of timer0 overflows
unsigned char str[10] ; // display result string
/*
* constant strings
*/
const unsigned char welcome[] = "\r\rRS232 Frequency Meter Ready\rGo to [url]www.micro-examples.com[/url] for details\r" ;
const unsigned char unit[] = " Hz\r" ;
/*
* write the s ram string to RS232
*/
void Comm_Write(unsigned char *s)
{
while(*s)
{
Soft_Uart_Write(*s) ;
s++ ;
}
}
/*
* write the s constant string to RS232
*/
void Comm_WriteConst(const unsigned char *s)
{
while(*s)
{
Soft_Uart_Write(*s) ;
s++ ;
}
}
/*
* convert the cnrt long value to string
*/
void Long2str(void)
{
unsigned char i, j ;
if(cntr == 0)
{
str[0] = '0' ;
str[1] = 0 ;
}
else
{
str[0] = 0 ;
i = 0 ;
while(cntr > 0)
{
for(j = i + 1 ; j > 0 ; j--)
{
str[j] = str[j - 1] ;
}
str[0] = cntr % 10 ;
str[0] += '0' ;
i++ ;
cntr /= 10 ;
}
}
}
/*
* interrupt routine called 4000000/256 times by seconds :
* the timer TMR0 is increased each 4 clock cycles (quartz frequency is 16 Mhz),
* and overflows when reseting from 255 to 0,
* calling the interrupt procedure with bit T0IF set
*
* also called on each RBO transition, with bit INTF set
*/
void interrupt(void)
{
if(INTCON.INTF)
{
/*
* RB0 interrupt
*/
cntr++ ; // inc. transition counter
INTCON.INTF = 0 ; // clear interrupt flag to enable next call
}
else if(INTCON.T0IF)
{
/*
* TIMER 0 overflow
*/
ovrflw++ ; // inc. overflow counter
INTCON.T0IF = 0 ; // clear interrupt flag to enable next call on overflow
}
}
/*
* entry point
*/
main()
{
Soft_Uart_Init(PORTB, 1, 2, 38400, 0) ; // RS232 on PORTB, bits 1 & 2, 38400 bauds
Comm_WriteConst(welcome) ; // write welcome message
TRISB.F0 = 1 ; // RB0 interrupt pin as input
OPTION_REG = 0b11011000 ; // no prescaler
/*
* main loop
*/
for(;;)
{
cntr = 0 ; // clear counters
ovrflw = 0 ;
INTCON = 0b10110000 ; // T0IF, INTF and GIE enabled
while(ovrflw < 15626) ; // wait 1 second : 15626 = 16 000 000 / 4 / 256, rounded up
INTCON.GIE = 0 ; // stop all interrupts
Long2Str() ; // convert counter to string
Comm_Write(str) ; // write string
Comm_WriteConst(unit) ; // write unit
}
}
//
Saat yapman bile zor.. Ayrıca interruptla ilgili bir sıkıntın varsa hala ona da yardımcı olmaya çalışabilirim.
