main.c

简单的在ATMEGA64上移植ucosII

#define Test1_GLOBALS
#include <includes.h>

/*
*********************************************************************************************************
*                                        SETUP THE TICK RATE
*********************************************************************************************************
*/
#define  OS_TASK_START_STK_SIZE        OS_TASK_STK_SIZE
#define  OS_TASK_START_HARD_STK_SIZE   OS_TASK_HARD_STK_SIZE

#define  OS_TASK_1_STK_SIZE            OS_TASK_STK_SIZE
#define  OS_TASK_1_HARD_STK_SIZE       OS_TASK_HARD_STK_SIZE

#define  OS_TASK_2_STK_SIZE            OS_TASK_STK_SIZE
#define  OS_TASK_2_HARD_STK_SIZE       OS_TASK_HARD_STK_SIZE

#define  OS_TASK_3_STK_SIZE            OS_TASK_STK_SIZE
#define  OS_TASK_3_HARD_STK_SIZE       OS_TASK_HARD_STK_SIZE

#define  OS_TASK_4_STK_SIZE            OS_TASK_STK_SIZE
#define  OS_TASK_4_HARD_STK_SIZE       OS_TASK_HARD_STK_SIZE

OS_STK  AppTaskStartStk[OS_TASK_START_STK_SIZE];
OS_STK  AppTask1Stk[OS_TASK_1_STK_SIZE];
OS_STK  AppTask2Stk[OS_TASK_2_STK_SIZE];
OS_STK  AppTask3Stk[OS_TASK_3_STK_SIZE];
OS_STK  AppTask4Stk[OS_TASK_4_STK_SIZE];

INT8U *str_share = "\r\n The Share Data";

void  OSTickISR_Init (void)
{
    TCCR0 = 0x00; //stop
    ASSR  = 0x00; //set async mode
    TCNT0 = 0x95; //set count
    OCR0  = 0x6B;
    TCCR0 = 0x07; //start timer                                      /* Set TIMER0 prescaler to CLK/1024            */
    TIMSK = 0x01;                                       /* Enable TIMER0 overflow interrupt            */
}


/*
*********************************************************************************************************
*                                        SETUP THE TICK RATE
*********************************************************************************************************
*/
#pragma interrupt_handler OSTickISR:iv_TIMER0_OVF
void  OSTickISR_Handler (void)
{
    //TCNT0 = 256 - (CPU_CLK_FREQ / OS_TICKS_PER_SEC / 1024);
    TCNT0 = 0x95; //set count
    OSTimeTick();
}
void AppTaskStart(void *pdata);
static  void  AppTaskCreate (void);

void enRx485(void)
{
    DelayMs();
    DelayMs();
    PORTB &= (~(1 << PB7));  //485接收使能     
}

void enTx485(void)
{
    PORTB |= (1 <<   PB7);
    DelayMs();
}
// Start
void main(void){
    /*---- Any initialization code prior to calling OSInit() goes HERE --------------------------------*/

    //CLI();                                            /* IMPORTANT: MUST be setup before calling 'OSInit()'  */
    OSTaskStkSize     = OS_TASK_STK_SIZE;       /* Setup the default stack size                        */
    OSTaskHardStkSize = OS_TASK_HARD_STK_SIZE;  /* Setup the default hardware stack size               */

	OSInit();		// OS init
    OSTaskCreate(AppTaskStart,(void *)0, &AppTaskStartStk[OS_TASK_START_STK_SIZE - 1],0);
	OSStart();		// start multitasking

}

void AppTaskStart(void *pdata){
    INT8U  a = 1;
    INT8U *str1 = "\r\n The uc/os-II start!";
    INT8U *str2 = "\r\nRxd0BufCnt% "; 
    INT8U cData[21] = "\0"; 
    INT8U *str3 = cData;
    INT16S data = 0;
	pdata    = pdata;
	//Init_devices();
	DDRD     = 0xff;
	DDRB = 0x80;
	OSTickISR_Init();
	uartInit(0);
	uartInit(1);
	putStr(0, str1, strlen(str1));
	enTx485();
	putStr(1, str1, strlen(str1));
	enRx485();
	AppTaskCreate();
	SEI();
	enRx485();
    while(1)
    {
        //putStr(0, str2, strlen(str2));
        PORTD ^= BIT(PD5);
        //data = getChar(0);
        //if(data != -1)
        //{
        //    putChar(0, (INT8U)(data));    
        //}
        OS_ENTER_CRITICAL();
        enTx485();
        putStr(1, str2, strlen(str2));
        putCharHex(1, (INT8U)((Rxd0BufCnt >> 8) & 0x00FF));
        putCharHex(1, (INT8U)((Rxd0BufCnt >> 0) & 0x00FF));
        getStrLong(0, (INT8U)255, str3);
        putStr(1, str3, strlen(str3));
        enRx485();
        OS_EXIT_CRITICAL();
        memset(str3, '\0', strlen(str3));
        WDR();
		OSTimeDly(100);
		
	}
}

