KARTOS - 8–bitowe jądro czasu rzeczywistego, część 2.pdf - KARTOS - 8–bitowe jądro czasu rzeczywistego - Witek63

PROGRAMY

8–bitowe jądro czasu

rzeczywistego, część 2

W pierwszej części cyklu została wstępnie poruszona teoretyczna

problematyka systemów operacyjnych z uwzględnieniem systemów

operacyjnych czasu rzeczywistego. Kontynuacją będzie przedstawienie

prostej implementacji dla małych, tanich i powszechnie dostępnych,

a jednocześnie wydajnych mikrokontrolerów jednoukładowych RISC.

Zaprezentujemy również aplikację demonstracyjną.

zadań, szeregowanie zadań, zarzą-

dzanie kolejkami.

Pamięć systemowa – to obszar

pamięci danych zawierający zmien-

ne systemowe oraz stos systemowy.

Część rozszerzająca systemu

składa się z konﬁgurowalnych au-

tonomicznych modułów rozszerza-

jących funkcjonalność jądra. W jej

skład wchodzą również wszystkie

sterowniki układów peryferyjnych.

W zależności od docelowej aplikacji,

poszczególne podsystemy mogą być

włączane lub wyłączane na etapie

kompilacji kodu. Minimalna kompi-

lacja systemu w wersji 3.00 z włą-

czonym algorytmem karuzelowym

szeregowania zadań zajmuje jedynie

1654 bajty pamięci ROM i 13 baj-

tów pamięci RAM.

W tab. 1 pokazano zapotrzebo-

wanie na pamięć programu ROM

przez główne moduły systemu KaR-

TOS w wersji 3.00.

Budowa systemu KaRTOS

System KaRTOS składa się

z dwóch głównych części: podstawo-

wej i rozszerzającej, co pokazano sche-

matycznie na rys. 7 . Część podstawo-

wa jest niezbędna do pracy syste-

mu. Jej uruchomienie jest konieczne.

W skład części podstawowej wchodzą:

Timer systemowy – to blok wy-

korzystujący sprzętowy licznik mi-

krokontrolera i zegar systemowy do

odmierzania jednostkowych odcin-

ków czasu o długości 1 ms. Jest to

minimalny kwant czasu, którym za-

rządza system KaRTOS.

Funkcje podstawowe (jądro)

– to zbiór niezbędnych procedur

realizujących takie zadania jak: ini-

cjalizacja mikrokontrolera (również

timera systemowego), inicjalizacja

Rys. 7. Budowa systemu KaRTOS

Zadania w systemie KaRTOS

Każde zadanie uruchomione w sys-

temie KaRTOS posiada swoje własne

zasoby. Należą do nich:

Kod – instrukcje wykonywane

przez kontroler znajdujące się w pa-

mięci ROM. Wielkość zajmowanej

pamięci zależy od algorytmu realizo-

wanego przez zadanie. Zadanie mru-

gania diodą zajmie kilkanaście baj-

tów w pamięci programu, natomiast

implementowanie skomplikowanych

funkcjonalności wymaga większej jej

pojemności.

Stos – obszar pamięci RAM za-

wierający adresy powrotu przy wyko-

nywaniu skoków do funkcji, zmienne

tymczasowe oraz kontekst zadania

niezbędny podczas jego przełączania

(rejestry danych, wskaźnik stosu, re-

jestr statusu kontrolera). Rozmiar tej

struktury jest deﬁniowany przez pro-

gramistę implementującego algorytm

zadania. Rozmiar stosu musi być tym

większy, im więcej stopni zagnieżdżeń

posiada korzystające z niego zadanie.

Dla średnio rozbudowanego zadania

Tab. 1. Zapotrzebowanie na pamięć programu ROM przez główne moduły syste-

mu KaRTOS w wersji 3.00

Lp. Nazwa modułu

Rozmiar

[bajty]

Opis

