<--  | Ana Sayfa  | Eri�imd�zeni  | ��indekiler  | Arama

Ismael Ripoll <iripoll/at/disca.upv.es> Yazar hakk�nda: Ph.D'sini Valencia'daki Polytechnic Universitesinde 1996 'da yapti. DISCA b�l�m�nde i�letim sistemleri profes�r�d�r. Ger�ek zaman progrmlamas� ve i�letim sistemleri ilgisini ceken ara�t�rma konular� aras�nda yer almaktad�r. 1994 y�l�ndan beri Linux kullan�c�s�d�r. Hobileri: Pyrennes da�lar�nda y�r�y�� yapmak, kaymak ve ev elektroni�idir. T�rk�e'ye �eviri: Berfin Kalay <berfinkalay(at)hotmail.com> ��erik: KU Ger�ek Zamanl� Linux (KURT) Ger�ek Zaman Nerede Kullan�l�r? Y�klenebilir Mod�ller �lk Ger�ek Zamanl� Program�m�z G�revler Aras� �leti�im Sonu� References:

Ger�ek zamanl� Linux : 2. B�l�m �zet: Ger�ek zaman Linux hakk�ndaki bu ikinci yaz�mda, ger�ek zaman Linux'u daha �ok kullan�� y�n�nden ele alaca��m. Ancak, konunun ayr�nt�lar�na girmeden �nce, yeni ��kan ve ger�ek zamanl� bir i�letim sistemi olan Linux KURT hakk�nda k�saca de�inmek istiyorum. _________________ _________________ _________________

KU Ger�ek Zamanl� Linux (KURT)

1998 ba�lar�nda da��t�m� ba�lanan Linux �zerine kurulu KURT,yumu�ak bir ger�ek zamanl� i�letim sistemidir.�rnek vermek gerekirse;�izelgeleyici istenilen program y�r�tme zamanlar�n� sa�lamaya �al���rken,herhangi bir g�revin zaman�ndan �nce sonlanmas� ger�ek bir trajediye sebep olmaz.RT-Linux g�revlerinin aksine KURT ger�ek zamanl� g�revleri,Linux'un faydalar�n�n avantaj�n� ta��yabilirler.�ekirde�e yap�lan ilaveler ve de�i�iklikler ��yledir:

• Sistem saati ��z�n�rl��� geli�tirilmi�tir.Linux-i386 da,sistem saatinin i� kesme frekans� 10 ms dir ve �ekirde�in kontrol kararlar� alarak zaman� �l�t��� bu zaman ��z�n�rl���n� kullan�r.Zaman� kontrol etmede KURT da ayn� mekanizmay� kullan�r.Periodiklik yerine istem �zerinde i� kesme i�areti olu�turan zaman �ipini (8254) programlar.B�ylelikle,mikrosaniyeler hassasl���ndaki zaman ��z�n�rl���ne ula��labilir.
• Linux �ekirde�i taraf�ndan y�r�t�lmeye ba�lanan ve POSIX taraf�ndan tan�mlanm�� olan SCHED_FIFO,SCHED_RR,SCHED_OTHER d���nda,�izelgeleyici yeni �izelgeleme kurallar�(SCHED_KURT) i�erecek bi�imde yeniden yap�land�r�lm��t�r.
• Yeni ger�ek zaman i�levselli�inin avantaj�na sahip olmak i�in yeni sistem �a�r�lar� eklenmi�tir.

Ger�ek zaman g�revleri dinamik olarak y�klenmi� mod�llerdir.

KURT'un en karakteristik �zelliklerinden birisi sahip oldu�u "�izelgeleme kurallar�"d�r.Bir �evrimsel �izelge y�r�t�lmesi i�in bir karar al�n�r.Bu t�r �izelgeler,i�lem zaman�,y�r�tme g�revi, g�rev s�resi vb. gibi zamana g�re programlanm�� t�m eylemleri i�eren,plan olarak adland�r�lm�� bir tablo kullan�rlar.Bu tablo,sistemin tasar�m a�amas�nda olu�turulur.Daha sonra,�al��ma s�resi boyunca, �izelgeleyicinin tek g�revi tabloyu okuyup,talimatlar� takip etmektir.Tablonun sonuna ula��ld���nda �izelgeleyici ba�a d�ner ve g�revleri yerine getirme i�ini tamamlar.Bu tip �izelgenin pek �ok avantajlar� vard�r:

• Y�r�t�lmesi kolayd�r

• Etkilidir.

• Bir plan olu�turulduktan sonra sistemin fizibilitesi h�zl� bir �ekilde belirlenir.

As�l zorluk plan�n kendisini olu�turmakt�r.Bundan ba�ka g�rev paremetrelerinden herhangi biri yeniden d�zenlendi�inde plan�n yeniden olu�turulmas� gerekir.Ayr�ca haf�zada �ok yer kaplar.

Ger�ek Zaman Nerede Kullan�l�r?

Belki bir�oklar� ger�ek zaman tekniklerinin yaln�zca NASAda veya f�zelerde kullan�ld���n� d���n�yorlar.Birka� y�l �ncesine kadar bu d���nce yanl�� say�lmazd�,ancak g�n�m�zde durum olduk�a de�i�mi�tir ve bili�im sistemlerinin,elektroni�in g�nl�k ya�amda kullan�m�ndaki art��a paralel olarak h�zla de�i�mektedir.Ger�ek zamanl� uygulamalar g�nl�k hayat�m�zda telekom�n�kasyon ve multimedya alanlar�nda yer al�r.�rne�in bilgisayar�m�z�n hard diskinde kay�tl� bir ses dosyas�n� �almas�n� istedi�imizde,bir program�n s�rekli olarak dosyay� okumas�,a�mas� ve verileri ses kart�na g�ndermesi gerekir.E�er ayn� anda ba�ka bir uygulama �al���r durumda ise,i�lemci bu di�er g�revleri y�r�t�rken seste periodik kesilmeler olu�ur.�rne�in e�er m�zik dinlemek yerine sistemimize video kayd� yap�yorsak;sonu� ara ara donan g�r�nt�ye e�lik eden ve g�r�nt�yle e�zamanl� olmayan seslendirme olur.Bu tip sistemler soft Real-Time olarak bilinir.