// 显示CPU利用率
void AppTask1(void *pdata)
{
    INT8U str1[21] = "\r\n Task1 Display :";
    INT8U *str2 = "\r\nRxd1BufCnt%";
    INT8U *str4 = "\r\na = 200; b = 10;\r\n(INT8S)(a) < (INT8S)(b)";
    INT8U *str5 = "\r\nerror!!";
    INT8U strData[21] = "\r\n Test2!";
    
    INT8U *str3 = strData;
    INT8U a = 200;
    INT8U b = 10;
    pdata = pdata;
    while(1)
    {
        OS_ENTER_CRITICAL();
        putStr(0, str2, strlen(str2));
        putCharHex(0, (INT8U)((Rxd1BufCnt >> 8) & 0x00FF));
        putCharHex(0, (INT8U)((Rxd1BufCnt >> 0) & 0x00FF));
        if(Rxd1BufCnt != 0)
        {
            getStrLong(1, (INT8U)255, str3);
        }
        putStr(0, str3, strlen(str3));
        memset(str3, '\0', strlen(str3));
        OS_EXIT_CRITICAL();
        WDR();
        OSTimeDly(100);   
    }
}

// 显示系统节拍值OSTime
void AppTask2(void *pdata)
{
    INT32U os_time = 0;
    INT8U *str1 = "\r\n Task2 Display ";
    pdata = pdata;
    while(1)
    {
        OS_ENTER_CRITICAL();
        //InitModem();
        OS_EXIT_CRITICAL();
        WDR();
        OSTimeDly(500);
    }    
}

// 测试任务的同步与通信
void AppTask3(void *pdata)
{
    INT8U *str1 = "\r\nAppTask3";
    //INT8U *str1 = "\r\t-";
    INT8U *str2 = "\r\t\\";
    INT8U *str3 = "\r\t|";
    INT8U *str4 = "\r\t/";
    pdata = pdata; 
    while(1)
    {
        //putStr(0, str2, strlen(str2));
        OS_ENTER_CRITICAL();
        //putStr(0, str1, strlen(str1));
       // putCharHex(0, (INT8U)((Rxd0BufCnt >> 8) & 0x00FF));
        //putCharHex(0, (INT8U)((Rxd0BufCnt >> 0) & 0x00FF));
        
        OS_EXIT_CRITICAL();
        OSTimeDly(500);        
    }
}

void AppTask4(void *pdata)
{
    INT8U *str1 = "\r\t\t\t\t AppTast4 Access the Share Data";
    INT8U *str2 = "\r\n AppTast4 Access the CPU";
    pdata = pdata; 
    while(1)
    {
        //putStr(0, str2, strlen(str2));
       /* OS_ENTER_CRITICAL();
        str_share = str1;
        putStr(0, str_share, strlen(str_share));
        OS_EXIT_CRITICAL();*/
        OSTimeDly(100);    
    }
}
/*
*********************************************************************************************************
*                                    CREATE APPLICATION TASKS
*
* Description : This function creates the application tasks.
*
* Arguments   : p_arg   is the argument passed to 'AppStartTask()' by 'OSTaskCreate()'.
*
* Notes       : 1) The first line of code is used to prevent a compiler warning because 'p_arg' is not
*                  used.  The compiler should not generate any code for this statement.
*********************************************************************************************************
*/

static  void  AppTaskCreate (void)
{
    /*---- Task initialization code goes HERE! --------------------------------------------------------*/
    OSTaskStkSize     = OS_TASK_1_STK_SIZE;        /* Setup the default stack size                     */
    OSTaskHardStkSize = OS_TASK_1_HARD_STK_SIZE;   /* Setup the default hardware stack size            */
    OSTaskCreate(AppTask1, (void *)0, (OS_STK *)&AppTask1Stk[OSTaskStkSize - 1], 1);

    OSTaskStkSize     = OS_TASK_2_STK_SIZE;        /* Setup the default stack size                     */
    OSTaskHardStkSize = OS_TASK_2_HARD_STK_SIZE;   /* Setup the default hardware stack size            */
    OSTaskCreate(AppTask2, (void *)0, (OS_STK *)&AppTask2Stk[OSTaskStkSize - 1], 2);
	
	OSTaskStkSize     = OS_TASK_3_STK_SIZE;
	OSTaskHardStkSize = OS_TASK_3_HARD_STK_SIZE;   /* Setup the default hardware stack size            */
    OSTaskCreate(AppTask3, (void *)0, (OS_STK *)&AppTask3Stk[OSTaskStkSize - 1], 3);
    
    OSTaskStkSize     = OS_TASK_4_STK_SIZE;        /* Setup the default stack size                     */
    OSTaskHardStkSize = OS_TASK_4_HARD_STK_SIZE;   /* Setup the default hardware stack size            */
    OSTaskCreate(AppTask4, (void *)0, (OS_STK *)&AppTask4Stk[OSTaskStkSize - 1], 4);
}