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