아두이노에서 FreeRTOS 사용하기 - 4. Mutual Exclusion (상호배제)

이번 주제인 mutual exclusion(상호 배제)는 여러 태스크가 같은 자원에 동시에 억세스 하지 못하도록 보장해 주는 메커니즘이다. 

두개의 태스크가 동시에 같은 자원(여기서는 가상의 프린터 )를 사용하는 경우 태스크가 실행되는 도중에 RTOS에 의해 선점되면 출력 결과가 아래와 같은 식으로 되어 버린다.

Printer 1: +++++++++++Printer 2: -----------------------------

++++++++++++++++++

Printer 1: Printer 2: -----------------------------

+++++Printer 2: -----------------------------

++++++++++++++++++++++++

Printer 2: -----------------------------

PrintePrinter 2: -----------------------------

r 1: ++++++++Printer 2: -----------------------------

+++++++++++++++++++++

Printer 1: Printer 2: -----------------------------

+++++++++++++++++++++++++++++

Printer 1: +++++++++++++++++++++++++++++

Printer 2: -----------------------------

Printer 1: +++++++++++++++++++++++++++++

Printer 2: -----------------------------

Printer 1: +++++++++++++++Printer 2: -----------------------------

++++++++++++++

Printer 1: ++++++Printer 2: -----------------------------

+++++++++++++++++++++++

Printer 2: -----------------------------

위의 결과가 나온 코드이다.

#include <FreeRTOS_AVR.h>

#define MS(x) ((unsigned long)(x)/portTICK_PERIOD_MS)

void vPrint(void *);

void setup()

{

  Serial.begin(115200);

  xTaskCreate(vPrint, "Printer1", 200, (void *)"Printer 1: +++++++++++++++++++++++++++++", 1, NULL);

  xTaskCreate(vPrint, "Printer2", 200, (void *)"Printer 2: -----------------------------", 2, NULL);

  vTaskStartScheduler();

  while (1) ;

}

void loop()

{

}

void vPrint(void *pvParameters)

{

  unsigned char led_state = 0;

  while (1) {

    printer((char *)pvParameters);

    vTaskDelay(MS(random(100)));

  }

}

void printer(char *p)

{

  while (*p != '\0') {

    Serial.print(*p++);

    delay(1);

  }

  Serial.println(" ");

}

하지만 원하는 것은 한 태스크가 프린터로 출력하는 동안 다른 태스크가 방해하지 못하게 하는 것이다.

Printer 1: +++++++++++++++++++++++++++++

Printer 1: +++++++++++++++++++++++++++++

Printer 2: -----------------------------

Printer 2: -----------------------------

Printer 1: +++++++++++++++++++++++++++++

Printer 2: -----------------------------

Printer 1: +++++++++++++++++++++++++++++

Printer 1: +++++++++++++++++++++++++++++

Printer 2: -----------------------------

Printer 1: +++++++++++++++++++++++++++++

Printer 2: -----------------------------

Printer 2: -----------------------------

Printer 1: +++++++++++++++++++++++++++++

Printer 2: -----------------------------

Printer 2: -----------------------------

Printer 1: +++++++++++++++++++++++++++++

Printer 2: -----------------------------

Printer 1: +++++++++++++++++++++++++++++

Printer 2: -----------------------------

Printer 1: +++++++++++++++++++++++++++++

Printer 1: +++++++++++++++++++++++++++++

이런식으로 출력되게 하기 위해 한 태스크가 프린터를 사용하는 동안 다른 태스크는 프린터에 접근하지 못하고 대기하게 하기 위해 MUTEX를 사용한다.

#include <FreeRTOS_AVR.h>

#define MS(x) ((unsigned long)(x)/portTICK_PERIOD_MS)

SemaphoreHandle_t xMutex;

void vPrint(void *);

void setup()

