a sa�da do dmesg nos mostra que executamos a fun��o cleanup_module().

S� nos falta saber como podemos passar par�metros a um m�dulo. N�o h� nada mais f�cil e surpreendente. Podemos atribuir valores �s vari�veis globais, como s�mente escrever a atribui��o como par�metro de insmod. Por exemplo :

# insmod exemplo1.o output=4

# dmesg | tail -3

Output= 1

Adios, By, Chao, Orvua,

Output= 4

agora j� sabemos todo o necess�rio sobre m�todos, voltemos ao RT-Linux.

O programa de Tempo Real

Lembre,o-nos que para poder utilizar RT-Linux, primeiro tivemos que preparar o n�cleo do Linux para suportar os m�dulos de tempo real, opera��o que explicamos no primeiro n�mero da s�rie [refer�ncia a ele].

Podemos utilizar RT-Linux de duas formas distintas :

1. Como um sistema classico de tempo real com um planificador baseado em prioridades fixas.

2. Como um PC simples [bare], algo parecido com o que podemos fazer no DOS: capturar as interrup��es e ter o controle total do computador.

Neste artigo s� explicarei como utilizar RT-Linux como um sistema com prioridades fixas. O exemplo que vamos ver n�o faz nada "�til", t�o s�mente p�e em marcha (inicia) uma tarefa de tempo real, que � um simples caracol :

================== exemplo2 ==================

#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 bucle,x,limite;

limite = 10;

while(1){

for (bucle=0; bucle<computo; bucle++)

for (x=1; x<limite; 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);

}

Para compil�-lo, utilizaremos o seguinte comando :

# gcc -I /usr/src/linux/include/linux -O2 -Wall -D__KERNEL__ -D__RT__ -c exemplo2.c

J� que este programa � um m�dulo, o ponto de entrada � a fun��o init_module(). O que ele faz primeiro � ler o instante de tempo atual e o guarda em uma vari�vel local; a fun��o rt_get_time() devolve o n�mero de RT_TICKS_PER_SEC transcorridos desde o momento que se inicializou o computador (que na atual implementa��o RT_TICKS_PER_SEC vale 1.193.180, o que d� uma resolu��o de 0.838 micro-segundos). com rt_task_init() inicializamos a estrutura task sem por em marcha a tarefa. O programa principal da tarefa rec�m criada � � fun(), o segundo par�metro � o valor do dado que se passou a nova tarefa quando come�ar sua execu��o, observe que fun() espera um par�metro do tipo int. O par�metro seguinte � o tamanho da pilha da tarefa, j� que cada tarefa tem uma fila de execu��o pr�pria, necessita uma fila pr�pria. O �ltimo par�metro � a prioridade neste caso, como uma s� tarefa no sistema, e podemos por qualquer valor de prioridade.

rt_task_make_periodic() converte a tarefa task em uma tarefa peri�dica. O primeiro tempo � o instante de tempo absoluto em que se ativar� pela primeira vez e o seguinte par�metro indica o per�odo entre ativa��es sucessivas a partir da primeira.

A tarefa de tempo real (fun��o fun()), � um loop infinito, dentro do qual existem duas a��es: um loop que s� serve para gastar o tempo, e logo chama rt_task_wait(). rt_task_wait(), � uma fun��o que suspende a execu��o da tarefa que a chama at� a pr�xima ativa��o, momento e que ele continuar� a execu��o com a seguinte instru��o, depois de rt_task_wait(). Observe que uma tarefa peri�dica n�o � executada desde o princ�pio de cada ativa��o, sim que a pr�pria tarefa tem que paralizar-se (quando finalizou seu trabalho) e esperar a pr�xima ativa��o. Desta forma podemos programar uma tarefa para que s�mente na primeira ativa��o realize certos trabalhos de inicializa��o.

Para poder por o exemplo2 em execu��o, temos que instalar primeiro o m�dulo rt_prio_sched, pois necessitamos das fun��es rt_task_make_periodic(), rt_task_delete() e rt_task_init(). A fun��o rt_get_time() n�o est� dentro do n�cleo, e portanto n�o temos que instalar nada para poder utiliz�-lo.

# modprobe rt_prio_sched

# insmod ./exemplo2.o

