Colony

/*

time.c

anything that requires a delay

mostly delay_ms

author: Robotics Club, Colony Project

Change Log:

        2.5.07 - Kevin

                Aaron fixed the orb/servo code and made them use timer3 but compare registers B and C. He hard set the prescaler

                to 8 so the RTC broke. Changed it so that we use a 8 prescaler which sets the compare match at 1/16th of a second.

                You now count how many 16ths of a second you want until you trigger your actual interrupt. Works. Changed defines

                for time so you can still call rtc_init with a scale but now it is defined in terms of actual time like second, quarter_second

                etc. Read that section in the time.h file for more information. Tested and works, though the clock drifts more than

                it used to

        1.30.07 - Kevin

                Modified the clock to run on timer3 on the Dragonfly. Works with decent accuracy. Using a prescaler of 256

        the timer counts up to a precomputer value which will trigger an interrupt and reset the timer. Multiples of

        256 change it by that multiple. Refer to the time.h file for all possible prescalers.

                The interrupt will call a specified function _rtc_func every pulse.

                All of it has been tested and it works.

        10.29.07 - Andrew

                Modify to accept multiple functions with different time intervals

*/

#include <avr/interrupt.h>

#include <util/delay.h>

#include <time.h>

#include <serial.h>

static volatile int _rtc_val[MAX_FUNCTIONS];

static volatile int _rtc_pulse[MAX_FUNCTIONS];

static volatile int _rtc_scale[MAX_FUNCTIONS];

static int function_count = 0; //Number of functions

static  void (*_rtc_f[MAX_FUNCTIONS])(void);

/**

 * @defgroup time Time

 * @brief Time functions

 *

 * Functions dealing with time.

 *

 * @{

 **/

/**

 * Delays for the specified number of milliseconds.

 * The accuracy of this function is unknown.

 *

 * @param ms the number of milliseconds to delay for

 **/

void delay_ms(int ms)

{

        for(; ms > 15; ms-=15)

                _delay_ms(15);

        _delay_ms(ms);

}

/*         Prescales defined in time.h. SECOND will give you 1 second.

        More scales are defined in the time.h file.

        rtc_func is the address to a function that you want called every clock tick. */

/**

 * Initializes the real time clock. Prescales are defined in time.h.

 * For example, SECOND will give 1 second. The specified function is

 * called every clock tick. For the real time clock to activate,

 * interrupts must be enabled. (through sei() )

 *

 * @param prescale_opt the period with which the timer is triggered

 * @param rtc_func the function called when the timer is triggered

 *

 * @see rtc_get, rtc_reset

 **/

 int rtc_multi_init(int* prescale_opt,  void (*rtc_func[])(void), int argc) {

        //Check that the number of functions doesn't exceed alloted space

        if(argc > MAX_FUNCTIONS)

                return -1;

        function_count = argc;

        //Clear timer register for Timer 3

        TCNT3 = 0;

        /*         This sets the Waveform Generation Module to CTC (Clear Timer on Compare) Mode (100)

                See page135 in Atmega128 Docs for more modes and explanations */

        TCCR3B |= _BV(WGM32);

        /*         This sets the prescaler for the system clock (8MHz) ie: divides the clock by some number.

                Currently set to a prescaler of 8 because that is what the orb and servos use (they are on this timer as well)

                See page137 in Atemga128 Docs for all the available prescalers */

        TCCR3B |= _BV(CS31);

        /*         Sets the two regsiters that we compare against. So the timer counts up to this number and

                then resets back to 0 and calls the compare match interrupt.

                8x10^6 / 8 = 1/16 Second. All values are based off of this number. Do not change it unless you

                are l337*/

        OCR3A = 0xF424;

        /*         Enable Output Compare A Interrupt. When OCR3A is met by the timer TCNT3 this interrupt will be

                triggerd. (See page140 in Atmega128 Docs for more information */

        ETIMSK |= _BV(OCIE3A);

        /* Set number of functions*/

        function_count = argc;

        /*        Store how many 1/16ths of a second you want to let by before triggering an interrupt */

        for (int i = 0; i <argc; i++) {

                _rtc_pulse[i] = 0;

                _rtc_val[i] = 0;

                _rtc_f[i] = rtc_func[i];

                /*        Store how many 1/16ths of a second you want to let by before triggering an interrupt */

                _rtc_scale[i] = prescale_opt[i];

        }

        return argc-1;

}

int rtc_add_function(void (*rtc_func) (void), int prescale_opt)

{

        if(function_count>=MAX_FUNCTIONS)

                return -1;

        _rtc_f[function_count] = rtc_func;

        _rtc_pulse[function_count] = 0;

        _rtc_scale[function_count]  = prescale_opt;

        //return position in array that function was added to, increment count

        //this position may change if functions are removed

        return function_count++;

}

//remove function pointer

int rtc_remove_function(void (*rtc_func)(void))

{

        for(int i = 0; i < function_count; i++)

                if(_rtc_f[i] == rtc_func) {

                        //If not last function replace with last and reduce number of functions

                        if(i < function_count-1) {

                                _rtc_f[i] = _rtc_f[function_count-1];

                                _rtc_pulse[i] = _rtc_pulse[function_count-1];

                                _rtc_scale[i] = _rtc_scale[function_count-1];

                        }

                        return --function_count;

                }

        return -1;

}

int rtc_get_function_count()

{

        return function_count;

}

int rtc_init(int prescale_opt, void (*rtc_func)(void)){

        int temp[] = {prescale_opt};

        void (*temp2[MAX_FUNCTIONS])(void) = {rtc_func};

        return rtc_multi_init(temp, temp2, 1);

}

/**

 * Returns the time elapsed in seconds since the last call to

 * rtc_init or rtc_reset.

 *

 * @return the number of seconds since the last call to rtc_init or rtc_reset

 *

 * @see rtc_init, rtc_reset

 **/

int rtc_get(void){

        return _rtc_val[0];

}

int rtc_get_pos(int pos){

        return _rtc_val[pos];

}

/**

 * Resets the real time clock counter to 0.

 *

 * @see rtc_init, rtc_get

 **/

void rtc_reset(void){

        _rtc_val[0] = 0;

}

void rtc_reset_all(void)

{

        for(int i =0; i < function_count; i++)

                _rtc_val[i] = 0;

}

/** @} **/ //end defgroup

/*        Called every pulse. Function in _rtc_f is called every _rtc_scale and also the counter is updated.

        Bascially, since the pulse is hard set at 1/16s  you want to count how many 16ths of a second have passed

        and when it reaches the amount of time you want, execute the code. */

SIGNAL(TIMER3_COMPA_vect) {

        for(int functionNumber = 0; functionNumber < function_count; functionNumber++)

        {

                if (_rtc_pulse[functionNumber] ==  _rtc_scale[functionNumber]) {

                        //Increment the real time clock counter

                        _rtc_val[functionNumber]++;

                        //Calls the function tied to the real time clock if defined

                        _rtc_f[functionNumber]();

                        //Resets the pulse until the next scale is matched

                        _rtc_pulse[functionNumber] = 0;

                }

                _rtc_pulse[functionNumber]++;

        }

        //Updates the amount of pulses seen since the last scale match

}