b'\n_START_ARTICLE_\nRTAI\n_START_PARAGRAPH_\nRTAI (Real Time Application Interface) Interfaz para Aplicaciones en Tiempo Real, es una implementaci\xc3\xb3n de Linux para tiempo real basada en un principio en RTLinux, y actualmente en ADEOS, no es un sistema operativo tal como VXworks o QNX. Se basa en el n\xc3\xbacleo Linux, proporcionando la capacidad de hacerla completamente requisable (preemptable). RTAI a\xc3\xb1ade un peque\xc3\xb1o n\xc3\xbacleo Linux de tiempo real bajo el n\xc3\xbacleo est\xc3\xa1ndar de linux y trata al n\xc3\xbacleo linux como una tarea de menor prioridad. RTAI adem\xc3\xa1s proporciona una amplia selecci\xc3\xb3n de mecanismos de comunicaci\xc3\xb3n entre procesos y otros servicios de tiempo real. _NEWLINE_Adicionalmente, RTAI proporciona un m\xc3\xb3dulo llamado LXRT para facilitar el desarrollo de aplicaciones de tiempo real en el espacio de usuario.\n_START_SECTION_\nArquitectura\n_START_PARAGRAPH_\nRTAI tiene una arquitectura similar a RTLinux. Al igual que RTLinux, RTAI trata el n\xc3\xbacleo est\xc3\xa1ndar de Linux como una tarea de tiempo real con la menor prioridad, lo que hace posible que se ejecute cuando no haya ninguna tarea con mayor prioridad ejecut\xc3\xa1ndose. Las operaciones b\xc3\xa1sicas de las tareas de tiempo real son implementadas como m\xc3\xb3dulos del n\xc3\xbacleo al igual que RTLinux. RTAI maneja las interrupciones de perif\xc3\xa9ricos y son atendidas por el n\xc3\xbacleo linux despu\xc3\xa9s de las posibles acciones de tiempo real que hayan podido ser lanzadas por efecto de la interrupci\xc3\xb3n._NEWLINE_En la arquitectura b\xc3\xa1sica de RTAI, que es muy similar a la de RTLinux, las interrupciones se originan en el procesador y en los perif\xc3\xa9ricos. Las originadas en el procesador (principalmente se\xc3\xb1ales de error como divisi\xc3\xb3n por cero), son manejadas por el n\xc3\xbacleo est\xc3\xa1ndar, pero las interrupciones de los perif\xc3\xa9ricos (como los relojes) son manejadas por RTAI Interrupt Dispatcher. RTAI env\xc3\xada las interrupciones a los manejadores del n\xc3\xbacleo est\xc3\xa1ndar de linux cuando no hay tareas de tiempo real activas. Las instrucciones de activar/desactivar las interrupciones del n\xc3\xbacleo est\xc3\xa1ndar son reemplazadas por macros que se enlazan con las instrucciones de RTAI. Cuando las interrupciones est\xc3\xa1n desactivadas en el n\xc3\xbacleo est\xc3\xa1ndar, RTAI encola las interrupciones para ser repartidas despu\xc3\xa9s de que el n\xc3\xbacleo est\xc3\xa1ndar haya activado las interrupciones de nuevo._NEWLINE_Adicionalmente, el mecanismo de comunicaci\xc3\xb3n entre procesos (IPC), que est\xc3\xa1 implementado de forma separado por Linux y por RTAI. Tambi\xc3\xa9n existe un planificador (scheduler) distinto para Linux y para RTAI.\n_START_SECTION_\nHAL \xe2\x80\x93 Hardware Abstraction Layer\n_START_PARAGRAPH_\nLos desarrolladores de RTAI introducen el concepto de Real Time Hardware Abstraction Layer (RTHAL) que es usado para interceptar las interrupciones hardware y procesarlas despu\xc3\xa9s. RTHAL es una estructura instalada en el n\xc3\xbacleo Linux que re\xc3\xbane los punteros a los datos internos del hardware relacionados en el n\xc3\xbacleo y las funciones necesarias por RTAI para operar.\n_START_SECTION_\nPlanificaci\xc3\xb3n\n_START_PARAGRAPH_\nLas unidades de planificaci\xc3\xb3n de RTAI son las tareas. Siempre hay al menos una tarea, llamada n\xc3\xbacleo linux, que ejecuta como la tarea de menor prioridad. Cuando las tareas de tiempo real son a\xc3\xb1adidas, el planificador da entonces mayor prioridad a \xc3\xa9stas sobre la tarea del n\xc3\xbacleo Linux. El planificador proporciona servicios tales como suspend, resume, yield, make periodic, wait until, que son usadas en varios sistemas operativos de tiempo real._NEWLINE_El planificador es implementado como un m\xc3\xb3dulo del n\xc3\xbacleo dedicado (contrario a RTLinux) lo que facilita la implementaci\xc3\xb3n de planificadores alternativos si es necesario. Actualmente hay tres tipos de planificadores dependiendo del tipo de m\xc3\xa1quina:\n_START_SECTION_\nUniprocesador (UP)\n_START_PARAGRAPH_\nes aquel que es de un solo usuario\n_START_SECTION_\nMultiprocesador sim\xc3\xa9trico (SMP)\n_START_PARAGRAPH_\nEst\xc3\xa1 dise\xc3\xb1ado para m\xc3\xa1quinas SMP y proporciona una interfaz para las aplicaciones de forma que es posible seleccionar el procesador \xc3\xb3 procesadores que deben ejecutar una tarea. Si el usuario no especifica un procesador para la tarea, SMP selecciona el procesador en funci\xc3\xb3n de la carga de trabajo.\n_START_SECTION_\nMulti-Uniprocesador (MUP)\n_START_PARAGRAPH_\nPuede ser usado con ambos, pero al contrario que SMP, a las tareas se les debe especificar el procesador que deben usar. Vi\xc3\xa9ndolo por el lado positivo, el planificador MUP permite unos mecanismo de tiempo m\xc3\xa1s flexibles para las tareas que los planificadores SMP \xc3\xb3 UP.\n_START_SECTION_\nCaracter\xc3\xadsticas de RTAI\n_START_PARAGRAPH_\nCon el objetivo de hacer el desarrollo de aplicaciones m\xc3\xa1s f\xc3\xa1ciles y flexibles posibles, los desarrolladores de RTAI han introducido diferentes mecanismos para la comunicaci\xc3\xb3n entre procesos (IPC), entre las tareas de tiempo real y los procesos en el espacio de usuario. Como a\xc3\xb1adido al mecanismo IPC, RTAI proporciona servicios de manejo de memoria y threads compatibles con Posix.\n_START_SECTION_\nComunicaci\xc3\xb3n entre procesos (IPC \xe2\x80\x93 Inter-process comunication)\n_START_PARAGRAPH_\nRTAI proporciona una variedad de mecanismos para la comunicaci\xc3\xb3n entre procesos. Aunque los sistemas Unix proporcionan mecanismos similares a IPC para los procesos en el espacio de usuarios, RTAI necesita proporcionar una implementaci\xc3\xb3n propia para que las tareas de tiempo real puedan usar este mecanismo y no usen el est\xc3\xa1ndar del n\xc3\xbacleo Linux. Los diferentes mecanismo de IPC est\xc3\xa1n incluidos como m\xc3\xb3dulos de n\xc3\xbacleo, lo que facilita la carga cuando son necesarios. Como ventaja adicional, el uso de m\xc3\xb3dulos para los servicios IPC facilita el mantenimiento y la expansi\xc3\xb3n._NEWLINE_El antiguo mecanismo b\xc3\xa1sico de comunicaci\xc3\xb3n de RTAI eran los FIFOs. FIFO es un as\xc3\xadncrono y no bloqueante canal de comunicaci\xc3\xb3n entre los procesos de Linux y las tareas de tiempo real. La implementaci\xc3\xb3n de RTAI de FIFO est\xc3\xa1 basado en la implementaci\xc3\xb3n de RTLinux, pero RTAI proporciona algunas caracter\xc3\xadsticas que no son posibles en RTLinux. Primeramente RTAI puede lanzar se\xc3\xb1ales cuando hay eventos en el FIFO (escritura de nuevos datos). Los procesos en el espacio de usuario pueden entonces crear un manejador para la se\xc3\xb1al por los mecanismos est\xc3\xa1ndar de Unix. Sin embargo, este mecanismo no es necesario para los procesos de usuario que quieran leer \xc3\xb3 escribir del FIFO. Adicionalmente, puede haber m\xc3\xbaltiples lectores y escritores en el FIFO, cosa que no es posible en la versi\xc3\xb3n de RTLinux. Finalmente, los identificadores FIFO pueden ser din\xc3\xa1micamente localizados con un nombre simb\xc3\xb3lico. Antes era necesario establecer un identificador global para el FIFO, lo que causaba problemas cuando m\xc3\xbaltiples e independientes procesos y tareas lo usaban._NEWLINE_Los sem\xc3\xa1foros es otra herramienta b\xc3\xa1sica de sincronizaci\xc3\xb3n entre procesos usada en los sistemas operativos. RTAI proporciona un API para usar sem\xc3\xa1foros, aunque cada sem\xc3\xa1foro esta t\xc3\xa9cnicamente asociado a un FIFO, por tanto cada sem\xc3\xa1foro usa una entrada global del FIFO. Como a\xc3\xb1adido al servicio b\xc3\xa1sico de sem\xc3\xa1foros, un sem\xc3\xa1foro puede estar asociado con un reloj, el cual puede ser usado para despertar un proceso encolado en un sem\xc3\xa1foro, incluso cuando el sem\xc3\xa1foro a\xc3\xban est\xc3\xa1 cerrado._NEWLINE_La compartici\xc3\xb3n de memoria proporciona una alternativa a IPC y al paradigma FIFO, cuando un modelo de comunicaci\xc3\xb3n diferente es requerido. La memoria compartida es un bloque com\xc3\xban de memoria que puede ser le\xc3\xadda \xc3\xb3 escrita por un proceso y una tarea en el sistema. Como los diferentes procesos pueden operar de forma as\xc3\xadncrona en la regi\xc3\xb3n de memoria, es necesario un dise\xc3\xb1o para asegurar que los datos no sean sobreescritos de forma intencionada._NEWLINE_Finalmente, el m\xc3\xa9todo m\xc3\xa1s flexible de IPC quiz\xc3\xa1s sean los mailboxes. Cualquier n\xc3\xbamero de procesos pueden enviar y recibir mensaje de y desde un mailbox. Un mailbox almacena mensajes hasta un l\xc3\xadmite que se defina, y contrario a los FIFOs, mailbox preserva los mensajes que est\xc3\xa1n en el l\xc3\xadmite. Puede haber un n\xc3\xbamero arbitrario de mailbox activos en el sistema simult\xc3\xa1neamente. RTAI tambi\xc3\xa9n facilita la comunicaci\xc3\xb3n entre procesos mediante RPC.\n_START_SECTION_\nGesti\xc3\xb3n de memoria\n_START_PARAGRAPH_\nEn las primeras versiones de RTAI la memoria ten\xc3\xada que ser asignada est\xc3\xa1ticamente y no era posible las asignaci\xc3\xb3n en tiempo real. Sin embargo en las actuales versiones se incluye un m\xc3\xb3dulo gestor de memoria que permite la asignaci\xc3\xb3n din\xc3\xa1mica de memoria por parte de las tareas de tiempo real usando una interfaz basada en una biblioteca est\xc3\xa1ndar de C._NEWLINE_RTAI preasigna trozos de memoria antes de la ejecuci\xc3\xb3n de tiempo real. Cuando la tarea de tiempo real llaman a la funci\xc3\xb3n rt_malloc(), la respuesta que obtiene es el trozo preasignado. Antes de que el espacio se agote, RTAI reserva nuevos trozos de memoria (preasigna) para futuras llamadas. De manera similar ocurre con la funci\xc3\xb3n rt_free(), en este caso, se libera la memoria preasignada a la espera de futuras reservas. Cuando la suma de memoria liberada es mayor que un valor para una marca, se ordena su liberaci\xc3\xb3n.\n_START_SECTION_\nThreads Posix\n_START_PARAGRAPH_\nRTAI tiene m\xc3\xb3dulos que proporcionan la implementaci\xc3\xb3n de threads de acuerdo al est\xc3\xa1ndar POSIX 1003.1c. Usando las operaciones especificadas en el est\xc3\xa1ndar, el usuario puede manejar de manera similar a como lo hace con los threads posix convencionales, excepto en cuanto a los conceptos de joining y detaching._NEWLINE_Los threads de un mismo proceso comparten el espacio de memoria, por tanto es f\xc3\xa1cil el intercambio de informaci\xc3\xb3n entre ellos, sin embargo, el uso de \xc3\xa1reas de memoria compartida son necesarias para la sincronizaci\xc3\xb3n. Tambi\xc3\xa9n se proporcionan los mecanismos de mutex y de variables de condici\xc3\xb3n.'