J� que rt_prio_sched � um m�dulo do sistema, o criamos quando compilamos o n�cleo do Linux, e foi copiado para o diret�rio /var/modules/2.0.33/, podemos utilizar o comando modprobe, que � simplesmente uma forma mais f�cil de carregar m�dulos (� capaz de procurar o m�dulo pedido em v�rios diret�rios. Ver modprobe(1).

Se tudo foi bem, com o comando lsmod podemos ver que os dois m�dulos foram carregados corretamente.

Bem, pois j� temos uma tarefa de tempo real em andamento; Notas algo? Se o processador est� um pouco lento, possivelmente notar� que Linux est� um pouco diferente do normal. Podes aumentar o n�mero de intera��es do loop de fun(), variando o terceiro par�metro de rt_task_init(). Uma forma de apreciar que Linux utiliza menos tempo de processador com o programa ico, pois o tempo empregado para as tarefas de rempo real �, sobre todos os efeitos, como se o processador funcionasse mais limpo. Linux imagina que todos os seus processos precisam de mais tempo para fazer o mesmo. Se o tempo de computa��o (tempo necess�rio para executar todas as intera��es do loop) da tarefa � superior a 100 microsegundos, ent�o Linux suspender� suas atividades, pois a tarefa em background, e a tarefa de tempo real comsomem 100% do tempo. Realmente, Linux N�O suspendeu suas atividades, simplesmente n�o tem tempo de processador.

Comunica��es entre tarefas

No RT-Linux, s� h� uma forma de comunica��es: Real-Time FIFO. O funcionamento � muito similar ao que acontece em PIPE's do Unix, a comunica��o � por fluxo de dados sem estrutura. Uma FIFO � um buffer de bytes de tamanho fixo, que podemos fazer opera��es de leitura e escrita.

Com os FIFOS, podemos comunicar tanto tarefas em tempo real entre s�, como tarefas em tempo real com processos Linux normais.

# for i in 0 1 2 3; do mknod /dev/rtf$i c 63 $i; done

Desde o ponto de vista de um processo Linux normal uma FIFO � um arquivo especial de caracteres. Normalmente estar� no diret�rio /dev/rtf0, dev/rtf1, etc. Estes arquivos n�o existem no Linux, portanto temos que cri�-los. Podemos fazer da seguinte forma:

Se precisamos de mais FIFOs, s� temos que cri�-los rtf4, rtf5 etc. Os arquivos especiais s�o a interface de acesso a um manobrador do sistema operacional, mas se o manipulador n�o existe, ent�o de nada serve o arquivo especial, isto feito, tentar abrir um arquivo especial do qual o sistema operacional n�o tem o manipulador associado, falhar�.

A partir do ponto de vista de uma tarefa em tempo real, os FIFOs s�o utilizados mediante fun��es espec�ficas:

• rt_create(unsigned int fifo, int size): cria um FIFO com um buffer de tamanho size. A partir deste momento, e at� que se destrua, o dispositivo acessado desde /dev/rtf[fifo] existe e pode ser utilizado.

• rt_destroy(unsifned int fifo): destroi o FIFO e libera mem�ria.

• rt_fifo_put(fifo, char *buf, int count): tenta escrever count bytes do buffer buf. Se n�o h� bastante espa�o no buffer do FIFO, retorna -1.

• rt_fifo_get(fifo, char *buf, count): tenta ler count bytes a partir do FIFO, se n�o h� bastante dados dispon�veis retorna -1.

Vejamos agora um exemplo de sistema que faz uso desta fun��es. Este exemplo � uma pequena modifica��o de um dos exemplos que existe na distribui��o do RT-Linux (sound):

================== exemplo3 ==================

#define MODULE

#include <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);

/* this is just 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, rt_get_time()+(RTIME)1000LL,

(RTIME)(RT_TICKS_PER_SEC/ 8192LL));

return 0;

}

void cleanup_module(void){

rt_task_delete(&task);

rtf_destroy(0);

}

Exatamente como no exemplo2, necessitamos dos servi�os do m�dulo rt_prio_sched, mas agora tamb�m precisamos dos sevicos do m�dulo rt_fifo_new para poder utilizar os FIFOs.

Se criarmos uma tarefa de tempo real peri�dica, com uma frequencia de 8192Hz. Esta tarefa l� bytes da FIFO zero e se encontra alguma coisa o envia a porta do altofalante do PC. Se copiamos um arquivo de som no formato ".au" no diret�rio /dev/rtf0, poderemos ouvi=lo. N�o � necess�rio dizer que a qualidade de som � p�ssima, pois o hardware do PC s;o permite utilizar um bit para modular sinal. No diret�rio testing/sound da distribui��o, podemos encontrar o arquivo Linux.au para fazer provas.

Para compil�-lo e xecut�lo:

# gcc -I /usr/src/linux/include/linux -O2 -Wall -D__KERNEL__ -D__RT__ -c ejemplo3.c

# modprobe rt_fifo_new; modprobe rt_prio_sched; insmod ejemplo3.o

# cat linux.au > /dev/rtf0

Observe como o programa cat pode utilizar para escrever sobre qualquer arquivo, incluidos os arquivos especiais. Tamb�m poder�amos utilizar o comando cp.

Para poder ver como afeta o tempo real a qualidade de reprodu��o, s� temos que escrever um programa que fa�a o mesmo, mas desde um processo de usu�rio:

================== exemplo4 ==================

#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);

/* enable counter 2 */

dummy= inb(0x61);

espera(10);

outb(dummy|3, 0x61);

/* this is just to ensure that the output of the counter is 1 */

outb(0xb0, 0x43);

espera(10);

outb(3, 0x42);

espera(10);

outb(00, 0x42);

fun();

}