{

  Serial.begin(115200);

  xMutex = xSemaphoreCreateMutex();

  if (NULL != xMutex) {

    xTaskCreate(vPrint, "Printer1", 200, (void *)"Printer 1: +++++++++++++++++++++++++++++", 1, NULL);

    xTaskCreate(vPrint, "Printer2", 200, (void *)"Printer 2: -----------------------------", 2, NULL);

    vTaskStartScheduler();

  } else {

    Serial.println("Create mutex failed.");

  }

  while (1) ;

}

void loop()

{

}

void vPrint(void *pvParameters)

{

  unsigned char led_state = 0;

  while (1) {

    xSemaphoreTake( xMutex, portMAX_DELAY);       // block forever until the semaphore is given

    // Critical section start

    printer((char *)pvParameters);

    // Critical section end

    xSemaphoreGive( xMutex );

    vTaskDelay(MS(random(500)));

  }

}

void printer(char *p)

{

  while (*p != '\0') {

    Serial.print(*p++);

    delay(1);

  }

  Serial.println(" ");

}

위의 코드에서 빨간색으로 표시된 부분을 Critical Section(임계영역)이라고 한다. 여러 태스크가 공유하지만 동시에 억세스하면 안되는 자원을 억세스 하는건 critical section 내에서만 해야 한다. C.S.는 xSemaphoreTake()로 시작하고 xSemaphoreGive()로 끝난다. 한 태스크가 C.S. 내에 있는 코드를 실행하고 있는 동안 다른 태스크가 C.S. 안으로 들어가려고 하면 xSemaphoreTake()에서 블럭되어 현재 C.S. 내에서 실행중이 태스크가 빠져 나오면서 xSemaphoreGive()를 호출할 때 까지 sleep 상태로 대기하게 되므로 동시에 두개 이상의 태스크가 C.S. 내로 진입할 수 없게 된다.  

 

 

1. CS에 아무 태스크도 진입하지 않은 상태

 2.태스크1이 xSemaphoreTake() 를 호출해 키를 가지고 CS에 진입

 3. 태스크1이 CS 내부에서 공유자원인 프린터를 사용

 4. 태스크1이 아직 CS 내에 있는데 태스크2도 CS에 진입하기 위해 xSemaphoreTake()를 호출했으나 키가 없어 CS에 진입하지 못하고 sleep 상태로 키가 돌아오기를 대기

 5. 태스크1이 CS에서 빠져나오며 xSemaphoreGive()를 호출해 키를 돌려줌

 6. Sleep상태로 기다리던 태스크2가 키가 돌아왔으므로 깨어나 CS에 진입

 

 

위의 예제에서는 태스크간에 공유하는 자원으로 프린터를 예로 들었지만 그 이외에 서로 공유하는 전역변수들 역시 억세스 할 때는 C.S. 내에서 해야 한다. 

 

그리고 태스크가 C.S.  내에 들어 있는 동안 그 C.S.에 진입하려고 하는 태스크는 블럭되어 실행되지 못하므로 ISR과 마찬가지로 C.S. 내에서도 가능한 빨리 작업을 마치고 빠져 나와야 한다.

아두이노에서 FreeRTOS 사용하기 - 3. 태스크 동기화

멀티태스킹 프로그램을 만들다 보면 태스크 간 또는 태스크와 ISR 간에 동기화가 필요한 경우가 있다. 

이 예제에는 LED라는 이름의 태스크가 실행되는데, 이 태스크는 외부에 연결된 Push button이 눌린 이벤트가릴 발생할 때 마다 led의 상태를 토글한다. 또 하나의 태스크인 PBSW는 스위치의 상태를 감시하다 버튼이 눌리면 그 이벤트를 LED 태스크에 통보한다.

LED 태스크는 버튼이 눌린 이벤트가 발생할 때 까지 대기해야 하는데 이를 위해 세마포어를 사용하게 된다. 여기서는 binary semaphore를 사용한다.

세마포어는 다음 함수로 만들 수 있다.

vSemaphoreCreateBinary ( xSemaphoreHandle xSemaphore );

