extint.c

Go to the documentation of this file.

/*! \file extint.c \brief External-Interrupt function library. */
//*****************************************************************************
//
// File Name    : 'extint.c'
// Title        : External-Interrupt function library
// Author       : Pascal Stang - Copyright (C) 2002-2004
// Created      : 5/10/2002
// Revised      : 11/16/2004
// Version      : 1.0
// Target MCU   : Atmel AVR Series
// Editor Tabs  : 4
//
// Notes:   This library provides convenient standardized configuration and
//          access to external interrupts.  The library is designed to make
//          it possible to write code that uses external interrupts without
//          digging into the processor datasheets to find register names and
//          bit-defines.  The library also strives to allow code which uses
//          external interrupts to more easily cross-compile between different
//          microcontrollers.
//
//          NOTE: Using this library has certain advantages, but also adds
//          overhead and latency to interrupt servicing.  If the smallest
//          code size or fastest possible latency is needed, do NOT use this
//          library; link your interrupts directly.
//
//*****************************************************************************

#include <avr/io.h>
#include <avr/interrupt.h>

#include "global.h"
#include "extint.h"

// Global variables
typedef void (*voidFuncPtr)(void);
volatile static voidFuncPtr ExtIntFunc[EXTINT_NUM_INTERRUPTS];

// functions

//! initializes extint library
void extintInit(void)
{
    u08 intNum;
    // detach all user functions from interrupts
    for(intNum=0; intNum<EXTINT_NUM_INTERRUPTS; intNum++)
        extintDetach(intNum);

}

//! Configure external interrupt trigger
// NOTE: this function is not complete!!!
void extintConfigure(u08 interruptNum, u08 configuration)
{
    if(interruptNum == EXTINT0)
    {
        MCUCR &= ~((1<<ISC01) | (1<<ISC00));
        MCUCR |= configuration;
    }
    #ifdef SIG_INTERRUPT1
    else if(interruptNum == EXTINT1)
    {
        MCUCR &= ~((1<<ISC11) | (1<<ISC10));
        MCUCR |= configuration<<2;
    }
    #endif
    #ifdef SIG_INTERRUPT2
    else if(interruptNum == EXTINT2)
    {
        if(configuration == EXTINT_EDGE_RISING)
            sbi(MCUCSR, ISC2);
        else
            cbi(MCUCSR, ISC2);
    }
    #endif
    // need to handle a lot more cases
    // and differences between processors.
    // looking for clean way to do it...
}

//! Attach a user function to an external interrupt
void extintAttach(u08 interruptNum, void (*userHandler)(void) )
{
    // make sure the interrupt number is within bounds
    if(interruptNum < EXTINT_NUM_INTERRUPTS)
    {
        // set the interrupt function to run
        // the supplied user's function
        ExtIntFunc[interruptNum] = userHandler;
    }
}

//! Detach a user function from an external interrupt
void extintDetach(u08 interruptNum)
{
    // make sure the interrupt number is within bounds
    if(interruptNum < EXTINT_NUM_INTERRUPTS)
    {
        // set the interrupt function to run
        // the supplied user's function
        ExtIntFunc[interruptNum] = 0;
    }
}

//! Interrupt handler for INT0
EXTINT_INTERRUPT_HANDLER(SIG_INTERRUPT0)
{
    // if a user function is defined, execute it
    if(ExtIntFunc[EXTINT0])
        ExtIntFunc[EXTINT0]();
}

#ifdef SIG_INTERRUPT1
//! Interrupt handler for INT1
EXTINT_INTERRUPT_HANDLER(SIG_INTERRUPT1)
{
    // if a user function is defined, execute it
    if(ExtIntFunc[EXTINT1])
        ExtIntFunc[EXTINT1]();
}
#endif

#ifdef SIG_INTERRUPT2
//! Interrupt handler for INT2
EXTINT_INTERRUPT_HANDLER(SIG_INTERRUPT2)
{
    // if a user function is defined, execute it
    if(ExtIntFunc[EXTINT2])
        ExtIntFunc[EXTINT2]();
}
#endif

#ifdef SIG_INTERRUPT3
//! Interrupt handler for INT3
EXTINT_INTERRUPT_HANDLER(SIG_INTERRUPT3)
{
    // if a user function is defined, execute it
    if(ExtIntFunc[EXTINT3])
        ExtIntFunc[EXTINT3]();
}
#endif

#ifdef SIG_INTERRUPT4
//! Interrupt handler for INT4
EXTINT_INTERRUPT_HANDLER(SIG_INTERRUPT4)
{
    // if a user function is defined, execute it
    if(ExtIntFunc[EXTINT4])
        ExtIntFunc[EXTINT4]();
}
#endif

#ifdef SIG_INTERRUPT5
//! Interrupt handler for INT5
EXTINT_INTERRUPT_HANDLER(SIG_INTERRUPT5)
{
    // if a user function is defined, execute it
    if(ExtIntFunc[EXTINT5])
        ExtIntFunc[EXTINT5]();
}
#endif

#ifdef SIG_INTERRUPT6
//! Interrupt handler for INT6
EXTINT_INTERRUPT_HANDLER(SIG_INTERRUPT6)
{
    // if a user function is defined, execute it
    if(ExtIntFunc[EXTINT6])
        ExtIntFunc[EXTINT6]();
}
#endif

#ifdef SIG_INTERRUPT7
//! Interrupt handler for INT7
EXTINT_INTERRUPT_HANDLER(SIG_INTERRUPT7)
{
    // if a user function is defined, execute it
    if(ExtIntFunc[EXTINT7])
        ExtIntFunc[EXTINT7]();
}
#endif

---