main.c

The LN2410SBC is a high performance single board computer based on ARM920T (MMU included). Its ultra

//::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
//                                                                             ;
//   uC/OS-II ARM porting source                                               ;
//   version 2.52                                                              ;
//                                                                             ;
//   CyberLab 2003.11.25                                                       ;
//   www.armkorea.com                                                          ;
//       by redizi                                                             ;
//                                                                             ;
//::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

#include "includes.h"
#include "S3C2410x.h"
#include "myLib.h"

//-----------------------------------------------------------------------------------//
//                                              CONSTANTS                            //
//-----------------------------------------------------------------------------------//
#define  TASK_STK_SIZE        512   //Size of each task's stacks  (# of WORDs)
#define  N_TASKS              2     //Number of identical tasks

#define  PRIO_LED1_TASK       1
#define  PRIO_LED2_TASK       2


//-----------------------------------------------------------------------------------//
//                                              VARIABLES                            //
//-----------------------------------------------------------------------------------//
OS_STK   TaskStk[N_TASKS][TASK_STK_SIZE];             // Tasks stacks
OS_STK   TaskStartStk[TASK_STK_SIZE];


//-----------------------------------------------------------------------------------//
//                                         FUNCTION PROTOTYPES                       //
//-----------------------------------------------------------------------------------//

void   TaskStart(void *data);       // Function prototypes of Startup   task
void   LED1Task(void *data);        // Function prototypes of tasks
void   LED2Task(void *data);

OS_EVENT* sem1;
OS_EVENT* sem2;



/*$PAGE*/
//-----------------------------------------------------------------------------------//
//                                             STARTUP TASK                          //
//-----------------------------------------------------------------------------------//

void ViewPSR(char *str)
{
   int state;
   __asm__ __volatile__
   (
      "MRS %0, CPSR":"=r"(state)
   );
   Uart_Printf("%s CPSR:%x\n\r", str,state);
}

void ViewSP(char *str)
{
   int state;
   __asm__ __volatile__
   (
      "MOV %0, r13":"=r"(state)
   );
   Uart_Printf("%s SP:%x\n\r", str,state);
}

void Timer0(void)
{
   rSRCPND = BIT_TIMER0;
   rINTPND = BIT_TIMER0;

   rGPBDAT^=(1<<5);
   OSSemPost(sem2);
}

void Timer1(void)
{
   rSRCPND = BIT_TIMER1;
   rINTPND = BIT_TIMER1;

   OSTimeTick();
}

void Timer0_Init(void)
{
   rTCFG0=(rTCFG0&0xffffff00)|(128-1);                // Prescaler=1/128 for Timer0
   rTCFG1=(rTCFG1&0xfffffff0)|0x00;                   // Mux=1/2 for Timer0
   rTCNTB0=25920-1;
   rTCMPB0=rTCNTB0-1;
   rTCON|=0x02;
   rTCON=(rTCON&0xfffffff0)|0x09;                     // Interval Mode, Inverter Off, Update

   UCOS_VectSet( NUM_TIMER0, (int) Timer0);

   rINTMSK &= ~(BIT_TIMER0);
} // end of Isr_Init(...)


void Timer1_Init(void)
{
   rTCFG0=(rTCFG0&0xffffff00)|(125-1);                // Prescaler=1/125 for Timer1
   rTCFG1=(rTCFG1&0xffffff0f)|(0x1<<4);               // Mux=1/4 for Timer0
   rTCNTB1=(266000000/4/125/4/OS_TICKS_PER_SEC)-1;
   rTCMPB1=rTCNTB1-1;
   rTCON|=(0x02<<8);
   rTCON=(rTCON&0xfffff0ff)|(0x09<<8);                // Interval Mode, Inverter Off, Update

   UCOS_VectSet( NUM_TIMER1, (int) Timer1);

   rINTMSK &= ~(BIT_TIMER1);
}

//-----------------------------------------------------------------------------------//
//                                                MAIN                               //
//-----------------------------------------------------------------------------------//
void Main(void)
{
   int i;

   rINTMOD     = 0x0;                        //All=IRQ mode
   rINTMSK     = BIT_ALLMSK;                 //All interrupt is masked.

   Uart_Init();

   pISR_SWI = (unsigned)UCOS_SWI;
   pISR_IRQ = (unsigned)UCOS_IRQ;

   Uart_Printf("uCOS II Start...\n\r");

   OSInit();                        // Initialize uC/OS-II
   OSTaskCreate(TaskStart, (void *)0, (void *)&TaskStartStk[TASK_STK_SIZE - 1], 0);
   OSStart();                       // Start multitasking
} // end of main()


void TaskStart (void *data)
{
   OS_CPU_SR cpu_sr;
   INT8U err;
   int i;

   #ifdef   OS_TASK_USERMODE
   Uart_Printf("USER Mode \n\r");
   #else
   Uart_Printf("System Mode \n\r");
   #endif
   Uart_Printf("Start Task\n\r");

   Timer0_Init();
   Timer1_Init();


   OSTaskCreate(LED1Task,"LED1", (void *)&TaskStk[0][TASK_STK_SIZE - 1], PRIO_LED1_TASK);
   OSTaskCreate(LED2Task,"LED2", (void *)&TaskStk[1][TASK_STK_SIZE - 1], PRIO_LED2_TASK);

   sem1 = (OS_EVENT*)OSSemCreate(0);
   sem2 = (OS_EVENT*)OSSemCreate(0);

   for(;;)
   {
      Uart_Printf("Task1: %d\n\r", i++);

      OSSemPend( sem1, 0, &err);
   } // end of for
} // end of TaskStart(...)

void LED1Task(void *data)
{
   INT8U err;
   int i;

   while(1)
   {
      Uart_Printf("Task2: %d\n\r",i++);

      OSTimeDly(OS_TICKS_PER_SEC);
      OSSemPost( sem1);
   }
}


void LED2Task(void *data)
{
   INT8U err;

   while(1)
   {
      OSSemPend( sem2, 0, &err);
      rGPBDAT^=(2<<5);
   }
}