0. KaRTOS wer. 3.01 1654

Podstawowa wersja systemu.

Włączenie algorytmu szeregowania round–robin

z priorytetami i określeniem maksymalnego czasu dla

zadania.

2. KaRTOS_RTC 242 Moduł zegara czasu rzeczywistego działającego

w oparciu o główny zegar systemowy.

3. KaRTOS_32KHZ_RTC 294 Moduł zegara czasu rzeczywistego działającego

w oparciu rezonator 32,768 kHz.

4. KaRTOS_EXT_TIME 180 Uruchomienie rozszerzonej wersji zegara z datą.

5. KaRTOS_UART_ON 1248 Sterownik wraz z funkcjami obsługi portu szeregowego.

6. KaRTOS_ADC_ON 148 Sterownik wraz z funkcjami obsługi przetwornika ADC

7. KaRTOS_EEPROM_ON 132 Sterownik wraz z funkcjami obsługi pamięci EEPROM.

8. KaRTOS_STRING 206 Pakiet funkcji do manipulacji na ciągach znaków.

9. KaRTOS_SEM 234

Moduł implementujący semafory.

Elektronika Praktyczna 6/2008

105

1. KaRTOS_PRIORITY_SCHED 160

PROGRAMY

Rys. 8. Krążenie zadań w systemie KaRTOS

nia mogą posiadać

identyczny priorytet

i być traktowane na

równi,

– licznik –

jest zmienną o sze-

rokości 16 bitów,

przechowującą war-

tość (w ms) interwa-

łu czasu, na jaki zadanie zostało

zawieszone,

– wskaźnik do struktury TCB umoż-

liwiający realizację kolejek zadań,

– wskaźnik stosu przechowujący ad-

res wierzchołka stosu zadania.

Każde zadanie w systemie może

znajdować się w jednym z czterech

stanów: wykonywane, gotowe, ocze-

kujące lub zablokowane. Wędrówkę

zadań w systemie KaRTOS pokazano

na rys. 8.

Wystartowane zadanie znajduje

się w stanie gotowe do momentu, aż

zostanie uruchomione (wykonywa-

ne) zgodnie ze swoim priorytetem.

Zadanie wykonywane to takie, któ-

re jest aktualnie w posiadaniu pro-

cesora. Oczekujące zadanie to takie,

które przerwało swoje działanie na

określony czas. W stanie zablokowane

znajduje się zadanie, które oczekuje

na określony zasób (dostęp do pa-

mięci współdzielonej RAM, pamięci

EEPROM, port itp.) lub na określony

komunikat synchronizujący. Innymi

słowy, w stanie zablokowane znajdu-

je się zadanie nie mogące kontynu-

ować działania z powodu innego niż

oczekiwanie na odmierzenie interwału

czasu.

Implementując algorytm zadania

należy pamiętać, aby nie dopuścić do

wyjścia z funkcji zadania. Można to

zrealizować na różne sposoby:

– zadanie to nieskończona pętla

void Task_2(void)