Este programa � compilado como um programa normal:

# gcc -O2 ejemplo4.c -o exemplo4

e para execut�-lo:

# cat linux.au | exemplo4

Para poder acessar as portas hardware do computador a partir de um programa normal de Linux, temos que pedir permiss�o ao sistema operacional. Isto � uma medida de prote��o b�sica e necess�ria para evitar que um programa possa acessar por exemplo so disco r�gido diretamente. a chamada ioperm(0 serve para indicar ao sistema operacional que queremos acessar a um determinado n�vel de endere�os de entrada/sa�da. S� ser� concedido o acesso aos programas sendo executados com permiss�o de super-usu�rio. Outro detalhe a destacar � como se gera a frequencia de 8192Hz, para se emitir o som. Se bem que existe a chamada nanodelay(), esta s� tem uma resolu��o do milisegundo, pelo que temos que fazer uso da temporiza��o por loop de espera. O loop est� ajustado para que mais ou menos funcione sobre um Pentium 100Mhz.

Agora prova e executa o exemplo4 junto com o programa ico. O que se ouve? Te parece agora que o tempo real serve para alguma coisa?

Conclus�o

Este segundo artigo teve como ponto central os detalhes de programa��o de tarefas de tempo real. Os exemplos apresentados s�o bastante simples e necessitam de utilidades, no segundo n�mero, apresentarei uma aplica��o mais �til. Poderemos controlar a televis�o a partir do Linux, ou mais surpreendente, controlar teu Linux � distancia (controle remoto)!!

Bibliografía:

"Online KURT" B. Srinivasan. http://hegel.ittc.ukans.edu/projects/kurt

"A Linux-based Real-Time Operating System" por Michael Barabanov. Master of Science, New Mexico Institute of Mioning and Technology.

"Linux as an Embedded Operating System" by Jerry Epplin http://www.espmag.com/97/fe39710.htm

"Implementing Loadable Kernel Modules for Linux" por Matt Welsh http://www.ddj.com/ddj/1995/1995.05/welsh.html

"Linux Kernel Internals" por M. Beck, H. Böhme, M. Dziadzka, U. Kunitz, R. Magnus, D. Verworner. Ed: Addison-Wesley.

"Programa��o Linux 2.0, API do sistema e funcionamento do n�cleo" pors Rémy Card, Eric Dumas y Franck Mével. (Escrito originalmente em frances e traduzido para o espanhol). Ed: Eyrolles, Ediciones Gestión 2000.

"On Satisfying Timing Constrains in Hard-Real-Time Systems" por J. Xu & L. Parmas. IEEE Trans. on Software Engineering. Jan 1993