www.pudn.com > ucosforcodewarrior-hc12.rar > _2006_01_02_PE.c, change:2006-02-16,size:12261b


/* 
********************************************************************************************************* 
*                                               uC/OS-II 
*                                         The Real-Time Kernel 
* 
*                         (c) Copyright 1998, Jean J. Labrosse, Plantation, FL 
*                                          All Rights Reserved 
* 
* 
*                                          MC68HC912DG128A Sample code 
* 
* File : TEST.C 
* By   : Jean J. Labrosse 
* Ported to MC68HC912DG128A : Robert F. Heslar 
********************************************************************************************************* 
*/ 
 
#include "INCLUDES.H" 
 
/* 
********************************************************************************************************* 
*                                                VARIABLES 
********************************************************************************************************* 
*/ 
 
OS_STK  AppStartTaskStk[256] = {0xA5}; 
OS_STK  AppTask1Stk[256]; 
OS_STK  AppTask2Stk[256]; 
 
INT16U  AppTask1Ctr = 0; 
INT16U  AppTask2Ctr = 0; 
 
/* 
********************************************************************************************************* 
*                                            FUNCTION PROTOTYPES 
********************************************************************************************************* 
*/ 
 
static void  AppStartTask(void *pdata); 
static void  AppTask1(void *pdata); 
static void  AppTask2(void *pdata); 
static void  AppTickInit(void); 
 
/* 
********************************************************************************************************* 
*                                                main() 
* 
* Description : This is the standard entry point for C code.  It is assumed that your code will call 
*               main() once you have performed all necessary 68HC12 and C initialization. 
* Arguments   : none 
********************************************************************************************************* 
*/ 
 
void main (void) 
{ 
    /*---- Any initialization code prior to calling OSInit() goes HERE --------------------------------*/ 
 
    OSInit();                               /* Initialize "uC/OS-II, The Real-Time Kernel"             */ 
		DDRB=0xFF; 
    /*---- Any initialization code before starting multitasking ---------------------------------------*/ 
 
    OSTaskCreate(AppStartTask, (void *)0, (void *)&AppStartTaskStk[255], 0); 
 
    /*---- Create any other task you want before we start multitasking --------------------------------*/ 
 
    OSStart();                              /* Start multitasking (i.e. give control to uC/OS-II)      */ 
} 
/*$PAGE*/ 
/* 
********************************************************************************************************* 
*                                          STARTUP TASK 
* 
* Description : This is an example of a startup task.  As mentioned in the book's text, you MUST 
*               initialize the ticker only once multitasking has started. 
* Arguments   : pdata   is the argument passed to 'AppStartTask()' by 'OSTaskCreate()'. 
* Notes       : 1) The first line of code is used to prevent a compiler warning because 'pdata' is not 
*                  used.  The compiler should not generate any code for this statement. 
*               2) Interrupts are enabled once the task start because the I-bit of the CCR register was 
*                  set to 0 by 'OSTaskCreate()'. 
********************************************************************************************************* 
*/ 
 
static void  AppStartTask (void *pdata) 
{ 
    pdata = pdata; 
    AppTickInit();                          /* Initialize the ticker                                   */ 
    /*---- Task initialization code goes HERE! --------------------------------------------------------*/ 
    OSTaskCreate(AppTask1, (void *)0, (void *)&AppTask1Stk[255], 10); 
    OSTaskCreate(AppTask2, (void *)0, (void *)&AppTask2Stk[255], 20); 
 
    while (TRUE) {                          /* Task body, always written as an infinite loop.          */ 
        /*---- Task code goes HERE! -------------------------------------------------------------------*/ 
        PORTB=0xff; 
        OSTimeDly(700);                       /* Delay task execution for one clock tick                 */ 
    } 
} 
/*$PAGE*/ 
/* 
********************************************************************************************************* 
*                                             TASK #1 
* 
* Description : This is an example of a task.   
* Arguments   : pdata   is the argument passed to 'AppTask1()' by 'OSTaskCreate()'. 
* Notes       : 1) The first line of code is used to prevent a compiler warning because 'pdata' is not 
*                  used.  The compiler should not generate any code for this statement. 
*               2) Interrupts are enabled once the task start because the I-bit of the CCR register was 
*                  set to 0 by 'OSTaskCreate()'. 
********************************************************************************************************* 
*/ 
 
static void  AppTask1 (void *pdata) 
{ 
    pdata = pdata; 
    /*---- Task initialization code goes HERE! --------------------------------------------------------*/ 
 
    while (TRUE) {                          /* Task body, always written as an infinite loop.          */ 
        /*---- Task code goes HERE! -------------------------------------------------------------------*/ 
        //AppTask1Ctr++; 
        PORTB=0xaa; 
        OSTimeDly(900);                       /* Delay task execution for one clock tick                 */ 
    } 
} 
/*$PAGE*/ 
/* 
********************************************************************************************************* 
*                                             TASK #2 
* 
* Description : This is an example of a task.   
* Arguments   : pdata   is the argument passed to 'AppTask2()' by 'OSTaskCreate()'. 
* Notes       : 1) The first line of code is used to prevent a compiler warning because 'pdata' is not 
*                  used.  The compiler should not generate any code for this statement. 
*               2) Interrupts are enabled once the task start because the I-bit of the CCR register was 
*                  set to 0 by 'OSTaskCreate()'. 
********************************************************************************************************* 
*/ 
 