{

for(;;)

{

// Instrukcje zadania ;

} ;

– nieskończona pętla znajduje się

na końcu kodu, po zakończeniu

algorytmu zadania

void Task_2(void)

{

// Instrukcje zadania ;

for(;;){ TimeSleepms(1000)

; }

wystarczający będzie stos o wielkości

100 bajtów.

Blok kontrolny ( T ask C ontrol

B lock ) – obszar pamięci o rozmiarze

8 bajtów zawierający informacje o za-

daniu. Umożliwia on identyﬁkację za-

dań i zarządzanie nimi przez system.

TCB zawiera:

– numer identyﬁkacyjny zadania

– PID ( Process ID ) – jest to licz-

ba z zakresu od 2 do 255 jed-

noznacznie identyﬁkująca zadanie

w systemie. PID numer 0 jest za-

rezerwowany, a numer PID o nu-

merze 1 posiada systemowy pro-

ces bezczynności. Oczywistym jest,

że w poprawnie działającym syste-

mie nie mogą istnieć dwa zadania

o identycznym numerze identyﬁka-

cyjnym. PID jest nadawany zada-

niu podczas jego tworzenia,

– priorytet – liczba z zakresu od 1

do 254 określająca ważność zada-

nia – im mniejsza wartość, tym

zadanie jest ważniejsze. Najważ-

niejsze jest zadanie z priorytetem

1, gdyż priorytet 0 jest zarezerwo-

wany. Systemowy proces bezczyn-

ności posiada najmniejszą ważność

(priorytet 255). Jeśli w systemie

istnieją zadania o tym samym

priorytecie oznacza to, że są rów-

nie ważne. W skrajnym przypad-

ku wszystkie uruchomione zada-

}

„Hello wolrd tu KaRTOS”, czyli

pierwsza aplikacja w systemie

KaRTOS

Po przedstawionym powyżej mi-

nimalnym wstępie teoretycznym

nadszedł wreszcie czas upragniony

przez wszystkich praktyków, czyli

koniec marudzenia – przystępujemy

do działania. Co jest potrzebne do

tego, by napisać i uruchomić apli-

kację w systemie KaRTOS:

1. system KaRTOS – zawarty w pliku

Hello_world_tu_KaRTOS.zip – jest

to gotowa aplikacja demonstracyjna

opisywana poniżej. Po rozpakowa-

niu pliku w katalogu Hello_world_

Rys. 9. Schemat układu dla aplikacji demonstracyjnej systemu KaRTOS

106

Elektronika Praktyczna 6/2008

PROGRAMY

tu_KaRTOS znajdą się następujące

zasoby:

– katalog KaRTOS – zawiera sys-

tem operacyjny,

– plik main.h – zawiera parametry

zadań (TASK_PID – numer za-

dania (przyjmuje wartości od 2

do 255), TASK_STACK – określa

rozmiar stosu zadania w bajtach,

TASK_PRIORITY – numer prio-

rytetu zadania (przyjmuje warto-

ści od 1 do 254)),

– plik main.c – tutaj zawarte są

procedury tworzenia, inicjalizacji

zadań oraz inicjalizacji i urucho-

mienia systemu operacyjnego,

– pliki Task_1.h , Task_2.h , Task_

3.h , Task_4.h – pliki nagłówkowe

zadań istniejących w systemie

– zawierają deklaracje funkcji

i zmiennych globalnych poszcze-

gólnych zadań,

– pliki Task_1.c , Task_2.c , Task_3.c ,

Task_4.c – pliki zawierające kod

poszczególnych zadań,

– makeﬁle – plik z instrukcjami

automatycznej kompilacji dla

programu make.

2. Kawałek sprzętu, czyli mikrokon-

troler ATmega8(L) wraz z peryfe-

riami jak na rys. 9 (jeśli do kon-

trolera jest podłączony rezonator

o innej częstotliwości (lub nie jest

podłączony żaden), zaprogramuj go

do pracy z wewnętrznym oscylato-

rem o częstotliwości 8 MHz).

3. Zainstalowany kompilator avr–gcc

najlepiej WinAVR 20040720,

4. Zainstalowany programator pozwa-

lający załadować kod wynikowy

do kontrolera ATmega8(L).

Posiadając powyższe składniki

możemy przystąpić do dzieła, jakim

jest napisania i uruchomienia pierw-

szej aplikacji dla systemu KaRTOS.

Uruchomimy trzy zadania:

– Task_1 – będzie wysyłało co 1

sekundę przez port szeregowy

ekran powitalny aplikacji – „Hel-

lo world tu KaRTOS !”. Parame-

try transmisji: 8N1,38400 (osiem

bitów danych, bez bitu parzysto-

ści, jeden bit stopu z prędkością

38,4 kbps),

– Task_2 – będzie zapalało na 1

sekundę i gasiło na 1 sekundę

diodę_1 podłączoną do pinu PC0

mikrokontrolera,

– Task_3 – będzie zapalało na

100 ms i gasiło na 400 ms dio-

dę_2 podłączoną do pinu PC1

mikrokontrolera.

rająca rozmiar stosu zadania (zde-

ﬁniowane w main.h ).

Konﬁgurowanie systemu

W katalogu Hello_world_tu_KaR-

TOS\KaRTOS\ATMega8\ znajduje się

plik KaRTOS.conf . W nim zawarte są

zmienne konﬁgurujące system opera-

cyjny. Plik jest podzielony na pięć

sekcji, z których edytować będziemy

pierwsze trzy:

1. Sekcja SWITCH ON/OFF KaR-

TOS MODULES – umożliwia włącze-

nie lub wyłączenie poszczególnych

modułów systemu do kompilacji. Do-

konujemy tego „komentując” (lub nie)

poszczególne zmienne kompilatora

za pomocą znaków „//”. Dla potrzeb

naszej pierwszej aplikacji wszystkie

moduły winny być wyłączone („zako-

mentowane”) z wyjątkiem modułu ob-

sługi portu szeregowego – KaRTOS_

UART_ON.

2. Sekcja HARDWARE SYSTEM

CONFIGURATION – w tej sekcji mo-

żemy ustawić takie parametry jak:

rozmiar stosu systemowego (w bajtach)

– SYS_STACK 20, podział pamięci

RAM na sekcje: pamięci zmiennych

globalnych oraz pamięci systemowej.

NO_TASKS_RAM_ADDR 620, (więcej

na ten temat w kolejnej części).

3. Sekcja KaRTOS_1MS_OCR_

WART – wartość rejestru OCR timera

systemowego zgłaszającego przerwanie

co 1 ms. Częstotliwość zegara tak-

tującego mikrokontroler jest dzielona

wstępnie przez 64. W naszym wypad-

ku ma wtedy wartość równą 8 [MHz]

/64=125 [kHz]. Zatem aby odmierzyć

1/1000 sekundy, w rejestrze OCR musi

się znajdować wartość 125. Dlatego:

KaRTOS_1MS_OCR_WART=125.

Zmienne

Zmienne zdeﬁniowane w sys-

temie KaRTOS przedstawiono

w tab. 2.

Konﬁguracja zadań

Otwórz plik main.h i upewnij

się, że parametry zadań TASK_1,

TASK_2 i TASK_3 są odpowiednio

skonﬁgurowane ( list. 1 ).

Uruchomienie zadań

Otwórz plik main.c i upewnij się,

że zadania Task_1, Task_2 i Task_3

zostaną utworzone i uruchomione

( list. 2 ). Funkcja void KaRTOSTaskInit(

void(*pMyfunction)(void), u08 Pid, u08

u08Prio, u16 u16StackSize) przyjmuje

następujące parametry:

– void(*pMyfunction)(void)

– wskaźnik do funkcji zawierają-

cej kod zadania – w naszym przy-

padku są to funkcje o nazwach

Task_1, Task_2 i Task_3,

– u08 Pid – 8–bitowa zmienna

zawierająca numer zadania (zdeﬁ-

niowane w main.h ),

– u08 u08Prio – 8–bitowa zmien-

na zawierająca priorytet zadania –

im mniejsza wartość, tym zadanie

ma wyższy priorytet (zdeﬁniowane

w main.h ),

– u16 u16StackSize – zmienna

o rozmiarze dwóch bajtów zawie-

Tab. 2. Zmienne zdeﬁniowane w sys-

temie KaRTOS

Typ zmiennej

w systemie

u08 zmienna 8–bitowa bez znaku

s08 zmienna 8–bitowa ze znakiem

u16 zmienna 16–bitowa bez znaku

s16 zmienna 16–bitowa ze znakiem

u32 zmienna 32–bitowa bez znaku

s32 zmienna 32–bitowa ze znakiem

Konﬁgurowanie pinów

kontrolera

W katalogu Hello_world_tu_KaR-

TOS\KaRTOS\ATMega8\ otwieramy

plik Initm8.c . Dokonujemy konﬁgu-

racji portów w zależności od tego,

do których nóżek mikrokontrolera

mamy podłączone diody. Jeśli na-

sza aplikacja ma działać w układzie

z rys. 9, dokonujemy konﬁguracji

PORTU C następująco: DDRC=0x03

oraz PORTC=0x03 (piny 0 i 1 portu

są wyjściami w stanie wysokim).

List. 1. Parametry zadań w pliku

main.h

#deﬁne TASK_1_PID 10

#deﬁne TASK_1_STACK 100

#deﬁne TASK_1_PRIORITY 10

#deﬁne TASK_2_PID 20

#deﬁne TASK_2_STACK 100

#deﬁne TASK_2_PRIORITY 20

#deﬁne TASK_2_PID 30

#deﬁne TASK_2_STACK 100

#deﬁne TASK_2_PRIORITY 30

Implementacja kodu zadań

Na list. 3 przedstawiono imple-

mentację zadania Task_1 realizujące-

go wysyłanie danych przez port sze-

regowy. Jako pierwsza wywoływana

jest funkcja systemowa KaRTOSUar-

List. 2. Wywołanie funkcji tworzącej zadania w pliku main.c

KaRTOSTaskInit(&(Task_1),TASK_1_PID,TASK_1_PRIORITY,TASK_1_STACK) ;

KaRTOSTaskInit(&Task_2,TASK_2_PID,TASK_2_PRIORITY,TASK_2_STACK) ;

KaRTOSTaskInit(&Task_3,TASK_3_PID,TASK_3_PRIORITY,TASK_3_STACK) ;

//KaRTOSTaskInit(&Task_4,TASK_4_PID,TASK_4_PRIORITY,TASK_4_STACK)

Elektronika Praktyczna 6/2008

107

Opis zmiennej

PROGRAMY

List. 3. Implementacja zadania Task_1

void Task_1(void)

{

KaRTOSUartInit(12,0) ; //–38400 bps dla 8, MHz

for(;;)

{

KaRTOSUartOpen() ;

KaRTOS_UART_PRINT(„\n\r*** Hello World tu KaRTOS !! ***”) ;

KaRTOSUartClose() ;

TimeSleepms(1000) ;

} ;

}

Rys. 11. Widok okna terminala z dzia-

łającą aplikacją

List. 4. Implementacja zadania

Task_2

void Task_2(void)

{

for(;;)

{

cbi(PORTC,0) ;

TimeSleepms(1000) ;

sbi(PORTC,0) ;

TimeSleepms(1000) ;

} ;

}

W naszym przypadku używa-

my zegara o częstotliwości 8 MHz,

a chcemy uzyskać prędkość transmisji

38,4 kb/s bez podwojenia prędkości

(u08doubleSpeed=0) . Wykonując

proste obliczenie podane w dokumen-

tacji mikrokontrolera lub korzystając

z gotowych tabelek również tam za-

wartych otrzymujemy wartość UBRR

równą 12 (u16Baudrate=12) .

Kolejnym krokiem w naszym za-

daniu ( list. 3 ) jest zaimplementowa-

nie nieskończonej pętli wysyłającej

co sekundę ciąg znaków. Funkcja

systemowa KaRTOSUartOpen otwiera

port szeregowy, KaRTOS_UART_PRINT

wysyła ciąg znaków będących jej ar-

gumentem i zawarty między znakami

cudzysłów, a KaRTOSUartClose zamy-

ka wcześniej otwarty port. Pozostaje

nam jeszcze zrealizować sekundowe

opóźnienie, do czego służy systemo-

wa funkcja TimeSleepms . Jako argu-

ment podajemy czas w milisekundach

– w naszym przypadku 1000 ms.

Zadania Task_2 i Task_3 będą mia-

ły podobną budowę ze względu na

realizację podobnych algorytmów –

różnią się jedynie czasami opóźnień.

Kod zadań przedstawiają odpowiednio

list. 4 i 5 . Po ustawieniu odpowied-

niego pinu w stan niski, co powo-

duje zapalenie podłączonej do niego

diody, należy zrealizować opóźnienie

o założonym czasie trwania. Ustawie-

nie pinu w stan wysoki powoduje, że

podłączona dioda gaśnie, a my znów

realizujemy opóźnienie o odpowiednim

czasie trwania. Realizując cyklicznie

w nieskończonej pętli powyższy al-

gorytm powodujemy mruganie diody

z zadanymi czasami świecenia i nie

świecenia.

Po dokonaniu wszystkich powyż-

szych czynności jesteśmy gotowi do

kompilacji kodu i zaprogramowania

kontrolera.

List. 5. Implementacja zadania

Task_3

void Task_3(void)

{

for(;;)

{

cbi(PORTC,1) ;

TimeSleepms(100) ;

sbi(PORTC,1) ;

TimeSleepms(400) ;

} ;

}

Kompilacja

Po rozpakowaniu archiwum Hel-

lo_world_tu_KaRTOS.zip na dysk c:\

możemy przystąpić do kompilacji.

W tym celu otwieramy wiersz pole-

ceń systemu windows i przechodzimy

do katalogu c:\Hello_world_tu_KaRTOS\ .

Po wydaniu polecenia make na kon-

soli powinny pojawić się komunikaty

świadczące o postępie kompilacji i po

chwili ekran powinien wyglądać jak

na rys. 10 . Oznacza to, że kompila-

cja przebiegła pomyślnie, a w katalogu

c:\Hello_world_tu_KaRTOS\ znajduje się

plik main.hex (i main.bin ), z kodem

wynikowym, który możemy załadować

do pamięci kontrolera.

tInit dokonująca inicjalizacji portu

USART mikrokontrolera. Deklaracja

wspomnianej funkcji ma następują-

cą postać: void KaRTOSUartInit(u16

u16Baudrate, u08 u08doubleSpeed).

Przyjmuje ona dwa parametry:

– u16Baudrate – wartość ta zo-

stanie przepisana do rejestru

UBRR, określa zatem prędkość

transmisji,

– u08doubleSpeed – włącza (jeśli

ma wartość 1) lub wyłącza (jeśli

wartość jest różna od 1) podwo-

jenie prędkości transmisji portu.

Aplikacja działa

Teraz wystarczy podłączyć sprzęt

(rys. 9) do komputera PC za pomo-

cą niekrosowanego kabla szeregowego

i uruchomić dowolną aplikację ter-

minala (np. TTermSSH). Następnie

ustawiamy parametry transmisji, jak

podano powyżej (8N1, 38400). Jeśli

połączenia są wykonane poprawnie,

to po podłączeniu zasilania do płyty

kontrolera zaobserwujemy mrugające

diody, a terminal zapełni się ekranem

powitalnym jak na rys. 11 .

Mariusz Żądło

iram@poczta.onet.pl

Rys. 10. Widok okna konsoli po pomyślnej kompilacji aplikacji demo

Autor zachęca Czytelników do kształtowania tre-

ści kolejnych odcinków cyklu. Napisz w e–mailu

czy bardziej interesuje Cię teoria działania, czy

raczej wolisz aby prezentowane były przykła-

dowe aplikacje i projekty dla systemu KaRTOS.

Inne uwagi również mile widziane.

108

Elektronika Praktyczna 6/2008

KARTOS - 8–bitowe jądro czasu rzeczywistego, część 2.pdf

Plik z chomika:

Inne pliki z tego folderu:

Inne foldery tego chomika: