/*
*********************************************************************************************************
* uC/OS-II
* The Real-Time Kernel
* CORE FUNCTIONS
*
* (c) Copyright 1992-1998, Jean J. Labrosse, Plantation, FL
* All Rights Reserved
*
* V2.00
*
* File : OS_CORE.C
* By : Jean J. Labrosse
*********************************************************************************************************
*/
#ifndef OS_MASTER_FILE
#define OS_GLOBALS
#include "includes.h"
#endif
/*
*********************************************************************************************************
* 지역적 전역 변수
*********************************************************************************************************
*/
static INT8U OSIntExitY; /* 'OSIntExit'에서 지역변수 대신 사용하는 변수 */
static OS_STK OSTaskIdleStk[OS_TASK_IDLE_STK_SIZE]; /* Idle 태스크 스택 */
#if OS_TASK_STAT_EN
static OS_STK OSTaskStatStk[OS_TASK_STAT_STK_SIZE]; /* 통계 태스크 스택 */
#endif
static OS_TCB OSTCBTbl[OS_MAX_TASKS + OS_N_SYS_TASKS]; /* TCB 테이블 */
/*$PAGE*/
/*
*********************************************************************************************************
* 비트 위치에 대한 비트 마스크를 매핑하기 위한 테이블
*
* 노트 : 테이블 인덱스는 비트 위치(0..7)를 의미.
* 인덱싱된 값은 비트 마스크에 해당.
*********************************************************************************************************
*/
INT8U const OSMapTbl[] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};
/*
*********************************************************************************************************
* 우선순위 매핑 테이블
*
* 노트 : 테이블에 대한 인덱스는 최상위 우선순위를 계산하기 위한 비트 패턴임.
* 인덱싱된 값은 최상위 우선순위 비트 위치(0..7)에 해당.
*********************************************************************************************************
*/
INT8U const OSUnMapTbl[] = {
0, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
6, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
7, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
6, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0
};
/*$PAGE*/
/*
*********************************************************************************************************
* 이벤트의 종류에 따라 태스크를 실행준비 상태로 만들기
*
* 설명 : 이 함수는 uC/OS-II의 다른 서비스에 의해 호출되며, 이벤트가 발생하기를 기다리는 태스크를
* 실행준비 상태로 만든다.
*
* 전달인자 : pevent 해당 이벤트 컨트롤 블록을 가리키는 포인터.
*
* msg 메시지를 가리키는 포인터. 이 포인터는 메일박스나 큐 같은 메시지 처리 서비스가
* 사용한다. 다른 서비스 함수가 호출할 경우, 이 포인터를 사용하지 않는다.
*
*
* msk TCB의 상태 바이트를 클리어하는데 사용하는 마스크. 예를 들어, OSSemPost()는
* OS_STAT_SEM를, OSMboxPost()는 OS_STAT_MBOX를 전달한다.
*
* 리턴값 : 없음
*
* 노트 : 이 함수는 uC/OS-II 내부적으로 사용하므로 응용프로그램이 이 함수를 호출하면 안된다.
*********************************************************************************************************
*/
#if (OS_Q_EN && (OS_MAX_QS >= 2)) || OS_MBOX_EN || OS_SEM_EN
void OSEventTaskRdy (OS_EVENT *pevent, void *msg, INT8U msk)
{
OS_TCB *ptcb;
INT8U x;
INT8U y;
INT8U bitx;
INT8U bity;
INT8U prio;
y = OSUnMapTbl[pevent->OSEventGrp]; /* 메시지를 기다리는 최상위 우선순위 태스크 선택 */
bity = OSMapTbl[y];
x = OSUnMapTbl[pevent->OSEventTbl[y]];
bitx = OSMapTbl[x];
prio = (INT8U)((y << 3) + x); /* 실제 우선순위를 계산 */
if ((pevent->OSEventTbl[y] &= ~bitx) == 0) { /* 대기 목록에서 이 태스크를 삭제 */
pevent->OSEventGrp &= ~bity;
}
ptcb = OSTCBPrioTbl[prio]; /* 태스크의 TCB를 가리킨다 */
ptcb->OSTCBDly = 0; /* OSTimeTick()이 준비상태로 만드는 것을 막는다 */
ptcb->OSTCBEventPtr = (OS_EVENT *)0; /* 태스크에서 ECB를 삭제 */
#if (OS_Q_EN && (OS_MAX_QS >= 2)) || OS_MBOX_EN
ptcb->OSTCBMsg = msg; /* 대기 태스크로 직접 메시지를 송부 */
#else
msg = msg; /* 인자를 사용하지 않을 경우 컴파일러 경고 방지 */
#endif
ptcb->OSTCBStat &= ~msk; /* 이벤트 종류에 관련된 비트를 지움 */
if (ptcb->OSTCBStat == OS_STAT_RDY) { /* 준비 상태인지 확인(대기 상태일 수 있다) */
OSRdyGrp |= bity; /* 태스크를 실행준비 리스트에 등록 */
OSRdyTbl[y] |= bitx;
}
}
#endif
/*$PAGE*/
/*
*********************************************************************************************************
* 태스크를 이벤트 대기상태로 만들기
*
* 설명 : 이 함수는 다른 uC/OS-II의 서비스 함수에 의해 호출되며, 태스크를 이벤트가 발생할 때까지
* 대기시킨다.
*
* 전달인자 : pevent 태스크가 기다릴 이벤트 컨트롤 블록을 가리키는 포인터.
*
* 리턴값 : 없음
*
* 노트 : 이 함수는 uC/OS-II 내부적으로 사용하므로 응용프로그램이 이 함수를 호출하면 안된다.
*********************************************************************************************************
*/
#if (OS_Q_EN && (OS_MAX_QS >= 2)) || OS_MBOX_EN || OS_SEM_EN
void OSEventTaskWait (OS_EVENT *pevent)
{
OSTCBCur->OSTCBEventPtr = pevent; /* TCB에 있는 이벤트 컨트롤 블록의 포인터 저장 */
if ((OSRdyTbl[OSTCBCur->OSTCBY] &= ~OSTCBCur->OSTCBBitX) == 0) { /* 준비상태가 아님 */
OSRdyGrp &= ~OSTCBCur->OSTCBBitY;
}
pevent->OSEventTbl[OSTCBCur->OSTCBY] |= OSTCBCur->OSTCBBitX; /* 태스크를 대기 목록에 등록 */
pevent->OSEventGrp |= OSTCBCur->OSTCBBitY;
}
#endif
/*$PAGE*/
/*
*********************************************************************************************************
* 이벤트 타임아웃 발생시 태스크를 준비상태로 만들기
*
* 설명 : 이 함수는 타임아웃이 발생했을 때 태스크를 준비상태로 만들기 위해 uC/OS-II의
* 다른 서비스 함수가 호출한다.
*
* 전달인자 : pevent 태스크를 준비상태로 만드는 이벤트 컨트롤 블록을 가리키는 포인터.
*
* 리턴값 : 없음
*
* 노트 : 이 함수는 uC/OS-II 내부적으로 사용하므로 응용프로그램이 이 함수를 호출하면 안된다.
*********************************************************************************************************
*/
#if (OS_Q_EN && (OS_MAX_QS >= 2)) || OS_MBOX_EN || OS_SEM_EN
void OSEventTO (OS_EVENT *pevent)
{
if ((pevent->OSEventTbl[OSTCBCur->OSTCBY] &= ~OSTCBCur->OSTCBBitX) == 0) {
pevent->OSEventGrp &= ~OSTCBCur->OSTCBBitY;
}
OSTCBCur->OSTCBStat = OS_STAT_RDY; /* 준비상태로 한다 */
OSTCBCur->OSTCBEventPtr = (OS_EVENT *)0; /* 이벤트 포인터를 삭제 */
}
#endif
/*$PAGE*/
/*
*********************************************************************************************************
* 이벤트 컨트롤 블록의 대기목록 초기화
*
* 설명 : 이벤트 컨트롤 블록의 대기몰록을 초기화 하기 위해 uC/OS-II의 다른 서비스가 호출한다.
*
* 전달인자 : pevent 이벤트에 할당된 이벤트 컨트롤 블록을 가리키는 포인터.
*
* 리턴값 : 없음
*
* 노트 : 이 함수는 uC/OS-II 내부적으로 사용하므로 응용프로그램이 이 함수를 호출하면 안된다.
*********************************************************************************************************
*/
#if (OS_Q_EN && (OS_MAX_QS >= 2)) || OS_MBOX_EN || OS_SEM_EN
void OSEventWaitListInit (OS_EVENT *pevent)
{
INT8U i;
pevent->OSEventGrp = 0x00; /* 아무 태스크도 이벤트를 기다리지 않는다 */
for (i = 0; i < OS_EVENT_TBL_SIZE; i++) {
pevent->OSEventTbl[i] = 0x00;
}
}
#endif
/*$PAGE*/
/*
*********************************************************************************************************
* 초기화
*
* 설명 : 이 함수는 uC/OS-II의 내부상태를 초기화 한다. 다른 uC/OS-II 오브젝트를 생성하기 전에
* 반드시 호출해야 하며, OSStart()를 호출하기 전에 호출해야 한다.
*
* 전달인자 : 없음
*
* 리턴값 : 없음
*********************************************************************************************************
*/
void OSInit (void)
{
INT16U i;
OSTime = 0L; /* 32비트 시스템 클럭을 클리어 */
OSIntNesting = 0; /* 인터럽트 중첩 카운터 클리어 */
OSLockNesting = 0; /* 스케줄링 잠금 카운터 클리어 */
#if OS_TASK_CREATE_EN || OS_TASK_CREATE_EXT_EN || OS_TASK_DEL_EN
OSTaskCtr = 0; /* 태스크 수 클리어 */
#endif
OSRunning = FALSE; /* 멀티태스킹이 시작되지 않았음을 명시 */
OSIdleCtr = 0L; /* 32비트 idle 카운터 클리어 */
#if OS_TASK_STAT_EN && OS_TASK_CREATE_EXT_EN
OSIdleCtrRun = 0L;
OSIdleCtrMax = 0L;
OSStatRdy = FALSE; /* 통계 태스크가 준비되지 않음 */
#endif
OSCtxSwCtr = 0; /* 문맥전환 카운터 클리어 */
OSRdyGrp = 0; /* 준비 리스트 클리어 */
for (i = 0; i < OS_RDY_TBL_SIZE; i++) {
OSRdyTbl[i] = 0;
}
OSPrioCur = 0;
OSPrioHighRdy = 0;
OSTCBHighRdy = (OS_TCB *)0; /* TCB 초기화 */
OSTCBCur = (OS_TCB *)0;
OSTCBList = (OS_TCB *)0;
for (i = 0; i < (OS_LOWEST_PRIO + 1); i++) { /* 우선순위 테이블 클리어 */
OSTCBPrioTbl[i] = (OS_TCB *)0;
}
for (i = 0; i < (OS_MAX_TASKS + OS_N_SYS_TASKS - 1); i++) { /* 자유 TCB 리스트 초기화 */
OSTCBTbl[i].OSTCBNext = &OSTCBTbl[i + 1];
}
OSTCBTbl[OS_MAX_TASKS + OS_N_SYS_TASKS - 1].OSTCBNext = (OS_TCB *)0; /* 마지막 OS_TCB */
OSTCBFreeList = &OSTCBTbl[0];
#if OS_MAX_EVENTS >= 2
for (i = 0; i < (OS_MAX_EVENTS - 1); i++) { /* 자유 이벤트 컨트롤 블록의 리스트 초기화 */
OSEventTbl[i].OSEventPtr = (OS_EVENT *)&OSEventTbl[i + 1];
}
OSEventTbl[OS_MAX_EVENTS - 1].OSEventPtr = (OS_EVENT *)0;
OSEventFreeList = &OSEventTbl[0];
#endif
#if OS_Q_EN && (OS_MAX_QS >= 2)
OSQInit(); /* 메시지 큐 구조체 초기화 */
#endif
#if OS_MEM_EN && OS_MAX_MEM_PART >= 2
OSMemInit(); /* 메모리 관리자 초기화 */
#endif
#if OS_STK_GROWTH == 1
#if OS_TASK_CREATE_EXT_EN
OSTaskCreateExt(OSTaskIdle,
(void *)0, /* OSTaskIdle()에 인자를 전달하지 않음 */
&OSTaskIdleStk[OS_TASK_IDLE_STK_SIZE - 1], /* 스택 최상위 위치 설정 */
OS_IDLE_PRIO, /* 최하위 우선순위 */
OS_TASK_IDLE_ID,
&OSTaskIdleStk[0], /* 스택 최하위 위치 설정 */
OS_TASK_IDLE_STK_SIZE,
(void *)0, /* TCB 확장 사용하지 않음 */
OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR);/* 스택 점검, 클리어 기능 활성화 */
#else
OSTaskCreate(OSTaskIdle, (void *)0, &OSTaskIdleStk[OS_TASK_IDLE_STK_SIZE - 1], OS_IDLE_PRIO);
#endif
#else
#if OS_TASK_CREATE_EXT_EN
OSTaskCreateExt(OSTaskIdle,
(void *)0, /* OSTaskIdle()에 인자를 전달하지 않음 */
&OSTaskIdleStk[0], /* 스택 최상위 위치 설정 */
OS_IDLE_PRIO, /* 최하위 우선순위 */
OS_TASK_IDLE_ID,
&OSTaskIdleStk[OS_TASK_IDLE_STK_SIZE - 1], /* 스택 최하위 위치 설정 */
OS_TASK_IDLE_STK_SIZE,
(void *)0, /* TCB 확장 사용하지 않음 */
OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR);/* 스택 점검/클리어 기능 활성화 */
#else
OSTaskCreate(OSTaskIdle, (void *)0, &OSTaskIdleStk[0], OS_IDLE_PRIO);
#endif
#endif
#if OS_TASK_STAT_EN
#if OS_TASK_CREATE_EXT_EN
#if OS_STK_GROWTH == 1
OSTaskCreateExt(OSTaskStat,
(void *)0, /* OSTaskStat()에 인자 전달하지 않음 */
&OSTaskStatStk[OS_TASK_STAT_STK_SIZE - 1],/* 스택 최상위 위치 설정 */
OS_STAT_PRIO, /* idle 태스크 보다 1단계 높은 순위 */
OS_TASK_STAT_ID,
&OSTaskStatStk[0], /* 스택 최하위 위치 설정 */
OS_TASK_STAT_STK_SIZE,
(void *)0, /* TCB 확장 사용하지 않음 */
OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR); /* 스택 점검, 클리어 기능 활성화 */
#else
OSTaskCreateExt(OSTaskStat,
(void *)0, /* OSTaskStat()에 인자 전달하지 않음 */
&OSTaskStatStk[0], /* 스택 최상위 위치 설정 */
OS_STAT_PRIO, /* idle 태스크보다 1단계 높은 순위 */
OS_TASK_STAT_ID,
&OSTaskStatStk[OS_TASK_STAT_STK_SIZE - 1],/* 스택 최하위 위치 설정 */
OS_TASK_STAT_STK_SIZE,
(void *)0, /* TCB 확장 사용하지 않음 */
OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR); /* 스택 점검, 클리어 기능 활성화 */
#endif
#else
#if OS_STK_GROWTH == 1
OSTaskCreate(OSTaskStat,
(void *)0, /* OSTaskStat()에 인자 전달하지 않음 */
&OSTaskStatStk[OS_TASK_STAT_STK_SIZE - 1], /* 스택 최상위 위치 설정 */
OS_STAT_PRIO); /* idle 태스크보다 1단계 높은 순위 */
#else
OSTaskCreate(OSTaskStat,
(void *)0, /* OSTaskStat()에 인자 전달하지 않음 */
&OSTaskStatStk[0], /* 스택 최상위 위치 설정 */
OS_STAT_PRIO); /* idle 태스크보다 1단계 높은 순위 */
#endif
#endif
#endif
}
/*$PAGE*/
/*
*********************************************************************************************************
* ISR 진입
*
* 설명 : 이 함수는 uC/OS-II에게 인터럽트 서비스 루틴(ISR)으로 진입하는 것을 알려준다
* 따라서 uC/OS-II는 인터럽트 중첩을 주시할 수 있으므로 마지막 중첩이 해제될 때만 스케줄링을
* 수행한다.
*
* 전달인자 : 없음
*
* 리턴값 : 없음
*
* 노트 : 1) OSIntNesting은 전역변수로 선언됐으므로 ISR은 이 함수를 호출할 필요 없이 그 값을
* 증가시킬 수 있다. 그러나 이 변수는 매우 중요한 변수 이므로 프로세서가 증가시킬 때
* 한 개의 명령어만을 사용하거나 다른 인터럽트가 중간에 발생되지 않도록 적절한 조치를
* 취해야만 한다.
* 2) OSIntNesting을 직접 증가시킬 수는 있지만, 감소시킬 때는 반드시 OSIntExit()를 호출한다.
* 3) OSIntEnter()와 OSIntExit()는 반드시 쌍으로 호출해야 한다. 즉, ISR이 시작될 때는
* OSIntEnter()를 호출하고, ISR에서 복귀할 때는 반드시 OSIntExit()를 호출해야 한다.
*
*********************************************************************************************************
*/
void OSIntEnter (void)
{
OS_ENTER_CRITICAL();
OSIntNesting++; /* ISR 중첩 레벨을 증가한다 */
OS_EXIT_CRITICAL();
}
/*$PAGE*/
/*
*********************************************************************************************************
* ISR 복귀
*
* 설명 : 이 함수는 uC/OS-II에게 ISR가 완료됐음을 알려준다. 마지막으로 중첩된 ISR이 완료된 경우
* uC/OS-II는 스케줄러를 호출해서 새로운 태스크가 실행준비 상태가 됐는지 결정한다.
*
*
* 전달인자 : 없음
*
* 리턴값 : 없음
*
* Notes : 1) OSIntEnter()와 OSIntExit()는 반드시 쌍으로 호출해야 한다. 즉, ISR이 시작될 때는
* OSIntEnter()를 호출하고, ISR에서 복귀할 때는 반드시 OSIntExit()를 호출해야 한다.
*
* 2) 스케줄러가 잠겨 있는 경우(OSSchedLock()참조) 스케줄링은 이뤄지지 않는다.
*********************************************************************************************************
*/
void OSIntExit (void)
{
OS_ENTER_CRITICAL();
if ((--OSIntNesting | OSLockNesting) == 0) { /* 모든 ISR이 처리됐고, 스케줄러가 해제 상태인가? */
OSIntExitY = OSUnMapTbl[OSRdyGrp];
OSPrioHighRdy = (INT8U)((OSIntExitY << 3) + OSUnMapTbl[OSRdyTbl[OSIntExitY]]);
if (OSPrioHighRdy != OSPrioCur) { /* 현재 태스크가 최상위면, 문맥을 전환하지 않음 */
OSTCBHighRdy = OSTCBPrioTbl[OSPrioHighRdy];
OSCtxSwCtr++; /* 문맥전환 횟수를 갱신한다 */
OSIntCtxSw(); /* 인터럽트 레벨 문맥전환 */
}
}
OS_EXIT_CRITICAL();
}
/*$PAGE*/
/*
*********************************************************************************************************
* 스케줄러
*
* 설명 : 이 함수는 어떤 태스크가 실행준비된 최상위 우선순위인지 결정하기 위해 uC/OS-II의 다른
* 함수가 호출한다. 이 함수는 태스크 레벨 코드가 호출해야 하며, ISR 내에서 태스크 스케줄링을
* 위해 사용하면 안된다(ISR에서의 스케줄링은 OSIntExit() 참조).
*
* 전달인자 : 없음
*
* 리턴값 : 없음
*
* 노트 : 1) 이 함수는 uC/OS-II 내부적으로 사용하므로 응용프로그램이 이 함수를 호출하면 안된다.
* 2) 스케줄러가 잠겨 있는 경우(OSSchedLock()참조) 스케줄링은 이뤄지지 않는다.
*********************************************************************************************************
*/
void OSSched (void)
{
INT8U y;
OS_ENTER_CRITICAL();
if ((OSLockNesting | OSIntNesting) == 0) { /* 스케줄러가 해제 상태이고 ISR 상태가 아닌 경우 */
y = OSUnMapTbl[OSRdyGrp]; /* 실행준비 상태인 최상위 우선순위 태스크 포인터 얻음 */
OSPrioHighRdy = (INT8U)((y << 3) + OSUnMapTbl[OSRdyTbl[y]]);
if (OSPrioHighRdy != OSPrioCur) { /* 현재 태스크가 최상위인 경우 문맥전환 없음 */
OSTCBHighRdy = OSTCBPrioTbl[OSPrioHighRdy];
OSCtxSwCtr++; /* 문맥전환 카운터 증가 */
OS_TASK_SW(); /* 문맥전환 수행 */
}
}
OS_EXIT_CRITICAL();
}
/*$PAGE*/
/*
*********************************************************************************************************
* 스케줄링 잠그기
*
* 설명 : 이 함수는 스케줄링이 발생하는 것을 막기 위해 사용한다. 따라서 응용프로그램은 문맥전환을
* 허용할 준비가 될 때까지 스케줄링을 잠글 수 있다.
*
* 전달인자 : 없음
*
* 리턴값 : 없음
*
* 노트 : 1) OSSchedLock()과 OSSchedUnlock()은 쌍으로 호출해야 한다. 즉, OSSchedLock()을 호출할
* 때마다 OSSchedUnlock()을 호출해야 한다.
*********************************************************************************************************
*/
void OSSchedLock (void)
{
if (OSRunning == TRUE) { /* 멀티태스킹이 시작됐는지 확인 */
OS_ENTER_CRITICAL();
OSLockNesting++; /* 잠금 중첩 카운터를 증가한다 */
OS_EXIT_CRITICAL();
}
}
/*$PAGE*/
/*
*********************************************************************************************************
* 스케줄링 해제
*
* 설명 : 스케줄링을 해제하기 위해 이 함수를 호출한다.
*
* 전달인자 : 없음
*
* 리턴값 : 없음
*
* 노트 : 1) OSSchedLock()과 OSSchedUnlock()은 쌍으로 호출해야 한다. 즉, OSSchedLock()을 호출할
* 때마다 OSSchedUnlock()을 호출해야 한다.
*********************************************************************************************************
*/
void OSSchedUnlock (void)
{
if (OSRunning == TRUE) { /* 멀티태스킹이 시작됐는지 확인 */
OS_ENTER_CRITICAL();
if (OSLockNesting > 0) { /* 카운터가 이미 0이면 감소하지 않는다 */
OSLockNesting--; /* 잠금 중첩 카운터를 감소한다 */
if ((OSLockNesting | OSIntNesting) == 0) { /* 스케줄링이 해제됐고 ISR이 아닌지 확인 */
OS_EXIT_CRITICAL();
OSSched(); /* 상위 우선순위 태스크가 실행준비 됐는지 확인 */
} else {
OS_EXIT_CRITICAL();
}
} else {
OS_EXIT_CRITICAL();
}
}
}
/*$PAGE*/
/*
*********************************************************************************************************
* 멀티태스킹 시작
*
* 설명 : 이 함수는 멀티태스킹 프로세스를 기동시켜서 uC/OS-II로 하여금 생성된 태스크를 관리하도록
* 해 준다. OSStart()를 호출하려면 그 전에 반드시 OSInit()을 호출하고 하나 이상의 태스크를
* 생성해야 한다.
*
* 전달인자 : 없음
*
* 리턴값 : 없음
*
* 노트 : OSStartHighRdy()는 다음일을 해야 한다
* a) OSTaskSwHook()을 호출한 뒤,
* b) OSRunning을 TRUE로 세트한다.
*********************************************************************************************************
*/
void OSStart (void)
{
INT8U y;
INT8U x;
if (OSRunning == FALSE) {
y = OSUnMapTbl[OSRdyGrp]; /* 최상위 우선순위 태스크의 실제 우선순위를 계산 */
x = OSUnMapTbl[OSRdyTbl[y]];
OSPrioHighRdy = (INT8U)((y << 3) + x);
OSPrioCur = OSPrioHighRdy;
OSTCBHighRdy = OSTCBPrioTbl[OSPrioHighRdy]; /* 실행 준비된 최상위 우선순위 태스크를 가리킨다 */
OSTCBCur = OSTCBHighRdy;
OSStartHighRdy(); /* 태스크를 시작하는 타겟 의존적 코드를 실행 */
}
}
/*$PAGE*/
/*
*********************************************************************************************************
* 통계 기능 초기화
*
* 설명 : 이 함수는, 다른 태스크가 수행되지 않는 1초 동안 32비트 카운터가 얼만큼 증가하는지 알아
* 내서 응용프로그램이 CPU 사용율을 계산할 때 사용하도록 해준다.
* 이 후, CPU 사용율은 32비트 카운터를 지속적으로 주시하고 있는 낮은 우선순위 태스크에 의해
* 계산된다. 그러나 이 경우는 타른 태스크가 실행되고 있는 상태다.
* CPU 사용율은 다음과 같이 주어진다:
*
* OSIdleCtr
* CPU 사용율(%) = 100 * (1 - ------------)
* OSIdleCtrMax
*
* 전달인자 : 없음
*
* 리턴값 : 없음
*********************************************************************************************************
*/
#if OS_TASK_STAT_EN
void OSStatInit (void)
{
OSTimeDly(2); /* 클럭 틱에 동기화 */
OS_ENTER_CRITICAL();
OSIdleCtr = 0L; /* idle 카운터 클리어 */
OS_EXIT_CRITICAL();
OSTimeDly(OS_TICKS_PER_SEC); /* 1초 동안의 최대 idle 카운터 값을 알아낸다 */
OS_ENTER_CRITICAL();
OSIdleCtrMax = OSIdleCtr; /* 이 값을 최대 카운터 변수에 저장 */
OSStatRdy = TRUE;
OS_EXIT_CRITICAL();
}
#endif
/*$PAGE*/
/*
*********************************************************************************************************
* IDLE 태스크
*
* 설명 : 이 태스크는 uC/OS-II 내부적으로 사용하며, 다른 상위 우선순위 태스크가 수행되지 않을 때
* 실행된다.
*
* 전달인자 : 없음
*
* 리턴값 : 없음
*********************************************************************************************************
*/
void OSTaskIdle (void *pdata)
{
pdata = pdata; /* 컴파일러 경고를 방지한다 */
for (;;) {
OS_ENTER_CRITICAL();
OSIdleCtr++;
OS_EXIT_CRITICAL();
}
}
/*$PAGE*/
/*
*********************************************************************************************************
* 통계 태스크
*
* 설명 : 이 함수는 uC/OS-II 내부적으로 사용하며, 멀티태스킹 환경에서의 몇 가지 통계값을 계산한다.
* 구체적으로, OSTaskStat()은 CPU 사용율을 계산한다.
* CPU 사용율은 다음과 같이 주어진다:
*
* OSIdleCtr
* OSCPUUsage = 100 * (1 - ------------) (단위는 %다)
* OSIdleCtrMax
*
* 전달인자 : pdata 현재 이 포인터는 사용하지 않는다.
*
* 리턴값 : 없음
*
* 노트 : 1) 이 태스크는 idle 태스크보다 높은 우선순위로 실행된다. 실제, 한 단계 높은 우선순위인
* OS_IDLE_PRIO-1로 실행된다.
* 2) 설정 매크로 OS_TASK_STAT_EN을 0으로 선언하면 이 태스크를 비활성화 할 수 있다.
* 3) 다른 모든 태스크가 생성된 후, 시스템이 안정된 상태가 될 때까지 기다리기 위해서
* 통계 태스크를 시작하기 전에 5초 정도 지연한다. 시스템이 idle 태스크의 최대값을 얻을
* 수 있도록 최소한 2초 정도의 시간지연을 줘야한다.
*
*********************************************************************************************************
*/
#if OS_TASK_STAT_EN
void OSTaskStat (void *pdata)
{
INT32U run;
INT8S usage;
pdata = pdata; /* 컴파일러 경고 방지 */
while (OSStatRdy == FALSE) {
OSTimeDly(2 * OS_TICKS_PER_SEC); /* 통계 태스크가 준비될 때 까지 대기한다 */
}
for (;;) {
OS_ENTER_CRITICAL();
OSIdleCtrRun = OSIdleCtr; /* 대기시간 동안 idle 태스크가 증가한 카운터를 얻는다 */
run = OSIdleCtr;
OSIdleCtr = 0L; /* 다음 대기시간을 위해 카운터를 리셋 */
OS_EXIT_CRITICAL();
if (OSIdleCtrMax > 0L) {
usage = (INT8S)(100L - 100L * run / OSIdleCtrMax);
if (usage > 100) {
OSCPUUsage = 100;
} else if (usage < 0) {
OSCPUUsage = 0;
} else {
OSCPUUsage = usage;
}
} else {
OSCPUUsage = 0;
}
OSTaskStatHook(); /* 사용자 훅(hook)함수 호출 */
OSTimeDly(OS_TICKS_PER_SEC); /* 1초간 대기 해서 OSIdleCtr 값을 누적한다 */
}
}
#endif
/*$PAGE*/
/*
*********************************************************************************************************
* TCB 초기화
*
* 설명 : 이 함수는 uC/OS-II 내부 함수며, 태스크 생성시 태스크 컨트롤 블록을 초기화한다.
* (OSTaskCreate(), OSTaskCreateExt() 참조)
*
* 전달인자 : prio 생성하는 태스크의 우선순위
*
* ptos CPU 레지스터를 이미 스택에 저장한 상태에서 스택영역 시작위치를 가리키는
* 포인터. OS_STK_GROWTH가 1일 때는 스택영역 시작위치가 상위 메모리를 의미하고
* 0인 경우는 하위 메모리를 의미한다. 스택이 사용되는 방향은 CPU에 따라
* 다르다는 점을 유의하라.
*
*
* pbos 스택영역의 끝을 가리키는 포인터.
* 'OSTaskCreate()'를 호출한 경우는 NULL이 전달된다.
*
* id 태스크 ID(0..65535)
*
* stk_size 스택요소 단위의 스택크기. 스택요소가 INT8U이면 'stk_size'는 스택의 바이트
* 수를 의미한다. 스택요소가 INT32U이면 스택의 바이트 수는 '4 * stk_size'다.
* 스택요소는 OS_STK로 결정하며 CPU에 의존적이다.
* 'OSTaskCreate()'를 호출한 경우 'stk_size'는 0이다.
*
*
* pext 태스크 컨트롤 블록을 확장을 위해 사용하는 사용자 정의 메모리 영역.
* 문맥전환이 일어날 때 부동 소수 연산 레지스터, MMU 레지스터를 저장하는 일 등
* 어떤 유용한 일도 할 수 있다.
* 또 태스크의 이름을 지어 이 영역에 저장할 수도 있다.
* 'OSTaskCreate()'를 호출한 경우 NULL 포인터가 전달된다.
*
*
* opt 'OSTaskCreateExt()'를 호출했을 때 전달되는 옵션이며,
* 'OSTaskCreate()'를 호출한 경우는 0이다.
*
* 리턴값 : OS_NO_ERR 호출 성공
* OS_NO_MORE_TCB 할당할 자유 TCB가 없으므로 태스크를 생성할 수 없음.
*
*
* 노트 : 이 함수는 uC/OS-II 내부적으로 사용하므로 응용프로그램이 이 함수를 호출하면 안된다.
*********************************************************************************************************
*/
INT8U OSTCBInit (INT8U prio, OS_STK *ptos, OS_STK *pbos, INT16U id, INT16U stk_size, void *pext, INT16U opt)
{
OS_TCB *ptcb;
OS_ENTER_CRITICAL();
ptcb = OSTCBFreeList; /* 자유 TCB 리스트에서 TCB를 하나 얻는다 */
if (ptcb != (OS_TCB *)0) {
OSTCBFreeList = ptcb->OSTCBNext; /* 자유 TCB 리스트의 포인터 갱신 */
OS_EXIT_CRITICAL();
ptcb->OSTCBStkPtr = ptos; /* TCB에 스택 포인터 로드 */
ptcb->OSTCBPrio = (INT8U)prio; /* TCB에 우선순위 로드 */
ptcb->OSTCBStat = OS_STAT_RDY; /* 태스크 실행 준비 상태 */
ptcb->OSTCBDly = 0; /* 태스크 지연 없음 */
#if OS_TASK_CREATE_EXT_EN
ptcb->OSTCBExtPtr = pext; /* TCB 확장 포인터 저장 */
ptcb->OSTCBStkSize = stk_size; /* 스택 크기 저장 */
ptcb->OSTCBStkBottom = pbos; /* 스택영역 끝 포인터 저장 */
ptcb->OSTCBOpt = opt; /* 태스크 옵션 저장 */
ptcb->OSTCBId = id; /* 태스크 ID 저장 */
#else
pext = pext; /* 사용하지 않는 경우 컴파일러 경고 방지 */
stk_size = stk_size;
pbos = pbos;
opt = opt;
id = id;
#endif
#if OS_TASK_DEL_EN
ptcb->OSTCBDelReq = OS_NO_ERR;
#endif
ptcb->OSTCBY = prio >> 3; /* X, Y, BitX, BitY를 미리 계산 */
ptcb->OSTCBBitY = OSMapTbl[ptcb->OSTCBY];
ptcb->OSTCBX = prio & 0x07;
ptcb->OSTCBBitX = OSMapTbl[ptcb->OSTCBX];
#if OS_MBOX_EN || (OS_Q_EN && (OS_MAX_QS >= 2)) || OS_SEM_EN
ptcb->OSTCBEventPtr = (OS_EVENT *)0; /* 이벤트를 기다리지 않음 */
#endif
#if OS_MBOX_EN || (OS_Q_EN && (OS_MAX_QS >= 2))
ptcb->OSTCBMsg = (void *)0; /* 메시지 도착하지 않았음 */
#endif
OS_ENTER_CRITICAL();
OSTCBPrioTbl[prio] = ptcb;
ptcb->OSTCBNext = OSTCBList; /* TCB 리스트에 연결 */
ptcb->OSTCBPrev = (OS_TCB *)0;
if (OSTCBList != (OS_TCB *)0) {
OSTCBList->OSTCBPrev = ptcb;
}
OSTCBList = ptcb;
OSRdyGrp |= ptcb->OSTCBBitY; /* 태스크를 실행 준비 상태로 함 */
OSRdyTbl[ptcb->OSTCBY] |= ptcb->OSTCBBitX;
OS_EXIT_CRITICAL();
return (OS_NO_ERR);
} else {
OS_EXIT_CRITICAL();
return (OS_NO_MORE_TCB);
}
}
/*$PAGE*/
/*
*********************************************************************************************************
* 시스템 클럭 틱 처리
*
* 설명 : 이 함수는 '시스템 틱'이라고도 하는 '클럭 틱'이 발생한 것을 uC/OS-II로 알려주고
* 필요한 일을 처리한다. 이 함수는 티커 ISR이 호출해야 하지만 우선순위가 높은 태스크가
* 호출할 수도 있다.
*
* 전달인자 : 없음
*
* 리턴값 : 없음
*********************************************************************************************************
*/
void OSTimeTick (void)
{
OS_TCB *ptcb;
OSTimeTickHook(); /* 사용자 훅(hook)함수 호출 */
ptcb = OSTCBList; /* TCB 리스트에서 첫 번째 TCB를 가리킨다 */
while (ptcb->OSTCBPrio != OS_IDLE_PRIO) { /* 모든 TCB를 처리한다 */
OS_ENTER_CRITICAL();
if (ptcb->OSTCBDly != 0) { /* 타임아웃과 함께 이벤트 또는 시간지연대기 */
if (--ptcb->OSTCBDly == 0) { /* 카운터가 0이 될 때까지 클럭 틱 수를 감소 */
if (!(ptcb->OSTCBStat & OS_STAT_SUSPEND)) { /* 태스크가 일시 중지 상태인가? */
OSRdyGrp |= ptcb->OSTCBBitY; /* No,태스크를 준비상태로 만듦(타임아웃)*/
OSRdyTbl[ptcb->OSTCBY] |= ptcb->OSTCBBitX;
} else { /* Yes, 서스펜트 상태가 해제될 때... */
ptcb->OSTCBDly = 1; /* ... 태스크를 잃어버리는 것을 ... */
} /* ... 방지하기 위해 1틱을 남겨둔다 */
}
}
ptcb = ptcb->OSTCBNext; /* TCB 리스트에서 다음 TCB를 가리킨다 */
OS_EXIT_CRITICAL();
}
OS_ENTER_CRITICAL(); /* 32비트 틱 카운터를 증가한다 */
OSTime++;
OS_EXIT_CRITICAL();
}
/*$PAGE*/
/*
*********************************************************************************************************
* 버전 정보
*
* 설명 : 이 함수는 uC/OS-II의 버전정보를 리턴한다. 리턴되는 값은 실제 버전 번호에 100을 곱한
* 값이다. 즉, 버전 2.00인 경우 200을 리턴한다
*
*
* 전달인자 : 없음
*
* 리턴값 : 버전 번호는 100을 곱한 값이다.
*********************************************************************************************************
*/
INT16U OSVersion (void)
{
return (OS_VERSION);
}