133 lines
6.2 KiB
C
133 lines
6.2 KiB
C
/*
|
|
This scheduler is designed to maintain 2 schedules for use by the fuel and ignition systems.
|
|
It functions by waiting for the overflow vectors from each of the timers in use to overflow, which triggers an interrupt
|
|
|
|
//Technical
|
|
Currently I am prescaling the 16-bit timers to 256. This means that the counter increments every 16us and will overflow every 1048576uS
|
|
Max Period = (Prescale)*(1/Frequency)*(2^17)
|
|
(See http://playground.arduino.cc/code/timer1)
|
|
This means that the precision of the scheduler is 16uS (+/- 8uS of target)
|
|
|
|
/Features
|
|
This differs from most other schedulers in that its calls are non-recurring (IE You schedule an event at a certain time and once it has occurred, it will not reoccur unless you explicitely ask for it)
|
|
Each timer can have only 1 callback associated with it at any given time. If you call the setCallback function a 2nd time, the original schedule will be overwritten and not occur
|
|
|
|
Timer identification
|
|
The Arduino timer3 is used for schedule 1
|
|
The Arduino timer4 is used for schedule 2
|
|
Both of these are 16-bit timers (ie count to 65536)
|
|
See page 136 of the processors datasheet: http://www.atmel.com/Images/doc2549.pdf
|
|
|
|
256 prescale gives tick every 16uS
|
|
256 prescale gives overflow every 1048576uS (This means maximum wait time is 1.0485 seconds)
|
|
|
|
*/
|
|
|
|
#include <avr/interrupt.h>
|
|
#include <avr/io.h>
|
|
|
|
//#define clockspeed 16000000
|
|
|
|
int schedule1Active; //Value=0 means do nothing, value=1 means call the startCallback, value=2 means call the endCallback
|
|
int schedule2Active;
|
|
unsigned long schedule1Duration; //How long (uS) after calling the start callback to we call the end callback
|
|
unsigned long schedule2Duration;
|
|
void (*schedule1StartCallback)(); //Start Callback function for schedule1
|
|
void (*schedule2StartCallback)();
|
|
void (*schedule1EndCallback)(); //End Callback function for schedule1
|
|
void (*schedule2EndCallback)();
|
|
|
|
void initialiseScheduler()
|
|
{
|
|
|
|
// Much help in this from http://arduinomega.blogspot.com.au/2011/05/timer2-and-overflow-interrupt-lets-get.html
|
|
//Schedule 1, which is uses timer 3
|
|
TCCR3B = 0x00; //Disbale Timer2 while we set it up
|
|
TCNT3 = 0; //Reset Timer Count
|
|
TIFR3 = 0x00; //Timer2 INT Flag Reg: Clear Timer Overflow Flag
|
|
TIMSK3 = 0x01; //Timer2 INT Reg: Timer2 Overflow Interrupt Enable
|
|
TCCR3A = 0x00; //Timer2 Control Reg A: Wave Gen Mode normal
|
|
TCCR3B = (1 << CS12); //Timer2 Control Reg B: Timer Prescaler set to 256. Refer to http://www.instructables.com/files/orig/F3T/TIKL/H3WSA4V7/F3TTIKLH3WSA4V7.jpg
|
|
|
|
//Schedule 2, which is uses timer 4
|
|
TCCR4B = 0x00; //Disbale Timer2 while we set it up
|
|
TCNT4 = 0; //Reset Timer Count
|
|
TIFR4 = 0x00; //Timer2 INT Flag Reg: Clear Timer Overflow Flag
|
|
TIMSK4 = 0x01; //Timer2 INT Reg: Timer2 Overflow Interrupt Enable
|
|
TCCR4A = 0x00; //Timer2 Control Reg A: Wave Gen Mode normal
|
|
TCCR4B = (1 << CS12); //Timer2 Control Reg B: Timer Prescaler set to 256. Refer to http://www.instructables.com/files/orig/F3T/TIKL/H3WSA4V7/F3TTIKLH3WSA4V7.jpg
|
|
|
|
schedule1Active = 0;
|
|
schedule2Active = 0;
|
|
}
|
|
|
|
/*
|
|
This turns schedule 1 on, gives it callback functions and resets the relevant timer based on the time in the future that this should be triggered
|
|
Args:
|
|
startCallback: The function to be called once the timeout1 is reached
|
|
timeout1: The number of uS in the future that the callback should be triggered
|
|
duration: The number of uS before endCallback is called
|
|
endCallback
|
|
*/
|
|
void setSchedule1(void (*startCallback)(), unsigned long timeout, unsigned long duration, void(*endCallback)())
|
|
{
|
|
//We need to calculate the value to reset the timer to (preload) in order to achieve the desired overflow time
|
|
//As the timer is ticking every 16uS (Time per Tick = (Prescale)*(1/Frequency))
|
|
//TODO: Need to add check for timeout > 1048576 ????
|
|
TCNT3 = 65536 - (timeout / 16); //Each tick occurs every 16uS with a 256 prescaler so divide the timeout by 16 to get ther required number of ticks. Subtract this from the total number of tick (65536 for 16-bit timer)
|
|
schedule1Duration = duration;
|
|
schedule1StartCallback = startCallback; //Name the start callback function
|
|
schedule1EndCallback = endCallback; //Name the start callback function
|
|
schedule1Active = 1; //Turn this schedule on and set it
|
|
}
|
|
|
|
//As above, but for schedule2
|
|
void setSchedule2(void (*startCallback)(), unsigned long timeout, unsigned long duration, void(*endCallback)())
|
|
{
|
|
//TODO: Need to add check for timeout > 1048576 ????
|
|
TCNT4 = 65536 - (timeout / 16); //Each tick occurs every 16uS with a 256 prescaler so divide the timeout by 16 to get ther required number of ticks. Subtract this from the total number of tick (65536 for 16-bit timer)
|
|
schedule2Duration = duration;
|
|
schedule2StartCallback = startCallback; //Name the callback function
|
|
schedule2EndCallback = endCallback; //Name the callback function
|
|
schedule2Active = 1; //Turn this schedule on
|
|
}
|
|
|
|
//Timer3 (schedule 1) Overflow Interrupt Vector
|
|
//This needs to call the callback function if one has been provided and rest the timer
|
|
ISR(TIMER3_OVF_vect)
|
|
{
|
|
if (schedule1Active == 1) //Check to see if this schedule is turn on
|
|
{
|
|
schedule1StartCallback(); //Replace with user provided callback
|
|
schedule1Active = 2; //Turn off the callback
|
|
TCNT3 = 65536 - (schedule1Duration / 16);
|
|
}
|
|
else if (schedule1Active == 2)
|
|
{
|
|
schedule1EndCallback();
|
|
schedule1Active = 0; //Turn off the callback
|
|
TCNT3 = 0; //Reset Timer to 0 out of 255
|
|
}
|
|
|
|
TIFR3 = 0x00; //Timer2 INT Flag Reg: Clear Timer Overflow Flag
|
|
}
|
|
|
|
//AS above for schedule2
|
|
ISR(TIMER4_OVF_vect)
|
|
{
|
|
if (schedule2Active == 1) //A value of 1 means call the start callback
|
|
{
|
|
schedule2StartCallback();
|
|
schedule2Active = 2; //Set to call the end callback on the next run
|
|
TCNT4 = 65536 - (schedule2Duration / 16);
|
|
}
|
|
else if (schedule2Active == 2)
|
|
{
|
|
schedule2EndCallback();
|
|
schedule2Active = 0; //Turn off the callback
|
|
TCNT4 = 0; //Reset Timer to 0 out of 255
|
|
}
|
|
|
|
TIFR4 = 0x00; //Timer2 INT Flag Reg: Clear Timer Overflow Flag
|
|
}
|