RT-Linux uygulamalar� normal ger�ek zaman uygulamalar�n�n �tesindedir.RT-Linux ile MSDOS da oldu�u gibi PC nin t�m kontrol� elimizdedir( PC diyorum,��nk� hen�z RT-Linux'un ba�ka herhangi bir yap�da uygulamas� yok.)Bir ger�ek zamanl� g�rev boyunca,PCnin t�m portlar�na ula��m m�mk�nd�r.

Y�klenebilir Mod�ller

RT-Linux'u anlamak ve kullanabilmek i�in Linux'un dinamik olarak y�klenebilir mod�llerini bilmek gerekir.Matt Welsh mod�lleri i�eren her s�r�m hakk�nda detayl� anlat�m� olan bir makale yazm��t�r.

Mod�ller Nedir?

Pek �ok UNIX uygulamas�nda, donan�ma eri�im i�in tek yol baz� �zel dosyalardan ve donan�m par�alar�n�n s�r�c�lerinin kurulu olmas�ndan ge�er.Par�a s�r�c�lerinin nas�l yaz�laca��n� anlatan pek �ok kitap bulunsa da,sisteme s�r�c�y� dahil etmek i�in yaz�lmas� gereken n�merik fonksiyonlar dolay�s�yla,bu uzun ve b�y�k oranda s�k�c� bir i�tir.

Mod�ller�al��ma zaman� i�inde eklenebilen ve ��kart�labilen "i�letim sistemi par�alar�d�r" Pek �ok kaynak dosyan�n derlenmesiyle bir program olu�turmada �nce her dosya ayr� ayr� derlenerek obje dosyas�na d�n��t�r�l�r,daha sonra t�m bu dosyalar �al��t�r�labilir tek bir dosya olu�turmak i�in birle�tirilir. main fonksiyonunu i�eren obje dosyas�n�n �al��abilir oldu�unu ve i�letim sisteminin geri kalan obje dosyalar�n� haf�zada tutabildi�ini ve yaln�zca gerekli oldu�unda biraraya getirdi�ini farzedelim.Kernel(�ekirdek) bunu tekba��na yapabilir.Linux �al��t�r�ld���nda,yaln�zca �al��t�r�labilir vmlinuz haf�zaya y�klenir.��eri�inde gerekli kernelin elemanlar� vard�r,daha sonra �al��ma s�resince mod�l�n herhangi bir ihtiyac�n� se�erek y�kleyebilir.

Mod�ller,�ekirde�in derlenmesi s�ras�nda �a��r�lmas� gereken,Linux �ekirde�indeki opsiyonel �zelliklerdir.Bildi�im t�m Linux da��t�mlar�n�n �ekirdekleri, mod�l opsiyonlar� aktif olarak derlenir.

Ayr�ca sistemi yeniden derlemeye veya yeniden �al��t�rmaya gerek olmaks�z�n yeni mod�ller olu�turmak ve y�klemek m�mk�nd�r.

Bir mod�l y�klendi�inde,i�letim sisteminin bir par�as�n� olu�turur:

• B�t�n fonksiyonlar� kullanabilir,b�t�n de�i�kenlere ve �ekirdek yap�lar�na eri�ebilir.

• Mod�l kodu i�lemcinin en �st �ncelik seviyesi ile �al���r.i386 yap�s�nda,t�m giri�-��k�� eri�im tiplerine sahip olabilmesinin ve �zel komutlar� �al��t�rabilmesinin bir sonucu olarak "ring level 0" seviyesinde �al��t�r�l�r.

• Hem program hem de veri i�in sayfalama yapman�n m�mk�n olmad��� fiziksel haf�za kullan�l�r.B�ylelikle mod�l�n �al��ma s�resince bir sayfa hatas� olu�maz.

G�rd���m�z gibi,dinamik olarak y�klenmi� bir mod�l bir ger�ek zamanl� program�n baz� �zelliklerine sahiptir:Sayfa hatalar� sonucu olu�an gecikmeleri �nler ve t�m donan�m kaynaklar�na eri�imi vard�r.

Onlar� Nas�l Olu�turmal� ve Kullanmal�?

Bir mod�l C kodlar�yla yap�land�r�l�r.A�a��da �ok k���k bir mod�l �rne�i g�r�lmektedir(A�a��daki komutlar� icra edebilmek i�in �st kullan�c�(s�per user) olmak gerekir):

example1.c

  #define MODULE
  #include <linux/module.h>
  #include <linux/cons.h>
  static int output=1;

  int init_module(void) {
    printk("Output= %d\n",output);
    return 0;
  }
  void cleanup_module(void){
    printk("Adiós, Bye, Chao, Ovuar, \n");
  }

Derlemek i�in �u parametreler kullan�l�r:

-c opsiyonu gcc ye obje dosyas�n� olu�turduktan sonra durmas�n� ve ba�lant� safhas�n� atlamas�n� s�yler.Sonu� example1.o �eklinde isimlendirilmi� bir dosyad�r.

�ekirdek standart ��k��tan yoksundur,dolay�s�yla printf() fonksiyonunu kullanamay�z.Bunun yerine,printf gibi �al��an,fark olarak ��kt�y� �ekirde�in tamponuna g�nderen printk()fonksiyonu vard�r.Bu �ekirdek tampon belle�inde sistem kapan�rken olu�an mesajlar saklan�r ki bu mesajlar sistem �al��t�r�ld���nda g�rd���m�z mesajlard�r.�stedi�imiz an tamponun i�eri�ini g�r�nt�leyebiliriz,bunun i�in dmseg komutunu kullanabilir veya do�rudan /prog/kmsg dosyas�na g�z atabiliriz.

Burada main() fonksiyonunun bulunmad���na, yerine hi� bir parametresi bulunmayan init_module() fonksiyonunu bulaca��m�za dikkat edelim. cleanup_module bir mod�l� bo�latmadan �nce �a��rd���m�z son fonksiyondur. Mod�l y�klemesi insmod komutu ile ger�ekle�ir.

  # insmod example1.o

Bu �ekilde example1 mod�l�n� kurduk ve init_module() fonksiyonunu �al��t�rd�k. Sonu�lar� g�rmek i�in �u komutu girin:

  # dmesg | tail -1
  Output= 1

lsmod komutu �ekirdekte elektriksel olarak y�kl� mod�lleri listeler:

# lsmod
Module    Pages   Used by:
example1      1          0
sb            6          1
uart401       2  [sb]    1
sound        16  [sb uart401]  0 (autoclean)

Ve bir mod�l� silmek i�in rmmod komutunu kullan�r�z.

  # rmmod example1
  # dmesg | tail -2
  Output= 1
  Adiós, Bye, Chao, Orvua,

dmesg komutunun ��kt�s� bize cleanup_module()fonksiyonunu �al��t���n� g�sterir. ;

Tek bilmemiz gereken bir mod�le paametreleri nas�l aayaca��m�zd�r. Bundan �a��r�c� d�zeyde kolay olan ba�ka bir �ey yoktur. �rne�in:

  # insmod ejemplo1.o output=4
  # dmesg | tail -3
  Output= 1
  Adíos, Bye, Chao, Orvua,
  Output= 4

�imdi mod�llerle ilgili bilmemiz gereken her �eyi biliyoruz.Ger�ek Zamanl� Linux'a geri d�nelim.

�lk Ger�ek Zamanl� Program�m�z

�ncelikle hat�rlamam�z gereken,RT-Linux'u kullanmak i�in,Linux �ekirde�ini Ger�ek Zamanl� mod�lleri destekleyecek �ekilde haz�rlam�� olmam�zd�r. bir �nceki makalede bu i�lemi anlatm��t�k.

RT-Linux kullan�m� i�in iki yol vard�r:

1. Belirlenmi� �ncelikler �zerine kurulu bir �izelgeleyiciye sahip klasik bir Ger�ek ZamanSistemi olarak.

2. DOS kullan�m�na yak�n bir kullan�m olarak.

�imdi,RT-Linux'u sabit �ncelikli bir sistem olarak nas�l kullanmak gerekti�i �zerinde duraca��m.Birazdan g�rece�imiz �rnek i�e yarar bir�ey yapmamakta,yaln�zca bir ger�ek zaman g�revini ayarlamaktad�r:

  #define MODULE
  #include <linux/module.h>
  #include <linux/kernel.h>
  #include <linux/version.h>
  #include <linux/rt_sched.h>
  RT_TASK task;

  void fun(int computo) {
    int loop,x,limit;
    limit = 10;
    while(1){
      for (loop=0; loop<computo; loop++)
        for (x=1; x<limit; x++);

      rt_task_wait();
    }
  }

  int init_module(void) {

    RTIME now = rt_get_time();

    rt_task_init(&task,fun, 50 , 3000, 1);
    rt_task_make_periodic(&task,
          now+(RTIME)(RT_TICKS_PER_SEC*4000)/1000000,
     (RTIME)(RT_TICKS_PER_SEC * 100)/1000000);
    return 0;
  }

  void cleanup_module(void){
    rt_task_delete(&task);
  }

Bir kere daha bu �rne�i a�a��daki komutla derleyelim:

Program bir mod�l oldu�undan,giri� noktas� init_module()fonksiyonudur.�lk yapt��� ak�m zaman�n� okumak ve lokal bir de�i�kene atamakt�r;rt_get_time() fonksiyonu y�klenme zaman�ndan beri ge�en zamanda RT_TICKS_PER_SEC de�erini d�nd�r�r. rt_task_init()ile'g�rev' yap�land�r�l�r ama hen�z ba�lat�lmaz.Son olarak olu�turulmu� g�revin ana program� fun(), ikinci paremetredir.Onu takip eden paremetre �al��t�r�lmas� s�ras�nda yeni g�reve atanacak olan veri de�eridir.Dikkat edilmesi gereken nokta fun() fonksiyonunun int paremetre kulland���d�r.Bir sonraki paremetre g�rev y���n�n�n boyutudur.Her g�rev kendi y�r�t�m izle�ine sahip oldu�undan,her biri kendisine ait y���na ihtiya� duyar.Son paremetre �ncelik parametresidir.B�ylelikle,sistemde tek bir g�revle,istedi�imiz de�eri ayarlayabiliriz.

rt_task_make_periodic() komutu g�revi periyodik bir g�reve d�n��t�r�r.Bu durumda g�rev iki zaman de�erine sahip olur,ilki g�revin ilk olarak etkinle�tirilece�i mutlak zamandaki and�r,di�eri aktivasyonlar aras�ndaki periyottur.

Ger�ek zamanl� g�rev(fun() fonksiyonu ),yaln�zca iki i�lem i�eren i�eren sonsuz bir d�ng�d�r:sadece zaman harcar ve sonra rt_task_wait() fonksiyonunu �a��ran bir d�ng�..rt_task_wait,kendisini bir sonraki aktivasyon zaman�na kadar �a��ran g�revin y�r�t�lmesini ge�ici olarak durduran bir fonksiyondur.Program rt_task_wait sat�r�ndan hemen sonra �al��maya devam eder.Okuyucu �unu iyi anlamal�d�r ki g�rev her aktivasyon zaman�nda �al��maya en ba�tan ba�lamaz,bunun yerine g�rev,�al��mas�n� kendi kendine ge�ici olarak durdurmal� ve bir sonraki aktivasyonu beklemelidir.Bu da ilk �a��r�ld���nda yaln�zca birka� ba�lat�m y�r�t�len bir g�rev yazmay� olanakl� k�lar.

example2 yi �al��t�rmak i�in,rt_prio_sched mod�l�n� kurmal�y�z,��nk� program�m�z� rt_task_make_periodic(), rt_task_delete() ve rt_task_init() fonksiyonlar�na ihtiyac� var. rt_get_time() fonksiyonu mod�lde bulunmaz fakat Linux �ekirde�inde yerle�iktir ve bu y�zden bu fonksiyonu kurmam�za gerek yoktur.

  # modprobe rt_prio_sched
  # insmod ./example2.o

Verilmi� rt_prio_sched bir sistem mod�l�d�r.Linux �ekirde�inin derlenmesi s�ras�nda yarat�l�r ve /var/modules/2.0.33/ dizinine kopyalan�r.Mod�lleri y�klemede daha kolay bir ara� oldu�undan,modprobe komutunu kullan�r�z.

E�er her �ey yolunda gittiyse,lsmod komutu ile her iki mod�l�n de do�ru bi�imde y�klendi�ini g�rece�iz.

Bu noktada okuyucu �al��an bir ger�ek zamanl� programa sahiptir.�zel herhangi bir�ey dikkatinizi �ekiyor mu?��lemci biraz yava� ise, okuyucu Linux'un herzamankinden daha yava� �al��t���n� farkedecektir.fun() fonksiyonunun i� d�ng�s�ndeki iterasyon say�s�n� artt�rmay� deneyebilirsiniz.Bunun i�in rt_task_init fonksiyonundaki ���nc� parametreyi de�i�tirmelisiniz.Size ico program�n� �al��t�rarak ne kadar az i�lemci zaman� kald���n� de�erlendirmenizi tavsiye ederim.��nk� Ger�ek Zamanl� programlar taraf�ndan kullan�lan zaman i�lemciyi d���k h�zda �al���yormu� gibi etkiler.Linux b�t�n i�lemlerini ayn� �ekilde i�lemesi i�in daha fazla zamana ihtiyac� oldu�una inan�r.E�er hesap zaman� 100 mikrosaniyeden fazlaysa Linux "kitlenecektir",��nk� Linux arka plan g�revidir ve ger�ek g�rev zaman�n tamam�n� almaktad�r.Asl�nda Linux kitlenmez sadece i�lemci zaman� yoktur.

G�revler Aras� �leti�im

RT-Linux tlt�nda ileti�im i�in tek bir yol vard�r: Real-Time FIFO.�al��ma �ekli UNIX PIPE lar�n�nkine �ok benzer. Unix PIPElar� yap�s� olmayan veri ak�m�yla sa�lanan bir ileti�imdir. .FIFO yazma ve okuma operasyonlar�n�n y�r�t�ld��� sabit b�y�kl�kte bir arabellektir.

FIFOS kullanarak ger�ek zamazl� g�revler aras�nda ve normal Linux g�revleri aras�nda inter-haberle�me kurmak m�mk�nd�r.

Bir Normal ��lem Bak�m�ndan r �zel karakter dosyas�d�r.Normal olarak Linux'un i�ermedi�i /dev/rtf0, /dev/rtfl,vs. dosyalar� olarak bulunduklar�ndan a�a��daki �ekilde yarat�lmalar� gerekir:

e�er daha fazla FIFO dosyas�na ihtiya� varsa ayn� rtf4,rtf5,.. prosed�r� kullan�larak kolayl�kla yarat�labilirler.�zel dosyalar i�letim sistemindeki bir i�leyiciye aray�z gibi davran�rlar,e�er i�leyici bulunmuyorsa bu �zel dosyalar�n bir kullan�m alan� yoktur.Nitekim ili�kilendirilmi� i�leyicinin yoklu�unda bu dosyalardan herhangibirini a�mak m�mk�n de�ildir.

FIFOlar normal dosyalar gibi kullan�l�rlar(open, read/write, close).Bir normal Linux i�leminin bo dosyalar� kullanabilmesi i�in �ncelikle bir ger�ek zamanl� program�n uygun FIFOyu yaratmas� gerekir.

Bir ger�ek zamanl� g�rev bak�m�ndan, FIFOlar �zel fonksiyonlar arac�l���yla kullan�l�rlar:

• rt_create(unsigned int fifo, int sise):size boyutunda bir arabellek ile bir FIFO yarat�r.Bu andan yokedilme an�na kadar /dev/rtf[fifo] taraf�ndan kabul edilen s�r�c� kullan�labilir.

• rt_destroy(unsigned int fifo):Uygun FIFO yokedilir ve haf�zas� geri kazan�l�r.

• rt_fifo_put(fifo, char *buf, int count): countbitlerini buf arabelle�inden yazmay� dener.FIFOnun arabelle�inde yeterli yer yoksa geri d�ner.

• rt_fifo_get(fifo, char *buf, count): count baytlar�n� FIFOdan okumay� dener.

�imdi bu fonksiyonlar� kullanan bir �rnek g�relim.Bu �rnek RT-Linux da��t�m�nda yer alan �rneklerin k���k bir modifikasyonudur:

  #define MODULE
  #�nclude <linux/module.h>
  #include <linux/rt_sched.h>

  #include <linux/rtf.h>
  #include <asm/io.h>

  RT_TASK task;

  static int filter(int x){
    static int oldx;
    int ret;
    if (x & 0x80) {
      x = 382 - x;
    }
    ret = x > oldx;
    oldx = x;
    return ret;
  }

  void fun(int dummy) {
    char data;
    char temp;
    while (1) {
      if (rtf_get(0, &data, 1) >  0) {
        data = filter(data);
        temp = inb(0x61);
        temp &= 0xfd;
        temp |= (data & 1) <<  1;
        outb(temp,0x61);
      }
      rt_task_wait();
    }
  }

  int init_module(void){
    rtf_create(0, 4000);

    /* enable counter 2 */
    outb_p(inb_p(0x61)|3, 0x61);

    /* to ensure  that the output of the counter is 1 */
    outb_p(0xb0, 0x43);
    outb_p(3, 0x42);
    outb_p(00, 0x42);

    rt_task_init(&task, fun,  0 , 3000, 1);
    rt_task_make_periodic(&task,
                   (RTIME)rt_get_time()+(RTIME)1000LL,
                   (RTIME)(RT_TICKS_PER_SEC / 8192LL));

    return 0;
  }

  void cleanup_module(void){
    rt_task_delete(&task);
    rtf_destroy(0);
  }

�kinci �rnekte ,rt_prio_sched mod�l�n�n hizmetlerini istemi�tik, bu defa FIFO nunkileri kullanmak i�in rt_fifo_new y�klemeliyiz.

8192 Hz frekans�nda bir periyodik ger�ek zamanl� g�rev yarat�l�r ve bu g�rev FIFO 0 dan baytlar� okur.E�er bir�ey bulursa PCnin giri�ine g�nderir.Bir ses dosyas�n�, /dev/rtf0 �zerine ".au" format�nda kopyalad���m�z takdirde dinleyebiliriz.PC donan�m�n�n sinyali mod�le etmek i�in yaln�zca 1 bayt kullan�m�na izin vermesinin bir sonucu olarak ses kalitesinin berbat olaca��n� s�ylemeye gerek yok.Da��t�m�ntesting/sound dizini,testler i�in kullan�lanlinux.au dosyas�n� i�erir.

Bu dosyay� derlemek ve �al��t�rmak i�in :

�zel dosyalar dahil herhangi bir dosyan�n �zerine yazmak i�in cat arac�n�n nas�l kullan�laca��na dikkat edin.Burada cp komutunu da kullanabilirdik.

Ger�ek zaman �zelliklerinin r�prodiksiyon kalitesini nas�l etkiledi�ini k�yaslayabilmek i�in, ayn� operasyonu y�r�ten fakat normal bir Linux kullan�c� i�leminden y�r�ten bir program yazmal�y�z.

  #include <unistd.h>
  #include <asm/io.h>
  #include <time.h>

  static int filter(int x){
    static int oldx;
    int ret;
    if (x & 0x80)
      x = 382 - x;
    ret = x > oldx;
    oldx = x;
    return ret;
  }
  espera(int x){
    int v;
    for (v=0; v<x; v++);
  }
  void fun() {
    char data;
    char temp;

    while (1) {
      if (read(0, &data, 1) >  0) {
        data = filter(data);
        temp = inb(0x61);
        temp &= 0xfd;
        temp |= (data & 1) << 1;
        outb(temp,0x61);
      }
      espera(3000);
    }
  }

  int main(void){
    unsigned char dummy,x;
    ioperm(0x42, 0x3,1); ioperm(0x61, 0x1,1);

    dummy= inb(0x61);espera(10);
    outb(dummy|3, 0x61);

    outb(0xb0, 0x43);espera(10);

    outb(3, 0x42);espera(10);
    outb(00, 0x42);

    fun();
  }

Bu program herhangi normal program gibi derlenebilir:

  # gcc -O2 example4.c -o  example4

Ve �al��t�rmak i�in:

  # cat linux.au | example4

Normal bir Linux program�ndan bilgisayar�n donan�m giri�lerine eri�im i�in,i�letim sistemine izin �a�r�s�nda bulunmal�y�z.Bu hard diske direkt program eri�imini �nlemek i�in gerekli ve basit bir koruma �l��t�d�r.ioperm �a�r�s� ,i�letim sistemine ,verilmi� bir giri�-��k�� adresleri s�ras�na eri�mek istedi�imizi s�yler.Sadece root ayr�cal��� ile �al��an programlar b�yle bir izni alabilirler.Not etmeye de�er bir detay, sesi mod�le eden 8192Hz frekans�n�n nas�l olu�turuldu�udur.nanodelay isimli milisaniyelik ��z�n�rl��e sahip bir sistem �a�r�s�n�nvarl���na ra�men, bekleme d�ng�s� kullanan ge�ici bir saat kullanmal�y�z. D�ng�, a�a�� yukar�, 100Mhz lik pentium �zerinde �al��acak �ekilde ayarlanmal�d�r.

�imdi okuyucunun example4'� ico program�yla test etmesini istiyorum. �imdi kula��n�za nas�l geliyor?. Ger�ek zamanl� ile fark� hissedebiliyormusunuz?Ger�ek zaman bir �eye de�di mi?

Sonu�

Bu ikinci makale ger�ek zamanl� uygulamalar�n programlama detaylar� �zerine konsantre olmu�ur. �rnekler �ok basit ve prtaik kullan�mdan uzakt�r. �n�m�zdeki makalede daha kullan��l� bir uygulama verece�im. Tv'nizi linux ile kontrol edebileceksiniz hatta daha da �tesi linuxunuzu uzaktan kumanda ile kontrol edeceksiniz.  

References:

• "Online KURT" B. Srinivasan. http://hegel.ittc.ukans.edu/projects/kurt
• "A Linux-based Real-Time Operating System" by Michael Barabanov. Master of Science, New Mexico Institute of Mining and Technology.
• "Linux as an Embedded Operating System" by Jerry Epplin http://www.embedded.com/97/fe39710.htm
• "Implementing Loadable Kernel Modules for Linux" by Matt Welsh http://www.ddj.com/ddj/1995/1995.05/welsh.html
• "Linux Kernel Internals" by M. Beck, H. Böhme, M. Dziadzka, U. Kunitz, R. Magnus, D. Verworner. Ed: Addison-Wesley.
• "Programación Linux 2.0, API de sistema y funcionamiento del núcleo" by Rémy Card, Eric Dumas y Franck Mével. (Originally written in French and translated to Spanish). Ed: Eyrolles, Ediciones Gestión 2000.
• "On Satisfying Timing Constrains in Hard-Real-Time Systems" by J. Xu & L. Parmas. IEEE Trans. on Software Engineering. Jan 1993

2004-11-23, generated by lfparser version 2.50