세마포어에 대한 동작은 ‘take’ 또는 ‘give’ 두가지 밖에 없다.

xSemaphoreTake ( vSemaphoreHandle xSemaphore, portTickType xBlockTime );

xSemaphoreGive ( vSemaphoreHandle xSemaphore );

위의 두 매크로 모두 정상적으로 실행되었으면 pdTrue를 리턴하고, 에러가 발생하면 pdFalse를 리턴한다. xBlockTime 파라미터는 semaphore가 available할 때 까지 대기 시간이다. Queue 함수에서 사용된 것과 동일한 역할을 한다.

만일 Queue 또는 semaphore등을 ISR에서 사용해야 하는 경우에는 특별한 함수나 매크로를 사용해야만 한다. 이 함수나 매크로들은 이름의 마지막이 FromISR 로 끝난다. 예) xSemaphoreTakeFromISR, xSemaphoreGiveFromISR 

#include <FreeRTOS_AVR.h>

#define MS(x) ((unsigned long)(x)/portTICK_PERIOD_MS)

#define LED_PIN 13

#define SW_PIN 3

SemaphoreHandle_t xSemaphore;

void vLED(void *);

void vPBSW(void *);

void setup()

{

  Serial.begin(115200);

  vSemaphoreCreateBinary( xSemaphore );

  xTaskCreate(vLED, "LED", 200, NULL, 1, NULL);

  xTaskCreate(vPBSW, "PBSW", 200, NULL, 1, NULL);

  vTaskStartScheduler();

  while (1) ;

}

void loop()

{

}

void vLED(void *pvParameters)

{

  unsigned char led_state = 0;

  Serial.print("Task ");

  Serial.print((char *)pvParameters);

  Serial.println(" started...");

  pinMode(LED_PIN, OUTPUT);          // init LED

  while (1) {

    xSemaphoreTake( xSemaphore, portMAX_DELAY);       // block forever until the semaphore is given

    led_state =! led_state;                          // toggle LED state

    digitalWrite(LED_PIN, led_state);         // apply LED state

  }

}

void vPBSW(void *pvParameters)

{

  unsigned char last_state = 1;

  unsigned char cur_state;

  Serial.print("Task ");

  Serial.print((char *)pvParameters);

  Serial.println(" started...");

  pinMode(SW_PIN, INPUT_PULLUP);  // init Pushbutton switch

  while (1) {

    cur_state = digitalRead(SW_PIN);

    if ((1==last_state) && (0==cur_state)) {    // button pressed

      xSemaphoreGive( xSemaphore );

      last_state = 0;

    } else if ((1==last_state) && (0==cur_state)) {    // button released

      last_state = 1;

    }

    vTaskDelay(10/portTICK_PERIOD_MS);

  }

}

위의 코드에서 vLED 태스크는 xSemaphoreTake() 함수에서 실행을 중단하고 vPBSW 태스크에서 xSemaphoreGive() 함수를 호출해 줄 때 까지는 잠자는 상태로 대기하게 된다. 물론 세마포어를 사용하지 않고 전역변수를 이용해서도 유사하게 동작하게 할 수 있지만 그 경우는 busy waiting이 되기 때문에 상당히 비효율적이다.

void LED()

