[Icc-avr] Help with callback functions on ICCAVR 7
Sylvain Bissonnette
sbissonnette at microsyl.com
Sat Sep 29 08:52:12 PDT 2007
Hi,
It's not 8 lines, but you will find what you need.
Sylvain
//*****************************************************************************
// TaskManager
// Version 2.0 Fev 2005
//
// 2.0 -> -Re work all the interrupt code
// 1.0 -> -Everything is new
//
// Sylvain Bissonnette
//*****************************************************************************
// Editor : UltraEdit32
//*****************************************************************************
// T I M E R U S A G E
//
// Timer 2 is use by Task Manager
//
//*****************************************************************************
//
//*****************************************************************************
// I N C L U D E
//*****************************************************************************
#include <iom128v.h>
#include <shortnametype.h>
#include <macros.h>
#include <stdlib.h>
#include <STRING.H>
#include "TaskManager.h"
//#define MINIMUM_CODE // if def save 71 words of code but no more
// checking of Register and UnRegister
//*****************************************************************************
// G L O B A L V A R I A B L E
//*****************************************************************************
typedef struct Task
{
void (*FunctionPTR)(void);
uint Interval;
uint Ticker;
ushort Persiste;
}Task;
Task TaskList[MAX_TASK];
Task TaskAdd;
Task TaskDel;
int TaskMax = 0;
/******************************************************************************
Name: void TaskInit(void)
Description: Init task system
Input: none
Output: none
Misc: Use Timer 0
******************************************************************************/
void TaskInit(void)
{
//Timer2
TCCR2 = 0x02; // Timer0 / 8
TIMSK |= (1<<TOIE2); // int enable on Timer 0 overflow
}
/******************************************************************************
Name: int TaskRegister( void(*FunctionPTR)(void),
int Interval,
ushort Persiste)
Description: Register a function to be call
Input: void Function pointer
int Interval
uchar Persiste
Output: 0 -> Task not registrated (error)
1 -> Task is now registrated
Misc:
******************************************************************************/
int TaskRegister(void(*FunctionPTR)(void),
uint Interval,
ushort Persiste)
{
#ifndef MINIMUM_CODE
uint i = 0;
if (FunctionPTR == NULL) return 0;
if (TaskMax >= MAX_TASK) return 0;
while (TaskAdd.FunctionPTR != NULL)
{
WDR();
if (i++ > 65530) return 0;
}
#endif
TaskAdd.FunctionPTR = FunctionPTR;
TaskAdd.Interval = Interval;
TaskAdd.Persiste = Persiste;
return 1;
}
/******************************************************************************
Name: int TaskUnRegister(void(*FunctionPTR)(void))
Description: UnRegister a function
Input: Function pointer
Output: 0 -> Task not find
1 -> Task is unregistrated
Misc:
******************************************************************************/
int TaskUnRegister(void(*FunctionPTR)(void))
{
#ifndef MINIMUM_CODE
uint i = 0;
if (FunctionPTR == NULL) return 0;
while(TaskDel.FunctionPTR != NULL)
{
WDR();
if (i++ > 65530) return 0;
}
#endif
TaskDel.FunctionPTR = FunctionPTR;
return 1;
}
/**********************************************************
Name: int TaskCheckRegister(void(*FunctionPTR)(void))
Description: Check if a function is register
Input: Function pointer
Output: 0 -> Not register
1 -> Register
Misc:
**********************************************************/
int TaskCheckRegister(void(*FunctionPTR)(void))
{
ushort i;
for (i=0; i < TaskMax; i++)
{
if (TaskList[i].FunctionPTR == FunctionPTR) return 1;
}
return 0;
}
/**********************************************************
Name: void TaskBlock(int Time)
Description: Block for x time
Input: none
Output: none
Misc:
**********************************************************/
void TaskBlock(uint Time)
{
TaskRegister(TaskDummy,Time,FALSE);
while (TaskCheckRegister(TaskDummy)) WDR();
}
void TaskDummy(void)
{
}
/**********************************************************
Name: void TaskStop(void)
Description: Stop Task Execution
Input: none
Output: none
Misc:
**********************************************************/
void TaskStop(void)
{
TIMSK &= ~(1<<TOIE2); // int disable on Timer 2 overflow
}
/**********************************************************
Name: void TaskStart(void)
Description: Start Task Execution
Input: none
Output: none
Misc:
**********************************************************/
void TaskStart(void)
{
TIMSK |= (1<<TOIE2); // int enable on Timer 0 overflow
}
/**********************************************************
Name: void TaskExecute(void)
Description: TaskExecute
Input: none
Output: none
Misc: TaskExecute is execute each 100us
**********************************************************/
#pragma interrupt_handler TaskExecute:11
void TaskExecute(void)
{
static ushort i,j;
static void (*FunctionPTR)(void);
TCNT2 = 255 - (XTAL / 8 / 10000);
WDR();
if (TaskDel.FunctionPTR != NULL) _TaskUnRegister();
if (TaskAdd.FunctionPTR != NULL) _TaskRegister();
for (i=0;i<TaskMax;i++)
{
if (TaskList[i].Ticker++ >= TaskList[i].Interval)
{
FunctionPTR = TaskList[i].FunctionPTR;
if (!TaskList[i].Persiste)
{
for (j=i;j<TaskMax;j++) memcpy(&TaskList[j],&TaskList[j+1],sizeof(Task));
TaskMax--;
}
else
{
TaskList[i].Ticker = 0;
}
SEI();
FunctionPTR();
CLI();
}
}
}
/******************************************************************************
Name: void _TaskUnRegister(void)
Description: UnRegister a function
Input: TaskDel struct
Output: none
Misc:
******************************************************************************/
void _TaskUnRegister(void)
{
ushort i,j;
for (i=0;i<TaskMax;i++)
{
if (TaskList[i].FunctionPTR == TaskDel.FunctionPTR)
{
for (j=i;j<TaskMax;j++) memcpy(&TaskList[j],&TaskList[j+1],sizeof(Task));
TaskMax--;
TaskDel.FunctionPTR = NULL;
return;
}
}
TaskDel.FunctionPTR = NULL;
}
/******************************************************************************
Name: int _TaskRegister(void)
Description: Register a function
Input: TaskAdd struct
Output: none
Misc:
******************************************************************************/
void _TaskRegister(void)
{
TaskList[TaskMax].FunctionPTR = TaskAdd.FunctionPTR;
TaskList[TaskMax].Interval = TaskAdd.Interval;
TaskList[TaskMax].Ticker = 0;
TaskList[TaskMax].Persiste = TaskAdd.Persiste;
TaskAdd.FunctionPTR = NULL;
TaskMax++;
}
//*****************************************************************************
// TaskManager.h
// Version 1.0 Dec 2004
//
// 1.0 -> -Everything is new
//
// Sylvain Bissonnette
//*****************************************************************************
//
//*****************************************************************************
// D E F I N E
//*****************************************************************************
#define TASK_MAN_VER 10
#define TRUE 1
#define FALSE 0
#define XTAL 16000000
#define MAX_TASK 10
#define T100US 1
#define T200US 2
#define T300US 3
#define T400US 4
#define T500US 5
#define T600US 6
#define T700US 7
#define T800US 8
#define T900US 9
#define T1MS 10
#define T2MS 20
#define T3MS 30
#define T4MS 40
#define T5MS 50
#define T6MS 60
#define T7MS 70
#define T8MS 80
#define T9MS 90
#define T10MS 100
#define T20MS 200
#define T30MS 300
#define T40MS 400
#define T50MS 500
#define T60MS 600
#define T70MS 700
#define T80MS 800
#define T90MS 900
#define T100MS 1000
#define T110MS 1100
#define T120MS 1200
#define T130MS 1300
#define T140MS 1400
#define T150MS 1500
#define T160MS 1600
#define T170MS 1700
#define T180MS 1800
#define T190MS 1900
#define T200MS 2000
#define T210MS 2100
#define T220MS 2200
#define T230MS 2300
#define T240MS 2400
#define T250MS 2500
#define T260MS 2600
#define T270MS 2700
#define T280MS 2800
#define T290MS 2900
#define T300MS 3000
#define T310MS 3100
#define T320MS 3200
#define T330MS 3300
#define T340MS 3400
#define T350MS 3500
#define T360MS 3600
#define T370MS 3700
#define T380MS 3800
#define T390MS 3900
#define T400MS 4000
#define T410MS 4100
#define T420MS 4200
#define T430MS 4300
#define T440MS 4400
#define T450MS 4500
#define T460MS 4600
#define T470MS 4700
#define T480MS 4800
#define T490MS 4900
#define T500MS 5000
#define T510MS 5100
#define T520MS 5200
#define T530MS 5300
#define T540MS 5400
#define T550MS 5500
#define T560MS 5600
#define T570MS 5700
#define T580MS 5800
#define T590MS 5900
#define T600MS 6000
#define T610MS 6100
#define T620MS 6200
#define T630MS 6300
#define T640MS 6400
#define T650MS 6500
#define T660MS 6600
#define T670MS 6700
#define T680MS 6800
#define T690MS 6900
#define T700MS 7000
#define T710MS 7100
#define T720MS 7200
#define T730MS 7300
#define T740MS 7400
#define T750MS 7500
#define T760MS 7600
#define T770MS 7700
#define T780MS 7800
#define T790MS 7900
#define T800MS 8000
#define T810MS 8100
#define T820MS 8200
#define T830MS 8300
#define T840MS 8400
#define T850MS 8500
#define T860MS 8600
#define T870MS 8700
#define T880MS 8800
#define T890MS 8900
#define T900MS 9000
#define T910MS 9100
#define T920MS 9200
#define T930MS 9300
#define T940MS 9400
#define T950MS 9500
#define T960MS 9600
#define T970MS 9700
#define T980MS 9800
#define T990MS 9900
#define T1S 10000
#define T2S 20000
#define T3S 30000
#define T4S 40000
#define T5S 50000
#define T6S 60000
#define T7S 70000
#define T8S 80000
#define T9S 90000
#define T10S 100000
#define T11S 110000
#define T12S 120000
#define T13S 130000
#define T14S 140000
#define T15S 150000
#define T16S 160000
#define T17S 170000
#define T18S 180000
#define T19S 190000
#define T20S 200000
#define T21S 210000
#define T22S 220000
#define T23S 230000
#define T24S 240000
#define T25S 250000
#define T26S 260000
#define T27S 270000
#define T28S 280000
#define T29S 290000
#define T30S 300000
#define T31S 310000
#define T32S 320000
//*****************************************************************************
// P R O T O T Y P E
//*****************************************************************************
void TaskInit(void);
int TaskRegister(void(*CallBack)(void),
unsigned int Interval, // was long
unsigned char Persiste);
int TaskUnRegister(void(*CallBack)(void));
int TaskCheckRegister(void(*CallBack)(void));
void TaskBlock(unsigned int Time); // was long
void TaskDummy(void);
void TaskStop(void);
void TaskStart(void);
void TaskExecute(void);
void _TaskUnRegister(void);
void _TaskRegister(void);
-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://dragonsgate.net/pipermail/icc-avr/attachments/20070929/3f9b5b21/attachment-0001.html
More information about the Icc-avr
mailing list