Task 구조, signal

void main ()
{
 
     Lamp_init();
 
     while (1)
      {
            Lamp_on();
            time_wait (100); /* wait 100uS */
 
            Lamp_off();
            time_wait (100); /* wait 100uS */
      }
}

 Motor도 움직이고싶다. 
   >  또하나의 main()함수 생성

void main()
{
  
     Motor_init();
 
     while (1)
      {
            Motor_on();
            time_wait (100); /* wait 100uS */
            Motor_off();
            time_wait (100); /* wait 100uS */
      }
}

> 그냥 Lamp 무한 Loop에 Motor도 끼워 넣기

void main ()
{
  
     motor_init();
 
     while (1)
      {
            Lamp_on();
            time_wait (100); /* wait 100uS */
            Lamp_off();
            time_wait (100); /* wait 100uS */
 
            Motor_on();
            time_wait (100); /* wait 100uS */
            Motor_off();
            time_wait (100); /* wait 100uS */
      }
}

똑같은 일의 반복,, 더 많은 일 하고싶어..
 >  RTOS ( Real Time OS ) ~=( Embedded OS )

RTOS : Hard/ Soft 구분
     Hard :  응답을 정해진 시간 안에 줌
     Soft :  응답을 언제든 하기만 하면 됨
> Computing Power의 향상 > Soft도 빠른시간 안에 응답제공 > 큰 구분은 많이 없어짐
 > 미사일, 위성 > 시간 응답성이 최우선 > Hard type RTOS 사용
<>  보통 Embedded System은 굳이 구분X

Embedded OS : Scheduler ( Embedded System의 매니저 ) :  스케쥴 관리 > 그때그때 그 일을 하게 해줌
 Lamp의 무한 Loop의 함수 이름 : Lamp_task() 
 Motor의 무한 Loop의 함수 이름 : Motor_task()
(한가지 일 단위에 따라서 task , Scheduling의 기본 단위 )

void Lamp_task ()
{
     Lamp_init();
 
     while (1)
      {
            Lamp_on();
            time_wait (100); /* wait 100uS */
 
            Lamp_off();
            time_wait (100); /* wait 100uS */
      }
}

  Lamp Task : 무한히 깜빡이는 일
+ Lamp_task()와 Motor_task()가 서로 번갈아가며 하려면.. 
> signal
   : Task끼리 signal을 주고 받을 수도 있고, 그걸로 서로 일을 시킬 수도 있는것

 wait(signal); signal을 기다림
 send (task, signal) : signal을 줌 
// 임의의 함수  
    > 어떤 task한테 signal을 주는 역할

/* Make_Ready() : 대상 함수를 Ready,
        > Scheduling발생 > 제일 먼저 실행 될 Task로 설정해 주는 함수 */

void main ()
{
     Make_Ready (Lamp_task());      // 일종의 쓰레드 > Lamp_tak() 함수와 동시 실행  
     wait (DONE);        /* Lamp task는 init, DONE > WORK을 기다림 */
     Make_Ready (Motor_task());      // 두번째 쓰레드
     wait (DONE);        /* Motor task는 init, DONE> WORK 기다림 */
     send (LAMP, WORK)  /* Lamp task 실행 */
     return;   /* Good bye forever */
}
 
void Lamp_task ()
{
 
     Lamp_init();       /* 우선은 초기화 */
                                  
     send (main, DONE);   /* wait > main으로 돌아감~ */

 

// main 함수에 DONE 신호 보냄

// main 의 wait(DONE);에서 기다리고 있는 상태를 깨움

     while (1)
     {
          wait (WORK);        /* WORK라는 signal을 기다림 */
                                    /* while(1) > 한번 깜빡임 > 항상 여기서 signal 대기 */
                                    /* Signal받음 > 일 시작 */
           clear (WORK);       /* main : WORK을 받았음 > 다음번에도 WORK을 받을 수 있도록 초기화  */
            Lamp_on();
            time_wait (100); /* wait 100uS */
 
            Lamp_off();
            time_wait (100); /* wait 100uS */
 
          send (MOTOR, WORK);  /* Motor task야 Motor를 돌려봐 */
      }
}
 
void Motor_task ()
{
 
    Motor_init();
                                    /*  초기화 */
    send (main, DONE);   /* wait을 만나면 main으로 돌아감 */

     while (1)
     {
          wait (WORK);    //      Lamp_task () 가 멈추게됨

                                   //    Lamp_task () : 하단의 send (LAMP, WORK); 를 받으면 다시 실행

                                  //  while() 문 내의 wait (WORK);  부터 

                                // 무한~~
          clear (WORK);       
            Motor_on();
            time_wait (100); /* wait 100uS */
 
            Motor_off();
            time_wait (100); /* wait 100uS */
 
            send (LAMP, WORK);   /* Lamp task야 Lamp를 깜빡여봐 */
      }
}

걸 그림으로 그려보면?

 

 

이런 식의 동작을 무한히 반복!
 > Embedded System의 Task구조
    >  죽을 때 까지 실행,  시킬 때 마다 자기에게 주어진 일을 하고 다시 기다리는 구조

Thread, Process

 Task : Scheduling (~= Context Switching)의 기본 단위
// Task 단위로 일을 나누어 System을 만드는 게 기본.

Task ~= Process + Thread
>    Task  ∋ Process
   + Task  ∋ Thread 
  > Task : Process로 구현, Thread로 구현

 Process, Thread : Scheduling (Context Switching)의 기본 단위
 
 Process : 자신 만의 공유한 Memory Space 할당 받음
      > Process끼리 Memory 공간 분리
        >  Data 공유 X

 Thread :  모든 주소 공간이 공유 
     > 다른 Thread의 주소 공간을 자유자재로 move
         >  전역 변수 공유 문제 발생

( Linux )
보통 Process > 자신의 Memory Space 내에서 > 다른 Scheduling의 단위인 Thread를 만들어 냄
 : 어미 Process 자신도 자식과 주소 공간을 공유 
     >  자식 입장에서 봤을 때 다~같이 Thread가 되는셈

// 쓰레드 안에서 값 변경 >  process에서도 값 변경
    > 다른 Process가 보았을 땐 엄연한 다른 Prcoess

( Embedded System )
 Thread > Task 구현
  > 모든 주소 공간 공유가능.
ex) 전역변수
Thread 끼리 : 전역변수를 특별한 방법 X > 직접 Access가 가능

Process : 다른 Process에서 사용하고 있는 전역변수에 Access
> System call ( 특수 interface ) 이용 > 접근

>> Task의 구현 방법 : Process or Thread 로 나눔