{

  ...

  while (1) {

    if (1 == gFlag) {

    led_state =! led_state;                          // toggle LED state

    digitalWrite(LED_PIN, led_state);         // apply LED state

    gFlag = 0; 

  }

} 

void PBSW()

{

  ...

  while (1) {    

    if ((1==last_state) && (0==cur_state)) {    // button pressed

      gFlag = 1;

      last_state = 0;

    } else if ((1==last_state) && (0==cur_state)) {    // button released

      last_state = 1;

    }

    ...

  }

}

이 경우 LED 태스크는 쉬지 않고 계속 gFlag 변수값이 1이 되는지를 확인해야 한다. 그에 비해 세마포어를 사용하면 스위치가 눌리지 않는 한 LED 테스크는 별도로 CPU 자원을 사용하지 않고 sleep 상태를 유지하므로 그 시간에 다른 작업을 더 할 수 있다.

아두이노에서 FreeRTOS 사용하기 - 2

이번에는 태스크 간 통신에 관한 내용이다.

두개의 태스크가 동시에 실행되면서 서로간에 데이터를 주고 받는 예제 코드를 만들어 보겠다. 태스크 간 통신을 위해서 Queue를 사용한다.

이전 예제 코드에서 Light 태스크는 측정한 조도 값을 시리얼 포트를 통해 출력했는데, 이번에는 시리얼 포트로 출력하는 대신 측정 값을 Print라는 이름의 태스크로 보낸다. Print 태스크는 데이터가 들어오기를 기다렸다가 들어온 내용을 시리얼 포트로 출력한다.

Print 태스크는 UART를 초기화 한 후 큐에 데이터가 들어오기를 기다리는 무한루프를 돌면서 데이터가 들어오면 그 내용을 읽어 출력한다. Light 태스크는 이전 예제와 같이 무한 루프를 돌면서 조도 값을 측정하여 그 값을 큐에 집어 넣는다.

태스크 간 통신은 queue를 사용한다. Queue는 xQueueCreate() 함수로 만들어 진다.

xQueueHandle xQueueCreate ( unsigned portBASE_TYPE uxQueueLength, unsigned portBASE_TYPE uxItemSize );

이 함수는 큐에 필요한 메모리 공간(uxQueueLength * uxItemSize)을 할당하고 그에 대한 queue handle(일종의 포인터)를 리턴 해 준다.

큐에 데이터를 집어 넣기 위해서는 xQueueSendToBack() 함수를 사용하고, 큐에서 데이터를 읽어 오기 위해서는 xQueueReceive() 함수를 사용한다. 

portBASE_TYPE xQueueSendToBack ( xQueueHandle xQueue, const void *pvItemToQueue, portTickType xTicksToWait );

portBASE_TYPE xQueueReceive ( xQueueHandle xQueue, void *pvBuffer, portTickType xTicksToWait );

두 함수 모두 첫번째 파라미터는 queue handle(xQueueCreate에서 리턴된 값)이고, 두번째 파라미터는 집어 넣을 아이템(데이터)에 대한 포인터 또는 읽어 올 아이템을 넣을 버퍼의 포인터이다. 두 함수 모두 데이터를 복사하는 동작을 수행한다. 세번째 파라미터는 동작이 완료될 때 까지 기다리는 시간이다. ‘0’으로 설정하면 함수는 아이템을 큐에 쓰거나 큐에서 읽어 오는 동작이 완료되었는가 여부에 관계 없이 바로 리턴한다. 만일 이 값을 portMAX_DELAY로 지정하면 함수는 동작이 수행될 때 까지 계속 블럭된다. 그 이외 값을 넣으면 동작이 수행되지 못하는 경우 지정된 시간만큼 함수가 블럭된다. 

아래 예제에서는 Light 태스크는 큐가 풀인 경우 기다리지 않지만, Print 태스크는 큐가 비어 있는 경우 데이터가 들어올 때 까지 블럭상태로 기다린다.

#include <FreeRTOS_AVR.h>

#define MS(x) ((unsigned long)(x)/portTICK_PERIOD_MS)

QueueHandle_t xQueue;

static void Print(void* arg);

static void Light(void* arg);

static void Print(void* arg) {

  uint16_t light;

  uint16_t sampleCount = 0;

  while (1) {

    if (xQueueReceive(xQueue, &light, portMAX_DELAY)) {

      sampleCount++;

      Serial.print("Sample ");       Serial.print(sampleCount);

      Serial.print(" Light = "); Serial.println(light);

    }

  }

}

static void Light(void* arg) {  

  uint16_t l = 0;

  TickType_t xLastWakeTime;  

  xLastWakeTime = xTaskGetTickCount();  

  while (1) {

    l = analogRead(0);    

    xQueueSendToBack(xQueue, &l, 0);

    vTaskDelayUntil( &xLastWakeTime, ( 2000 / portTICK_PERIOD_MS ) );  

  }

}

void setup() {

  Serial.begin(115200);

  xQueue = xQueueCreate(5, sizeof(uint16_t));

  xTaskCreate(Print, NULL, 200, NULL, 1, NULL);

  xTaskCreate(Light, NULL, 200, NULL, 2, NULL);

  vTaskStartScheduler();     // start scheduler

  while(1);

}

void loop() {

}

---

아두이노에서 RTOS 사용하기 (FreeRTOS in Arduino)

아두이노에 포팅된 FreeRTOS를 사용하면 아두이노에서도 RTOS를 사용해 멀티 쓰레드로 프로그램을 만들 수 있다. FreeRTOS를 설치하려면 먼저 브라우져에서 아래 주소로 이동한다.

https://github.com/greiman/FreeRTOS-Arduino

Download ZIP을 클릭해 zip 파일을 다운받는다. 다운받은 파일의 압축을 풀면 디렉토리 내에 아래와 같은 파일들이 만들어진다.

이 중 libraries 디렉토리 내에 아래와 같은 3개의 서브디렉토리가 들어있다.

이 3개의 서브디렉토리를 자신의 아두이노 라이브러리 디렉토리에 복사 해 주면 된다. (아두이노에 외부 라이브러리 설치하는 법 참조)

아두이노 DUE를 사용하면 FreeRTOS_ARM을 사용하고 아두이노 UNO, MEGA등 AVR 프로세서를 사용한 아두이노의 경우 FreeRTOS_AVR을 사용하면 된다. 

라이브러리 설치가 끝나면 아두이노를 재시동하고 예제 -> FreeRTOS_AVR -> frBlink 파일을 선택해 보드에 업로드 해서 LED가 깜빡이면 FreeRTOS가 정상적으로 동작하고 있는 것이다. 

#include <FreeRTOS_AVR.h>

const uint8_t LED_PIN = 13;

SemaphoreHandle_t sem;

static void Thread1(void* arg) {

  while (1) {

    xSemaphoreTake(sem, portMAX_DELAY);

    digitalWrite(LED_PIN, LOW);

  }

}

static void Thread2(void* arg) {

  pinMode(LED_PIN, OUTPUT);

  while (1) {

    digitalWrite(LED_PIN, HIGH);

    vTaskDelay((200L * configTICK_RATE_HZ) / 1000L);

    xSemaphoreGive(sem);

    vTaskDelay((200L * configTICK_RATE_HZ) / 1000L);

  }

}

void setup() {

  portBASE_TYPE s1, s2;

  sem = xSemaphoreCreateCounting(1, 0);  // 세마포어를 생성

  s1 = xTaskCreate(Thread1, NULL, configMINIMAL_STACK_SIZE, NULL, 2, NULL); // Thread1 생성

  s2 = xTaskCreate(Thread2, NULL, configMINIMAL_STACK_SIZE, NULL, 1, NULL); // Thread2 생성

  vTaskStartScheduler();  // 태스크 스케쥴러 시작

  while(1) {}

}

void loop() {}

코드에서는 두개의 쓰레드 (Thread1, Thread2)가 동시에 실행되어 Thread2에서 LED를 켜고 200ms 후에 semaphore를 POST 해주어 Thread1이 semaphore를 받으면 LED를 끄게 되어 있다. Thread1은 LED를 끄고 나면 곧바로 다시 semaphore를 기다리지만 Thread2에서 200ms를 기다린 후 LED를 켜고 다시 200ms 후에 semaphore를 POST 하기 전에는 계속 semaphore를 기다리게 된다. 

그리고 일반 스케치와 다르게 loop() 에서는 아무 동작을 하지 않는다.