static void  AppTask2 (void *pdata) 
{ 
    pdata = pdata; 
    /*---- Task initialization code goes HERE! --------------------------------------------------------*/ 
 
    while (TRUE) {                          /* Task body, always written as an infinite loop.          */ 
        /*---- Task code goes HERE! -------------------------------------------------------------------*/ 
        PORTB=0x55; 
        OSTimeDly(800);                       /* Delay task execution for one clock tick                 */ 
    } 
} 
/*$PAGE*/ 
/* 
********************************************************************************************************* 
*                                      TICKER INITIALIZATION 
* 
* Description : This function is used to initialize one of the eight output compares to generate an 
*               interrupt at the desired tick rate.  You must decide which output compare you will be 
*               using by setting the configuration variable OS_TICK_OC (see OS_CFG.H and also OS_CPU_A.S)  
*               to 0..7 depending on which output compare to use. 
*                   OS_TICK_OC set to 0 chooses output compare #0 as the ticker source 
*                   OS_TICK_OC set to 1 chooses output compare #1 as the ticker source 
*                   OS_TICK_OC set to 2 chooses output compare #2 as the ticker source 
*                   OS_TICK_OC set to 3 chooses output compare #3 as the ticker source 
*                   OS_TICK_OC set to 4 chooses output compare #4 as the ticker source 
*                   OS_TICK_OC set to 5 chooses output compare #5 as the ticker source 
*                   OS_TICK_OC set to 6 chooses output compare #6 as the ticker source 
*                   OS_TICK_OC set to 7 chooses output compare #7 as the ticker source 
* Arguments   : none 
* Notes       : 1) It is assumed that you have set the prescaler rate of the free running timer within 
*                  the first 64 E clock cycles of the 68HC12. 
*               2) CPU registers are define in IO.H (see COSMIC compiler) and in OS_CPU_A.S. 
********************************************************************************************************* 
*/ 
/* in the mchc912dg128a , the TCTL1 register(OCx bit) has to be set to same as TMSK */ 
/* the 16 bit down counter will run, but the interrupt won't get set if we dont set */ 
/* this bit															          		*/ 
 
static void AppTickInit (void) 
{ 
   TSCR1   = 0x80;                         /* Enable timer*/ 
         
#if OS_TICK_OC == 0 
    TIOS  |= 0x01;                          /* Make channel an output compare                          */ 
    TC0    = TCNT + OS_TICK_OC_CNTS;        /* Set TC0 to present time + OS_TICK_OC_CNTS               */ 
    TCTL1  |= 0x01;	              			/* set timer control reg */ 
    TIE |= 0x01;                          /* Enable OC0 interrupt.                                   */ 
#endif 
 
#if OS_TICK_OC == 1  
    TIOS  |= 0x02;                          /* Make channel an output compare                          */ 
    TC1    = TCNT + OS_TICK_OC_CNTS;        /* Set TC1 to present time + OS_TICK_OC_CNTS               */ 
    TCTL1  |= 0x02;	              			/* set timer control reg */ 
    TIE |= 0x02;                          /* Enable OC1 interrupt.                                   */ 
#endif 
 
#if OS_TICK_OC == 2 
    TIOS  |= 0x04;                          /* Make channel an output compare                          */ 
    TC2    = TCNT + OS_TICK_OC_CNTS;        /* Set TC2 to present time + OS_TICK_OC_CNTS               */ 
    TCTL1  |= 0x04;	              			/* set timer control reg */ 
    TIE |= 0x04;                          /* Enable OC2 interrupt.                                   */ 
#endif 
 
#if OS_TICK_OC == 3 
    TIOS  |= 0x08;                          /* Make channel an output compare                          */ 
    TC3    = TCNT + OS_TICK_OC_CNTS;        /* Set TC3 to present time + OS_TICK_OC_CNTS               */ 
    TCTL1  |= 0x08;	              			/* set timer control reg */ 
    TIE |= 0x08;                          /* Enable OC3 interrupt.                                   */ 
#endif 
 
#if OS_TICK_OC == 4 
    TIOS  |= 0x10;                          /* Make channel an output compare                          */ 
    TC4    = TCNT + OS_TICK_OC_CNTS;        /* Set TC4 to present time + OS_TICK_OC_CNTS               */ 
    TCTL1  |= 0x10;	              			/* set timer control reg */ 
    TIE |= 0x10;                          /* Enable OC4 interrupt.                                   */ 
#endif 
 
#if OS_TICK_OC == 5 
    TIOS  |= 0x20;                          /* Make channel an output compare                          */ 
    TC5    = TCNT + OS_TICK_OC_CNTS;        /* Set TC5 to present time + OS_TICK_OC_CNTS               */ 
    TCTL1  |= 0x20;	              			/* set timer control reg */ 
    TIE |= 0x20;                          /* Enable OC5 interrupt.                                   */ 
#endif 
 
#if OS_TICK_OC == 6 
    TIOS  |= 0x40;                          /* Make channel an output compare                          */ 
    TC6    = TCNT + OS_TICK_OC_CNTS;        /* Set TC6 to present time + OS_TICK_OC_CNTS */ 
    TCTL1  |= 0x40;	              			/* set timer control reg */ 
    TIE |= 0x40;                          /* Enable OC6 interrupt.                                   */ 
#endif 
 
#if OS_TICK_OC == 7 
    TIOS  |= 0x80;                          /* Make channel an output compare                          */ 
    TC7    = TCNT + OS_TICK_OC_CNTS; 
    TCTL1  |= 0x80;							/* set timer control reg */ 
    TIE |= 0x80;                          /* Enable OC7 interrupt. */ 
   								                              
#endif 
}