Académique Documents
Professionnel Documents
Culture Documents
Noviembre 2009
Concepto de interrupción:
Una interrupción se convierte en una interrupción de hardware cuando es solicitada por uno
de los componentes de hardware del equipo. En efecto, existen varios periféricos en un
equipo. Estos periféricos necesitan generalmente utilizar los recursos del sistema aunque sólo
sea para comunicarse con el sistema mismo.
Este ͞hilo͟ es, de hecho, una línea física que conecta cada ranura de expansión así como cada
interfaz E/S a la placa madre. Para una ranura ISA de 8 bits, por ejemplo, hay 8 líneas IRQ que
unen ranuras ISA de 8 bits a la placa madre (IRQ0 a IRQ7). Estos IRQ están controlados por un
͞controlador de interrupción͟ que se encarga de ͞cederle la palabra͟ al IRQ que posee la
mayor prioridad.
{text:bookmark-start} {text:bookmark-end}
Interrupt()
Interrupted()
isInterrupted()
Interrupciones Sintaxis
Primero el método checkAccess de este thread es invocado, lo cual puede causar una Security
Exception.
Si este thread es bloqueado en un selector, entonces el estado del thread de intrrupt será
fijado, y retornara inmediatamente de la operación de selección, posiblemente con un valor
diferente a cero, justo como si el método del selector wakeup hubiera sido invocado.
Si ninguna de las condiciones pasadas se cumple, entonces el estado en interrupt del thread
será fijado (activado).
Interrupted (interrumpido)
Hace una prueba si el thread actual a sido interrumpido. El estado de interrupción del thread
es deshecho por este método. En otras palabras, si este método se llamara dos veces, la
segunda vez devolvería un valor falso (al menos que el thread actual sea interrumpido de
nuevo, después de que la primera llamada haya terminado su interrupción y antes de que la
segunda empiece).
Todos los sistemas operativos de los ordenadores que están en uso hoy en día, soportan los
puertos serie, ya que han estado en funcionamiento durante décadas. Los puertos paralelos
son una invención más reciente y son mucho más rápidos que los puertos serie. Los puertos
USB solo tienen unos pocos años de antigüedad, y con el tiempo seguramente reemplazaran a
los puertos serie y paralelo en los próximos años.
El nombre de serie viene por el hecho de que un puerto serie serializa los datos. Esto significa
que coge un byte de datos y trasmite los 8 bits que contiene el byte uno a la vez. La ventaja es
que los puertos serie solo necesitan un hilo para transmitir los 8 bits, mientras que los paralelo
necesitan 8. La desventaja es que lleva 8 veces más de tiempo que si tuviera 8 hilos. Los
puertos serie bajan el coste de los cables y hacen que sean mas pequeños.
Antes de cada byte de datos, los puertos serie envían un bit de comienzo, el cual es un único
bit con un valor de 0. Después de cada byte de datos, envía un bit de parada para señalar que
el byte esta completo. También envía un bit de paridad.
Terminales eléctricas del puerto serial. El puerto serial cuenta con 9 contactos tipo pin, se
muestran las líneas eléctricas y su descripción básica.
Variantes físicas del puerto serial. Los puertos serie, también llamados puertos de
comunicación (COM), son bidireccionales. La comunicación bidireccional permite a cada
dispositivo recibir datos a la vez que los transmite. Los dispositivos serie usan pines diferentes
para el recibir y enviar datos, usar los mismos pines significaría que la comunicación estaría
limitada a half-duplex, y que la información viajaría en una sola dirección a la vez. Usar pines
diferentes permite una comunicación full-dúplex, y puede viajar en ambos sentidos.
Definición: Un puerto es el lugar donde el CPU se comunica con otros dispositivos, existen de
varios tipos, hay puertos de entrada, de salida y ambos. Además estos pueden ser seriales o
paralelos.
Puertos de salida: Son todos aquellos por donde el CPU envía datos a otros dispositivos, por
ejemplo están la salida de video y de sonido.
Nosotros vamos a hablar acerca de los puertos que se encuentran fuera del gabinete,
hablaremos de los puertos de teclado, mouse, impresoras, etc. La computadora por si misma
no sería capaz de realizar operaciones útiles para nosotros si no podemos comunicarnos con
ella, necesita dispositivos periféricos por donde pueda darnos mensajes y nosotrospodamos
enviarle órdenes.
Puerto serial: El puerto serial es aquel que envía y recibe los datos BIT por BIT, entre los
puertos seriales se puede mencionar el puerto de teclado, o el puerto del MODEM.
Puerto paralelo: Este tipo de puerto transmite la información byte por byte, o sea que
transmite ocho bits al mismo tiempo, de forma paralela. Un puerto paralelo por excelencia
pues es el puerto para impresora
Se puede observar que un puerto de entrada puede ser paralelo o serial, lo mismo que un
puerto de entrada o de entrada / salida.
A cada puerto la BIOS le asigna una dirección de memoria para que pueda trabajar,
dependiendo de que clase de puerto sea se le asigna un determinado espacio exclusivo para
él. Por medio de estas localidades de memoria el sistema puede enviarles o recibir
información, es una especie de memoria de intercambio para la transmisión de dados de un
lugar a otro. A esto se le llama espacio de localidades de memoria y se realiza dentro del
primer kilo bite de la memoria principal. Existen otras asignaciones de memoria en otras capas
superiores de memoria pero estas son hechas por el sistema operativo y por los demás
programas, pero estas asignaciones son para fines específicos de los demás programas.
Los puertos no solo se limitan a recibir la información, o enviarla, según sea el caso. El puerto
provee la corriente eléctrica necesaria para el funcionamiento del dispositivo y revisa el estado
de este.
6.4 Interrupciones que intervienen en cada punto
Luego cada vez que el usuario presiona una tecla, la CPU es advertida a través de una señal
especial de interrupción. Cuando la CPU advierte/recibe una señal de interrupción suspende
temporalmente el proceso actual almacenando en memoria RAMun bloque con toda la
información necesaria para restablecer posteriormente la ejecución del programa si es que
procede. Enseguida la CPU determina qué elemento ha solicitado la interrupción y para cada
caso existe un bloque de instrucciones que realiza la tarea correspondiente que es ejecutada a
continuación. Terminada la ejecución se restablece el programa original en el mismo punto en
que fue interrumpido usando para ello la información almacenada previamente.
Cada interrupción tiene asignada un número único. El PC está diseñado de manera que la
interrupción tiene asignada 4 bytes de memoria RAM. La dirección de los cuatro bytes en la
memoria corresponde al _número de la _interrupción multiplicado por 4. Por ejemplo la
interrupción IRQ 5 tiene asignada 4 bytes en la dirección 0x00014 (0000:0014). El contenido de
los 4 bytes de memoria RAM asignados a una interrupción contiene a su vez una dirección que
es un puntero a un bloque de instrucciones de máquina que realiza el procedimiento
correspondiente. De este modo al iniciar la ejecución de una interrupción de los cuatro bytes
que tiene asignados se obtiene la dirección del bloque de instrucciones que efectivamente se
ejecutan. Por ejemplo si en la dirección 0000:0014 estuviera almacenado el valor 0xFFF00, ello
significa que en dicha dirección (ó (F000:FF00) se encuentra el bloque de instrucciones a
ejecutar cuando la interrupción IRQ 5 sea requerida.
Los vectores de las interrupciones BIOS están ubicados a partir del vector 0x10H, vale decir
inmediatamente a continuación de los vectores 0 a15 que son generados por hardwarey que
no son enmascarables. Cabe hacer notar que la arquitectura del PC está definida de tal manera
que el primer Kilobyte del espacio de memoria está reservado para vectores de interrupciones,
vale decir hay espacio para 256 interrupciones.
Cuando se escriben programas Java que se comunican a través de la red, se está programando
en la capa de aplicación. Típicamente, no se necesita trabajar con las capas TCP y UDP Ͷ en su
lugar se puede utilizar las clases del paquete java.net. Estas clases proporcionan comunicación
de red independiente del sistema.
A través de las clases del paquete java.net, los programas Java puede utilizan TCP o UDP para
comunicarse a través de Internet. Las clases URL, URL Connection, Socket, y Socket Server?
Utilizan el TCP para comunicarse a través de la Red. Las clases ? Y Datagram Server? Utilizan
UDP.
TCP proporciona un canal de comunicación fiable punto a punto, lo que utilizan para
comunicarse las aplicaciones cliente-servidor en Internet. Las clases Socket y Server Socket del
paquete java.net proporcionan un canal de comunicación independiente del sistema utilizando
TCP, cada una de las cuales implementa el lado del cliente y el servidor respectivamente.
El entorno de desarrollo de Java incluye un paquete, java.io, que contiene un juego de canales
de entrada y salida que los programas pueden utilizar para leer y escribir datos. Las clases
Input Stream y Output Stream del paquete java.io son superclases abstractas que definen el
comportamiento de los canales de I/O secuenciales de Java. java.io también incluye muchas
subclases de Input Stream y Output Stream que implementan tipos específicos de canales de
I/O.
Servicio orientado a conexión: Donde disponemos de un stream que nos asegura la entrega de
la información de forma ordenada y fiable. Operamos con streams y el protocolo empleado es
TCP
El servidor crea un Socket, mediante Server Socket, le asigna una dirección y un puerto y
acepta llamadas (accept). A partir de este momento el proceso queda bloqueado a la espera
de una llamada. Cuando llega una llamada, el accept crea un nuevo socket para procesar dicha
llamada. Es únicamente en ese momento cuando existe la conexión y durará hasta que se
libere mediante close().
Los sockets tienen asociados un Stream de entrada y otro de salida a través de los cuales se
leen y escriben los datos:
Para enviar datos se puede utilizar el Output Stream del socket, para enviar un flujo de bytes
sin buffer. Pero también se puede crear un objeto de tipo stream de datos basado en el Output
Stream.
_String linea; _
do_ { _
linea_=teclado.readLine(); _
escribir.println_(linea); _
_} while (linea.compareTo(͞#͟)!=0); _
͙.
Para recibir datos se puede utilizar Input Stream o definir un nuevo objeto del mismo tipo más
eficiente.
Ejemplo:
Buffered Reader leer;
String s;
while_ (͞#͟.compareTo(s=leer.readLine()!=0) { _
System.out.println_(nombre+͟: ͞+s); _
Import java.io.*;
Import java.net.*;
Socket s=null;
?_(Socket s) {this.s=s;} _
While(_true) os.write(is.read()); _
_Public static void main(String agrs[]) throws IO Exception , _Unknown Host Exception?_ { _
While(true) {
_e.start(); _
}
Existe otro tipo de socket, RAW SOCKET que no opera en el nivel de transporte y accede
directamente al nivel de red. Este tipo de socket suele ser utilizado por aplicaciones con
privilegios para la definición de protocolos de bajo nivel.
Cada servicio está asociado a un puerto. Un puerto es una dirección numérica a través de la
cual se procesa el servicio. Sobre un sistema Unix, los servicios que proporciona ese sistema se
indican en el fichero /etc/services, y algunos ejemplos son:
La primera columna indica el nombre del servicio. La segunda columna indica el puerto y el
protocolo que está asociado al servicio. La tercera columna es un alias del servicio; por
ejemplo, el servicio smtp, también conocido como mail, es la implementación del servicio de
correo electrónico.
Las comunicaciones de información relacionada con Web tienen lugar a través del puerto 80
mediante protocolo TCP. Para emular esto en Java, usaremos la clase Socket. La fecha
(daytime). Sin embargo, el servicio que coge la fecha y la hora del sistema, está ligado al
puerto 13 utilizando el protocolo UDP. Un servidor que lo emule en Java usaría un objeto
6.1 Interrupciones.
Concepto de interrupción:
Una interrupción se convierte en una interrupción de hardware cuando es solicitada por uno
de los componentes de hardware del equipo. En efecto, existen varios periféricos en un
equipo. Estos periféricos necesitan generalmente utilizar los recursos del sistema aunque sólo
sea para comunicarse con el sistema mismo.
Este ͞hilo͟ es, de hecho, una línea física que conecta cada ranura de expansión así como cada
interfaz E/S a la placa madre. Para una ranura ISA de 8 bits, por ejemplo, hay 8 líneas IRQ que
unen ranuras ISA de 8 bits a la placa madre (IRQ0 a IRQ7). Estos IRQ están controlados por un
͞controlador de interrupción͟ que se encarga de ͞cederle la palabra͟ al IRQ que posee la
mayor prioridad.
Los métodos interrupt que se manejan en Java. Son 3
1. Interrupt()
2. Interrupted()
3. isInterrupted()
Interrupciones Sintaxis
Primero el método checkAccess de este thread es invocado, lo cual puede causar una Security
Exception.
Si este thread es bloqueado en una operación de E/S ante un canal interrumpidle, entonces el
canal se cerrará, el estado de interrupt del thread se fijara, y el thread recibirá un Closed by
Interrupt Exception.
Si este thread es bloqueado en un selector, entonces el estado del thread de intrrupt será
fijado, y retornara inmediatamente de la operación de selección, posiblemente con un valor
diferente a cero, justo como si el método del selector wakeup hubiera sido invocado.
Si ninguna de las condiciones pasadas se cumple, entonces el estado en interrupt del thread
será fijado (activado).
Interrupted (interrumpido)
Hace una prueba si el thread actual a sido interrumpido. El estado de interrupción del thread
es deshecho por este método. En otras palabras, si este método se llamara dos veces, la
segunda vez devolvería un valor falso (al menos que el thread actual sea interrumpido de
nuevo, después de que la primera llamada haya terminado su interrupción y antes de que la
segunda empiece).
IsInterrupted
Sintaxis Public boolean isInterrupted () Hace una prueba para ver si este thread a sido
interrumpido. El estado de interrupción del thread no es afectado por este método.
6.2 Generalidades de los puertos.
Canales
Grupos de cables a través de los cuales viaja la información entre los componentes del
sistema. Tienen 8, 16 o 32 cables y este número indica la cantidad de bits de información que
puede transmitir al mismo tiempo.
Los canales más anchos pueden transmitir información con más rapidez que los canales
angostos. Ranuras de expansión: Se conectan al bus eléctrico común. Algunos canales están
conectados a ellas en la caja del computador.
Los usuarios pueden personalizar sus máquinas insertando tarjetas de circuitos (o tarjetas) de
propósito especial en estas ranuras. Existen tarjetas de expansión de RAM, adaptadores de
color y de gráficos, fax módem, puertos, coprocesadores (procesadores adicionales que
incrementan la capacidad o velocidad de procesamiento del sistema), etc.
Puertos
Son puntos de conexión en la parte exterior del chasis de la computadora a los que se
conectan algunos canales. El puerto permite una conexión directa con el bus eléctrico común
de la PC. los puertos pueden ser:
Puertos series
Permiten la transmisión en serie de datos, un bit a la vez. Este tipo de puertos permiten una
interfaz con impresoras y módems de baja velocidad.
Puertos paralelos
Puerto serial:
El puerto serial es aquel que envía y recibe los datos BIT por BIT, entre los puertos seriales se
puede mencionar el puerto de teclado, o el puerto del MODEM.
6.3.1 USB.
El Universal Serial Bus (bus universal en serie) o Conductor Universal en Serie (CUS), abreviado
comúnmente USB, es un puerto que sirve para conectar periféricos a una computadora.
El diseño del USB tenía en mente eliminar la necesidad de adquirir tarjetas separadas para
poner en los puertos bus ISA o PCI, y mejorar las capacidades plug-and-play permitiendo a esos
dispositivos ser conectados o desconectados al sistema sin necesidad de reiniciar. Sin
embargo, en aplicaciones donde se necesita ancho de banda para grandes transferencias de
datos, o si se necesita una latencia baja, los buses PCI o PCIe salen ganando. Igualmente
sucede si la aplicación requiere de robustez industrial. A favor del bus USB, cabe decir que
cuando se conecta un nuevo dispositivo, el servidor lo enumera y agrega el software necesario
para que pueda funcionar.
Puerto paralelo:
Este tipo de puerto transmite la información byte por byte, o sea que transmite ocho bits al
mismo tiempo, de forma paralela. Un puerto paralelo por excelencia pues es el puerto para
impresora
Se puede observar que un puerto de entrada puede ser paralelo o serial, lo mismo que un
puerto de entrada o de entrada / salida.
A cada puerto la BIOS le asigna una dirección de memoria para que pueda trabajar,
dependiendo de que clase de puerto sea se le asigna un determinado espacio exclusivo para
él. Por medio de estas localidades de memoria el sistema puede enviarles o recibir
información, es una especie de memoria de intercambio para la transmisión de dados de un
lugar a otro. A esto se le llama espacio de localidades de memoria y se realiza dentro del
primer kilo bite de la memoria principal. Existen otras asignaciones de memoria en otras capas
superiores de memoria pero estas son hechas por el sistema operativo y por los demás
programas, pero estas asignaciones son para fines específicos de los demás programas.
Los puertos no solo se limitan a recibir la información, o enviarla, según sea el caso. El puerto
provee la corriente eléctrica necesaria para el funcionamiento del dispositivo y revisa el estado
de este.
El bit 4 del puerto de control se denomina IRQEN. Este bit habilita o permite que se produzca
la interrupción asociada a la entrada ACK#. Cuando este bit está a 1 y la señal ACK# pasa del
nivel lógico 1 al nivel 0 se produce una petición de interrupción, que es la IRQ7.
En el diseño original del PC, IBM reservó 8 interrupciones hardware, comenzando por la
interrupción 08h, para expansión de interrupciones, que son comúnmente conocidas como
IRQ0 a IRQ7. Así la IRQ0 se corresponde con la interrupción 08h, la IRQ1 con la 09h, etc. La
IRQ7 se corresponde pues con la 0Fh, estando sus vectores a partir de la dirección 0000:003Ch.
Para que una petición de una IRQ llegue a la CPU, ésta debe estar permitida, no enmascarada.
El puerto 021h está asociado con la máscara de interrupciones de las IRQ.
and al, 01111111b ; impone un 0 en el bit más significativo, IRQ7. No modifica el resto
Con estas operaciones quedará habilitada la IRQ7. Una vez atendida de la forma que se haya
previsto, el programa debe indicar a la CPU que la interrupción ya ha sido procesada, para ello
debe escribir un 1 en el bit 5 del puerto 020h, es decir:
mov al, 020h ; carga en al 0010 0000 b
Finalmente, tan sólo queda por activar el bit que permite que la señal ACK# genere una
petición de IRQ7. Para ello se deberá poner a 1 el bit 4 del puerto de control , sin modificar el
resto. Cuando no se quiera que se produzca una IRQ7, basta con poner a cero este bit.
Un programa que utilice la interrupción del puerto paralelo puede tener esta estructura, en lo
que se refiere al manejo de dicha interrupción
4. Cerrar el puerto.
El API de Comunicaciones Java solamente puede controlar puertos de los cuales tenga
conocimiento. En la última versión que JavaSoft ha proporcionado de este API, no es necesario
que se inicialicen los puertos, ya que en el arranque, el API realiza una búsqueda de los puertos
disponibles en la máquina en que se ejecuta y los va incorporando automáticamente.
Se pueden inicializar los puertos serie que se vayan a utilizar en la aplicación, y en caso de que
la nomenclatura de los dispositivos no siga la convención habitual, se pueden añadir
explícitamente utilizando código semejante al que se reproduce a continuación.
CommPortIdentifier.addPort( ttya,CommPortIdentifier.PORT_SERIAL );
CommPortIdentifier.addPort( ttyb,CommPortIdentifier.PORT_SERIAL );
El código que aparece a continuación muestra como se añade, fijan las características y abre
un dispositivo; si el lector necesita detalles específicos sobre los parámetros de las llamadas a
los métodos, debe remitirse a la documentación del API. El ejemplo fija un dispositivo serie
determinado para que sea accesible con el nombre ControlPuertoSerie. El dispositivo
conectado a esta línea tiene una velocidad de 9600 baudios, 1 bit de parada, 8 bits por
carácter y no dispone de paridad, y lo que se pretende es proporcionar dos canales, o streams,
uno para leer y otro para escribir en el dispositivo conectado a este puerto.
OutputStream salida;
CommPortIdentifier idPuerto =
CommPortIdentifier.getPortIdentifier( dispositivo );
puertoSerie.setSerialPortParams( 9600,SerialPort.DATABITS_8,
SerialPort.STOPBITS_1,SerialPort.PARITY_NONE );
puertoSerie.setFlowcontrolMode( SerialPort.FLOWCTRL_NONE );
puertoSerie.enableRcvThreshold( 1 );
puertoSerie.enableRcvTimeout( timeout );
entrada = puertoSerie.getInputStream();
try {
salida.write( arraySalida,0,longitud );
try {
int b = entrada.read()
El ejemplo java1901.java, es un ejemplo muy simple que permite escribir por el primer puerto
serie de la máquina en que se esté ejecutando.
import java.io.*;
import java.util.*;
import javax.comm.*;
listaPuertos = CommPortIdentifier.getPortIdentifiers();
while( listaPuertos.hasMoreElements() ) {
idPuerto = (CommPortIdentifier)listaPuertos.nextElement();
// if( idPuerto.getName().equals("/dev/term/a") ) {
if( idPuerto.getName().equals("COM1") ) {
try {
} catch( PortInUseException e ) {}
try {
salida = puertoSerie.getOutputStream();
} catch( IOException e ) {}
try {
puertoSerie.setSerialPortParams( 9600,
SerialPort.DATABITS_8,
SerialPort.STOPBITS_1,
SerialPort.PARITY_NONE );
} catch( UnsupportedCommOperationException e ) {}
// Se envía el mensaje
try {
salida.write( mensaje.getBytes() );
} catch( IOException e ) {}
Cierre de Puertos
El cierre de los puertos con este API de Comunicaciones no es distinto a otras peticiones de
cierre de dispositivos; aunque en este caso, el cierre es un paso sumamente importante
porque el API de Comunicaciones Java siempre intenta proporcionar acceso exclusivo a los
dispositivos, y si algún canal no se cierra, no estará disponible para otras aplicaciones. Si se
quiere utilizar un dispositivo para múltiples usuarios sobre una misma línea serie, es necesario
emplear un protocolo que permita multiplexar la información proveniente de cada uno de
ellos.
try {
entrada.close();
salida.close();
} ...
Conclusión
Habría que comprobar el comportamiento del API de Comunicaciones Java ante grandes
avalanchas de datos o aplicaciones en tiempo real, en donde sí se puede valorar la bondad de
API. No obstante esa duda, la aproximación tan disciplinada que proporciona este API de
Comunicaciones hará mucho más sencilla la integración de cualquier dispositivo serie como
lectores de códigos de barras, impresoras, lectores de tarjetas, y cientos de otros dispositivos.
También es verdad que hay otros APIs de Java que se apoyan en este API de Comunicaciones;
por ejemplo, si el lector necesita desarrollar una aaplicación que utilice tarjetas inteligentes,
puede utilizar un API ya definido como OpenCard Framework, o comunicarse directamente
utilizando javax.comm; e incluso, usando javax.smartcard, que hace uso de javax.comm.
Como recomendación final al lector, en caso de que desee utilizar este API en aplicaciones con
gran trasiego de datos, o sensiblemente críticas, debe valorar las siguientes cuestiones, para
comprobar que el uso de este API satisface los requerimientos que deban tener esas
aplicaciones.
23
2.1 Creación de componentes. 2.2 Creación de librerías dinámicas. 3.1 Concepto de Hilo. 3.2
Comparación de un programa de flujo único contra uno de flujo múltiple. 3.3 Creación y
control de hilos. 3.3.1 Atributos de hilos. 3.3.2 Creación e Inicialización de hilos. 3.3.3 Arranque
de hilos. 3.3.4 Manipulación de hilos. 3.3.5 Suspensión de hilos. 3.3.6 Parada de hilos. 3.4
Sincronización de hilos. 3.4.1 Mutex. 3.4.2 Semáforos. 3.4.3 Barreras (Barrier). 4.1 Creación de
interfaz gráfica para usuarios. 4.1.1 Librería de interfaz gráfica (API͛s). 4.1.2 Aplicaciones GUI.
4.2 Computación gráfica. 4.2.1 Área de dibujo. 4.2.2 Primitivas de dibujo (línea, arco, circulo,
colores, rellenos, imágenes).
ͻ
UNIDAD 3.- Programación concurrente multihilo. Objetivo Educacional Implementara ͻ
aplicaciones multihilo compartiendo la ͻ misma arquitectura ͻ ͻ ͻ ͻ Actividades de
Aprendizaje Buscar y seleccionar información sobre hilos. Organizar un debate sobre hilos vs.
procesos. Analizar uso e impacto de hilos en el desarrollo de aplicaciones. Desarrollar
programas para reforzar el uso de hilos con énfasis en los cambios de estado. Desarrollar
programas concurrentes que comparten recursos. Debatir problemas de exclusión mutua y
formas de resolverla. Fuentes de Información 1, 2, 3, 4, 6, 7, 9
UNIDAD 4.- Interfaz Gráfica de Usuario. Objetivo Educacional Implementará aplicaciones con
interfaz gráfica de usuario. Actividades de Aprendizaje ͻ ͻ ͻ ͻ Buscar y seleccionar librerías
para creación de interfaz gráfica de usuario. Desarrollar aplicaciones con interfaz gráfica de
usuario, que utilice múltiples ventanas. Buscar y seleccionar librerías de computación gráfica.
Desarrollar aplicaciones que permitan crear gráficos en tiempo de ejecución. Fuentes de
Información 1, 2, 3, 4, 6, 7, 9
UNIDAD 5.- Multimedia. Objetivo Educacional Comprenderá que es ͻ la multimedia, cuales son
sus ventajas y ͻ desarrollará una aplicación multimedia interactiva. ͻ Actividades de
Aprendizaje Buscar y seleccionar información para discutir sobre la multimedia. Elaborar un
mapa conceptual sobre los tipos de formatos gráficos más comunes. Buscar y seleccionar
información sobre las herramientas y clases que provee el lenguaje para crear y manipular
objetos multimedia. Desarrollar programas para aplicar alguna biblioteca de clases para el
manejo de multimedia. Fuentes de Información 1, 6, 8
ͻͻ
ͻ
10. FUENTES DE INFORMACIÓN 1. 2. 3. 4. Deitel y Deitel. Como programar en Java.Prentice
Hall. 1998. Mitchell will David. Java sin errores. Mc Graw Hill. 2001 Becerril C. Francisco. Java a
su alcance. Mc Graw Hill. 1998 Lemay Laura & Perkins Charles L. Aprendiendo Java en 21 días.
Prentice Hall. 1996. 5. Smiley John. Learn to program with Java.Mc Graw Hill. 2002. 6.
Naughton Patrick . The Java Handbook. Berkeley, CA: OsborneMcGraw Hill. 1996. 7. Schildt
Herbert. The Complete Reference Java 2. Fourth Edition. McGraw-Hill. 2001. 8. Case Bradley
Julia & Millspaugh Anita C. Mt. San Antonio College. Programming With Java W/CD-ROM. Mc
Graw Hill. 2002. 9. Arnow David M. & Weiss Gerald. Introducción a la programación con Java.
Un enfoque orientado a objetos. Addison Wesley. 2001. 10. Elliotte Rusty Harold. Java I/O O.
O'Reilly & Associates. 1999. 11. Scott Oaks and Henry Wong. Java Threads, second Edition.
O'Reilly & Associates. 1999.
Referencias en Internet
441251
12
3
INSTITUTO TECNOLOGICO
SUPERIOR DE HUATUSCO
NOMBRE DE LA MATERIA:
PROGRAMAS
UNIDAD I
UNIDAD II
Unidad I
Manejadores de Capas
1.- FlowLayout
import javax.swing.*;
import java.awt.*;
JButton alumno;
JButton maestro;
JButton escuela;
JButton materia;
public EjercicioFL () {
super.setTitle("FlowLayout");
this.setLayout(u);
alumno=new JButton("ALUMNO");
maestro=new JButton("MAESTRO");
escuela=new JButton("ESCUELA");
materia=new JButton("MATERIA");
this.add(alumno);
this.add(maestro);
this.add(escuela);
this.add(materia);
this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
this.setSize(210, 140);
u.setVisible(true);
2.- BorderLayout
import java.awt.*;
import javax.swing.*;
public EjercicioBL() {
super.setTitle("BorderLayout");
this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
this.setSize( 260,160 );
this.setVisible( true );
x.setVisible(true);
}//Fin de BorderLayout
3.- GridLayout
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
// configurar GUI
public EjercicioGL()
contenedor = getContentPane();
contenedor.setLayout( cuadricula1 );
this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
if ( alternar )
contenedor.setLayout( cuadricula2 );
else
contenedor.setLayout( cuadricula1 );
alternar = !alternar;
contenedor.validate();
x.setVisible(true);
4.- BoxLayout
import java.awt.*;
import javax.swing.*;
public EjercicioGBL()
vertical1.add( Box.createVerticalStrut( 25 ) );
horizontal2.add( Box.createHorizontalGlue() );
panel.add( Box.createGlue() );
JTabbedPane.TOP, JTabbedPane.SCROLL_TAB_LAYOUT );
// colocar cada contendor en panel con fichas
setVisible( true );
aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
} }//Fin de BoxLayout
Ejemplo Ventana
import javax.swing.*;
import java.awt.*;
JButton b1;
JButton b2;
JButton b3;
JButton b4;
JButton b5;
public Ventana() {
super.setTitle("Ventana");
this.setLayout(u);
this.add(b1);
this.add(b2);
this.add(b3);
this.add(b4);
this.add(b5);
this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
this.setSize(200, 150);
x.setVisible(true);
Ejemplo Ventana2
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
JButton boton;
JLabel Label;
JTextField t1;
public Ventana2() {
super.setTitle("Ventana2");
this.setLayout(c);
Label=new JLabel("algo");
t1=new JTextField(10);
this.add(boton);
this.add(Label);
this.add(t1);
//-----------------evento----------
String cadena=t1.getText();
Label.setText(cadena);
});
this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
this.setSize(200, 150);
x.setVisible(true);
-----------------------------------------------------------------------------------------
Tarea # 1
Este Juego genera 3 números aleatorios si los tres son iguales hace una bonificación y también
suma los números, verifica y limpia los campos.
import java.awt.*;
import javax.swing.*;
import java.awt.event.*;
JLabel l1;
JLabel l2;
JLabel l3;
JTextField n1;
JTextField n2;
JTextField n3;
JLabel suma;
JTextField s;
JTextField r;
JButton generar;
JButton verificar;
JButton limpiar;
JLabel res;
JLabel rl;
public juego() {
super.setTitle("Juego");
this.setLayout(capa);
n1=new JTextField(10);
n2=new JTextField(10);
n3=new JTextField(10);
suma=new JLabel("Suma");
s=new JTextField(10);
r=new JTextField(10);
generar=new JButton("Generar");
verificar=new JButton("Verificar");
limpiar=new JButton("Limpiar");
rl=new JLabel("<<<<Bonificacion>>>>");
this.add(l1);
this.add(n1);
this.add(l2);
this.add(n2);
this.add(l3);
this.add(n3);
this.add(suma);
this.add(s);
this.add(generar);
this.add(verificar);
this.add(limpiar);
this.add(res);
this.add(rl);
generar.addActionListener(new ActionListener(){
try{
int a1,a2,a3;
String cad;
a1=(int)(Math.random()*1000+1);
a2=(int)(Math.random()*1000+1);
a3=(int)(Math.random()*1000+1);
cad=n1.getText();
a1=Integer.parseInt(cad);
cad="";
cad=n2.getText();
a2=Integer.parseInt(cad);
cad="";
cad=n3.getText();
a3=Integer.parseInt(cad);
cad="";
}catch(Exception f){
});
verificar.addActionListener(new ActionListener(){
int r1,r2,r3,r4,s;
String cad;
cad=n1.getText();
r1=Integer.parseInt(cad);
cad="";
cad=n2.getText();
r2=Integer.parseInt(cad);
cad="";
cad=n3.getText();
r3=Integer.parseInt(cad);
cad="";
s=r1+r2+r3;
res.setText(cad);
cad=suma.getText();
r4=Integer.parseInt(cad);
cad="";
if(s==r4){
rl.setText("Excelente");
else{
rl.setText("Eres un Burroooooo!");
});
limpiar.addActionListener(new ActionListener(){
n1.setText("");
n2.setText("");
n3.setText("");
s.setText("");
});
x.setVisible(true);
x.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
x.setSize(200,300);
}
}
Promedio
import java.awt.*;
import javax.swing.*;
import java.awt.event.*;
JButton lc;
JLabel n;
JLabel e1;
JLabel e2;
JLabel e3;
JLabel e7;
JLabel e5;
JLabel e6;
JLabel e8;
JButton b1;
JLabel e4;
JTextField na;
JTextField t1;
JTextField t2;
JTextField t3;
JTextField t4;
JTextField t5;
JTextField t6;
JTextField t7;
JTextField t8;
JTextField t9;
JLabel l;
public Promedio() {
super.setTitle("Promedio");
this.setLayout(capa);
e3=new JLabel("Administracion");
na=new JTextField(10);
this.add(n);
this.add(na);
this.add(e1);
this.add(t1);
this.add(e2);
this.add(t2);
this.add(e3);
this.add(t3);
this.add(e5);
this.add(t5);
this.add(e6);
this.add(t6);
this.add(e7);
this.add(t7);
this.add(e8);
this.add(t8);
this.add(b1);
this.add(t4);
this.add(l);
this.add(lc);
lc.addActionListener(new ActionListener(){
na.setText("");
t1.setText("");
t2.setText("");
t3.setText("");
t4.setText("");
t5.setText("");
t6.setText("");
t7.setText("");
t8.setText("");
t9.setText("");
);
b1.addActionListener(new ActionListener() {
try{
cad=t1.getText();
cal1=Integer.parseInt(cad);
cad="";
cad=t2.getText();
cal2=Integer.parseInt(cad);
cad="";
cad=t3.getText();
cal3=Integer.parseInt(cad);
cad="";
cad=t6.getText();
cal5=Integer.parseInt(cad);
cad="";
cad=t7.getText();
cal6=Integer.parseInt(cad);
cad="";
cad=t8.getText();
cal7=Integer.parseInt(cad);
cad="";
cad=t5.getText();
cal8=Integer.parseInt(cad);
cad="";
prom=(cal1+cal2+cal3+cal5+cal6+cal7+cal8)/7;
cad=""+prom;
t4.setText(cad);
switch(prom){
case 100:
cad="Cien";
l.setText(cad);
break;
case 99:
cad="Noventaynueve";
l.setText(cad);
break;
case 98:
cad="Noventayocho";
l.setText(cad);
break;
case 97:
cad="Noventaysiete";
l.setText(cad);
break;
case 96:
cad="Noventayseis";
l.setText(cad);
break;
case 95:
cad="Noventaycinco";
l.setText(cad);
break;
case 94:
cad="Noventaycuatro";
l.setText(cad);
break;
case 93:
cad="Noventaytres";
l.setText(cad);
break;
case 92:
cad="Noventaydos";
l.setText(cad);
break;
case 91:
cad="Noventayuno";
l.setText(cad);
break;
case 90:
cad="Noventa";
l.setText(cad);
break;
case 89:
cad="Ochentaynueve";
l.setText(cad);
break;
case 88:
cad="Ochentayocho";
l.setText(cad);
break;
case 87:
cad="Ochentaysiete";
l.setText(cad);
break;
case 86:
cad="Ochentayseis";
l.setText(cad);
break;
case 85:
cad="Ochentaycinco";
l.setText(cad);
break;
case 84:
cad="Ochentaycuatro";
l.setText(cad);
break;
case 83:
cad="Ochentaytres";
l.setText(cad);
break;
case 82:
cad="Ochentaydos";
l.setText(cad);
break;
case 81:
cad="Ochentayuno";
l.setText(cad);
break;
case 80:
cad="Ochenta";
l.setText(cad);
break;
case 79:
cad="Setentaynueve";
l.setText(cad);
break;
case 78:
cad="Setentayocho";
l.setText(cad);
break;
case 77:
cad="Setentaysiete";
l.setText(cad);
break;
case 76:
cad="Setentayseis";
l.setText(cad);
break;
case 75:
cad="Setentaycinco";
l.setText(cad);
break;
case 74:
cad="Setentaycuatro";
l.setText(cad);
break;
case 73:
cad="Setentaytres";
l.setText(cad);
break;
case 72:
cad="Setentaydos";
l.setText(cad);
break;
case 71:
cad="Setentayuno";
l.setText(cad);
break;
case 70:
cad="Setenta";
l.setText(cad);
break;
default:
l.setText(cad);
JOptionPane.showMessageDialog(null,"Error de
datos","Error",JOptionPane.ERROR_MESSAGE);
na.setText("");
t1.setText("");
t2.setText("");
t3.setText("");
t6.setText("");
t7.setText("");
t8.setText("");
t5.setText("");
t1.requestFocus();
na.requestFocus();
}
});
this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
x.setSize(200,530);
x.setVisible(true);
Equivalencias
import java.awt.event.ActionEvent;
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionListener;
JLabel dn;
JLabel r;
JTextField n;
JButton e;
JButton l;
public Segundos() {
super.setTitle("Segundos");
this.setLayout(c);
dn=new JLabel("Dame una cantidad de Segundos");
n=new JTextField(10);
e=new JButton("Equivalencia");
l=new JButton("Nuevo");
r=new JLabel("resultado");
this.add(dn);
this.add(n);
this.add(l);
this.add(e);
this.add(r);
e.addActionListener(new ActionListener(){
try{
int numero;
String cad;
cad=n.getText();
numero=Integer.parseInt(cad);
cad="";
int h,m,s,mod;
h=numero/3600;
mod=numero%3600;
m=mod/60;
s=mod%60;
r.setText(cad);
}catch(Exception f){
JOptionPane.showMessageDialog(null,"Error de datos",
"Error",JOptionPane.ERROR_MESSAGE);
});
l.addActionListener(new ActionListener(){
n.setText("");
});
x.setVisible(true);
x.setSize(400, 100);
x.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
Tabla de Multiplicar
import java.awt.event.ActionEvent;
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionListener;
JTextField n;
JButton verificar;
JButton limpiar;
JTextArea Textarea;
public tabla() {
super.setTitle("Tabla de Multiplicar");
this.setLayout(capa);
n=new JTextField(10);
verificar=new JButton("Verificar");
Textarea.setAutoscrolls(true);
Textarea.setColumns(10);
Textarea.setRows(15);
this.add(l1);
this.add(n);
this.add(verificar);
this.add(Textarea);
this.add(limpiar);
this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
verificar.addActionListener(new ActionListener(){
cad=n.getText();
nu=Integer.parseInt(cad);
cad="";
for(int i=1;i<=10;i++){
res=nu*i;
Textarea.setText(cad);
});
limpiar.addActionListener(new ActionListener(){
n.setText("");
Textarea.setText("");
});
x.setSize(300,400);
x.setVisible(true);
}
Calculadora
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
Button b;
public Calculadora() {
setTitle("Calculadora");
setSize(200, 200);
Pantalla();
Teclado();
}
private void Pantalla() {
pantalla.setText("0");
pantalla.setAlignment(Label.RIGHT);
pantalla.setForeground(Color.black);
pantalla.setBackground(Color.white);
panel.add(pantalla);
add("North", panel);
addBoton("7", Color.black);
addBoton("8", Color.black);
addBoton("9", Color.black);
addBoton("/", Color.black);
addBoton("4", Color.black);
addBoton("5", Color.black);
addBoton("6", Color.black);
addBoton("*", Color.red);
//addBoton("sqrt", Color.red);
addBoton("1", Color.black);
addBoton("2", Color.black);
addBoton("3", Color.black);
addBoton("-", Color.red);
//addBoton("AC", Color.red);
addBoton("0", Color.black);
//addBoton("+/-", Color.red);
//addBoton(".", Color.red);
addBoton("+", Color.red);
addBoton("=", Color.red);
addBoton("C", Color.red);
add("Center", panel2);
b = new Button(n);
b.setForeground(color);
panel2.add(b);
b.addActionListener( this );
}
String s = pantalla.getText();
float valor = 0;
try {
} catch (Exception e) {
if (!digit.equals("C")) return;
if ("0123456789".indexOf(digit) != -1) {
if (nuevo) {
nuevo = false;
pantalla.setText(digit);
} else {
pantalla.setText(s + digit);
} else if (digit.equals(".")) {
if (nuevo) {
nuevo = false;
pantalla.setText("0.");
} else {
pantalla.setText(s + digit);
} else if (digit.equals("sqrt")) {
valor = (float)Math.sqrt(valor);
pantalla.setText(String.valueOf(valor));
nuevo = true;
} else if (digit.equals("+/-")) {
valor = -valor;
pantalla.setText(String.valueOf(valor));
nuevo = true;
} else if (digit.equals("C")) {
resultado_total = 0;
pantalla.setText("0");
ultimo = "=";
nuevo = true;
} else {
char c = ultimo.charAt(0);
switch (c) {
ultimo = digit;
nuevo = true;
pantalla.setText(String.valueOf(resultado_total));
//cal.show();
cal.setVisible(true);
cal.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
Suma
import javax.swing.JOptionPane;
public class mensajes {
JOptionPane.showMessageDialog(null,"Desea
continuar?","Cuestion",JOptionPane.QUESTION_MESSAGE);
try{
int a=Integer.parseInt(n1) ;
int b=Integer.parseInt(n2);
int s=a+b;
}catch(Exception e){
JOptionPane.showMessageDialog(null, "Error de
Dato","Burrooooooo!",JOptionPane.ERROR_MESSAGE);
Unidad II
import java.awt.*;
import javax.swing.*;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
/**
*Guadalupe Namorado
*/
Color color=Color.CYAN;
JTextArea Textarea;
public TextArea() {
this.setLayout(capa);
Textarea.setColumns(10);
Textarea.setRows(15);
colores=new JComboBox(col);
colores.setMaximumRowCount(6);
colores.addItemListener(new ItemListener(){
//if(e.getStateChange()==ItemEvent.SELECTED){
int c=colores.getSelectedIndex();
if(c==0)
color=color.BLUE;
else
if(c==1)
color=color.RED;
else
if(c==2)
color=color.YELLOW;
else
if(c==3)
color=color.GREEN;
else
if(c==4)
color=color.ORANGE;
else
if(c==5)
color=color.MAGENTA;
Textarea.setBackground(color);
repaint();
});
Textarea.setBackground(color);
add(colores);
add(Textarea);
repaint();
}
caja.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
caja.add(x);
caja.setBackground(Color.BLACK);
caja.setSize(300, 300);
caja.setVisible(true);
Ejemplos de RadioButton
package Radio;
import java.awt.*;
import javax.swing.*;
import java.awt.event.*;
import java.awt.peer.FontPeer;
import javax.swing.plaf.basic.BasicComboBoxUI.ItemHandler;
// atributos
JTextField texto;
JRadioButton rtp;
JRadioButton rtn;
JRadioButton rtc;
JRadioButton rtnc;
Font tplano;
Font tnegrita;
Font tcursiva;
Font tnegritacursiva;
ButtonGroup gruporadiobuttons;
public RadioButtons() {
this.setLayout(capa);
this.setSize(365, 150);
this.add(texto);
// se crea el buttongroup
gruporadiobuttons.add(rtp);
gruporadiobuttons.add(rtn);
gruporadiobuttons.add(rtc);
gruporadiobuttons.add(rtnc);
// se crean las fuentes
this.add(rtp);
this.add(rtn);
this.add(rtc);
this.add(rtnc);
rtp.addItemListener(new RadioButtonHandler(tplano));
rtn.addItemListener(new RadioButtonHandler(tnegrita));
rtc.addItemListener(new RadioButtonHandler(tcursiva));
rtnc.addItemListener(new RadioButtonHandler(tnegritacursiva));
// clase interna
Font font;
font = f;
texto.setFont(font);
ventana.setVisible(true);
ventana.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
import java.awt.*;
import java.awt.event.ItemEvent;
import javax.swing.*;
import java.awt.Event.*;
import java.awt.event.ItemListener;
/**
* @author guadalupe
*/
JButton boton;
JRadioButton bp;
JRadioButton bm;
JRadioButton bg;
ButtonGroup gruporadio;
public Botton() {
super("Tamaño RadioButton");
this.setLayout(capa);
this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
this.setSize(400, 400);
//*****Instanciar*******
boton=new JButton("Botton");
gruporadio=new ButtonGroup();
gruporadio.add(bp);
gruporadio.add(bm);
gruporadio.add(bg);
//************Agregando los radio buttons a la ventana y el Boton*************
this.add(bp);
this.add(bm);
this.add(bg);
this.add(boton);
bp.addItemListener(new RadioButtonHandler(80,150));
bm.addItemListener(new RadioButtonHandler(150,200));
bg.addItemListener(new RadioButtonHandler(220,350));
int x,y;
this.x = x;
this.y = y;
boton.setSize(x, x);
}
}
x.setVisible(true);
Usando colorchooser
package Mezclador;
import java.awt.*;
import javax.swing.*;
import java.awt.event.*;
public Colores() {
this.setLayout(capa);
panel.setBackground(color);
cambio=new JButton("Cambiar color");
// sino se elije color que se le asigne el mismo color que se le habia asignado al
principio
if(color==null){
color=Color.LIGHT_GRAY;
panel.setBackground(color);
});
this.add(panel);
this.add(cambio);
this.setSize(440, 130);
this.setVisible(true);
}
}
package Mezclador;
import java.awt.*;
import javax.swing.*;
import java.awt.event.*;
x.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
package Triangulo;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.*;
/**
* @author Administrador
*/
Color color=Color.CYAN;
super.paintComponent(g);
this.setBackground(Color.DARK_GRAY);
g.setColor(color);
poli.addPoint(120, 120);
g.fillPolygon(poli);
public Equilatero() {
this.setLayout(capa);
cambio=new JButton("Cambiar color");
cambio.addActionListener(new ActionListener(){
// sino se elije color que se le asigne el mismo color que se le habia asignado al
principio
if(color==null){
color=Color.LIGHT_GRAY;
// g.setBackground(color);
});
this.add(cambio);
equi.setBackground(Color.BLACK);
equi.add(e);
equi.setSize(250, 300);
equi.setVisible(true);
import java.awt.*;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
import javax.swing.*;
/**
* @author Usuario
*/
Color color=Color.DARK_GRAY;
public Figura() {
FlowLayout capa=new FlowLayout();
this.setLayout(capa);
colores=new JComboBox(col);
colores.setMaximumRowCount(6);
colores.addItemListener(new ItemListener(){
//if(e.getStateChange()==ItemEvent.SELECTED){
int c=colores.getSelectedIndex();
if(c==0)
color=color.BLUE;
else
if(c==1)
color=color.RED;
else
if(c==2)
color=color.YELLOW;
else
if(c==3)
color=color.GREEN;
else
if(c==4)
color=color.ORANGE;
else
if(c==5)
color=color.WHITE;
repaint();
});
add(colores);
repaint();
super.paintComponent(g);
this.setBackground(Color.gray);
g.setColor(color);
Polygon poli=new Polygon();
poli.addPoint(100, 10);
g.fillPolygon(poli);
equi.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
equi.setBackground(Color.BLACK);
equi.add(e);
equi.setSize(250, 300);
equi.setVisible(true);
Combox de Imágenes
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
/**
* @author Usuario
*/
};
public Imagenes() {
super("Probando JComboBox");
this.setLayout(capa);
imagenes=new JComboBox(nombres);
imagenes.addItemListener(new ItemListener() {
if(event.getStateChange()== ItemEvent.SELECTED)
etiqueta.setIcon(iconos[imagenes.getSelectedIndex()]);
});
add(imagenes);
etiqueta=new JLabel(iconos[0]);
add(etiqueta);
x.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
x.setSize(350,350);
x.setVisible(true);
Dibujando Lineas
import java.awt.*;
import javax.swing.*;
super.paintComponent(g);
this.setBackground(Color.BLACK);
g.setColor(Color.red);
// se crea el rectangulo
g.setColor(Color.BLUE);
g.setColor(Color.LIGHT_GRAY);
// se crea
g.setColor(Color.ORANGE);
g.setColor(Color.YELLOW);
g.drawRoundRect(290, 40, 90, 55,20, 20);
g.setColor(Color.yellow);
g.setColor(Color.magenta);
g.fillOval(290, 100,90,55);
import java.awt.*;
import javax.swing.*;
/**
* @author lupis
*/
ventana.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
ventana.add(x);
ventana.setSize(400, 210);
ventana.setVisible(true);
package Barco;
import java.awt.*;
import javax.swing.*;
super.paintComponent(b);
this.setBackground(Color.LIGHT_GRAY);
b.setColor(Color.RED);
barco.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
Barco b=new Barco();
barco.add(b);
b.setBackground(Color.BLUE);
barco.setSize(230, 250);
barco.setVisible(true);
package Casa;
import java.awt.*;
import javax.swing.*;
super.paintComponent(c);
this.setBackground(Color.DARK_GRAY);
c.setColor(Color.GREEN);
c.setColor(Color.LIGHT_GRAY);
c.setColor(Color.white);
c.setColor(Color.WHITE);
casa.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
casa.add(c);
casa.setBackground(Color.black);
casa.setSize(400,400);
casa.setVisible(true);
package Estrella;
import java.awt.*;
import javax.swing.*;
super.paintComponent(g);
this.setBackground(Color.LIGHT_GRAY);
g.setColor(Color.darkGray);
est.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
est.add(e);
est.setSize(300, 300);
est.setVisible(true);
package Estrellas;
import java.awt.*;
import javax.swing.*;
this.setBackground(Color.BLACK);
e.setColor(Color.RED);
// Triangulo 1
// Triangulo 2
e.setColor(Color.ORANGE);
// Triangulo 1
// Triangulo 2
e.setColor(Color.CYAN);
// Triangulo 1
// Triangulo 2
est.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
est.add(e);
est.setSize(360, 400);
est.setVisible(true);
package Exagono;
import java.awt.*;
import javax.swing.*;
/**
*
* @author lupis
*/
super.paintComponent(g);
this.setBackground(Color.black);
g.setColor(Color.RED);
exa.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
exa.add(e);
exa.setSize(200, 150);
exa.setVisible(true);
package Greca;
import java.awt.*;
import javax.swing.*;
super.paintComponent(d);
this.setBackground(Color.black);
d.setColor(Color.green);
d.drawLine(20,45,20, 140);
ventana.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
c.setBackground(Color.BLACK);
ventana.add(c);
ventana.setSize(230, 200);
ventana.setVisible(true);
package Octagono;
import java.awt.*;
import javax.swing.*;
/**
* @author lupis
*/
super.paintComponent(g);
this.setBackground(Color.black);
g.setColor(Color.RED);
pen.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
pen.add(o);
pen.setSize(200, 300);
pen.setVisible(true);
package Pentagono;
import java.awt.*;
import javax.swing.*;
/**
* @author lupis
*/
super.paintComponent(g);
this.setBackground(Color.black);
g.setColor(Color.RED);
}
public static void main(String[] args) {
pen.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
pen.add(p);
pen.setSize(200, 300);
pen.setVisible(true);
package Triangulos;
import java.awt.*;
import javax.swing.*;
/**
* @author lupis
*/
super.paintComponent(g);
this.setBackground(Color.black);
g.setColor(Color.RED);
equi.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
equi.add(e);
equi.setSize(250, 300);
equi.setVisible(true);
package Triangulos;
import java.awt.*;
import javax.swing.*;
/**
* @author lupis
*/
super.paintComponent(g);
this.setBackground(Color.black);
g.setColor(Color.RED);
esc.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
esc.add(e);
esc.setSize(250, 150);
esc.setVisible(true);
package java2d;
import java.awt.*;
import javax.swing.*;
import java.awt.Graphics2D.*;
import java.awt.geom.GeneralPath;
import java.util.*;
this.setBackground(Color.BLACK);
// arreglo de puntos
int puntosx[]={55,67,109,73,83,55,27,37,1,43};
int puntosy[]={0,36,36,54,96,72,96,54,36,36};
Graphics2D g2d=(Graphics2D)g;
estrella.moveTo(puntosx[0],puntosy[0]);
for(int i=1;i<puntosx.length;i++){
estrella.lineTo(puntosx[i],puntosy[i]);
estrella.closePath();
g2d.translate(200, 200);
for(int i=1;i<=20;i++){
g2d.rotate(Math.PI/10);
g2d.setColor(new
Color(random.nextInt(256),random.nextInt(256),random.nextInt(256)));
g2d.fill(estrella);
package java2d;
import java.awt.*;
import javax.swing.*;
import javax.swing.JFrame;
x.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
x.add(y);
x.setBackground(Color.white);
x.setSize(400, 400);
x.setVisible(true);
}
--------------------
1Introducción
dado porque dicha bolsa de aire tiene que estar completamente inflada antes de que
se elimina cualquier utilidad de la bolsa (y del software que la controla) dado que el
En la actualidad, los sistemas de tiempo real juegan un papel vital y cada vez más creciente
en nuestra sociedad. Los mismos se pueden encontrar en muchos sistemas desde los muy
simples, hasta los más complejos. Por ejemplo, pueden hallarse con facilidad en el control
lanzamiento espacial y en la robótica. Los sistemas de tiempo real más complejos son muy
costosos por lo que en la actualidad los gobiernos e industrias en los países desarrollados
tiempo real demanden, de la plataforma de cómputo que los soportan, requerimientos que
Los sistemas de tiempo real también tienen que operar con un alto grado de confiabilidad.
se cumplen los plazos de todas las tareas críticas en tiempo. Estos cálculos toman como
(si acaso estos pueden ser servidos). En algunos sistemas, estos cálculos de factibilidad se
hacen fuera de línea; mientras que en otros, destinados a ambiente más dinámicos, se hacen
en línea conforme varía la carga de trabajo del sistema. En este último caso, si los cálculos
arrojan que es imposible dar servicio a tiempo a los sucesos, el sistema debe decidir sobre
un plan de acción que garantice la respuesta de las tareas críticas en detrimento de las
menos críticas.
predecibilidad. Para el logro de esta predecibilidad, este tipo de sistemas operativos tienen
peor caso de todos los servios del sistema, o de la disponibilidad de memoria física).
prioridades para todas las actividades en el sistema. Esta suposición contrasta con el
modelo real soportado por el sistema operativo, en el cual las Rutinas de Servicio de
de predecir el comportamiento temporal del sistema. En los casos en que las ecuaciones
o Existen severas restricciones en cuanto a los servicios del sistema que se pueden
invocar dentro de las ISRs. Esto a su vez, trae como consecuencia un aumento de la
software resultante.
administración de interrupciones son adecuados para sistemas que demandan una alta
capacidad (o caudal) de procesamiento, como por ejemplo los sistemas operativos de red y
de bases de datos; así mismo, presentan severas restricciones para el caso de sistemas que
requieren un alto grado de confiabilidad y, peor aún, carecen del determinismo necesario
para establecer las garantías de respuesta temporal que demandan las aplicaciones de
tiempo real. Estas dificultades son de un grado tal, que incluso algunos investigadores han
optado por eliminar completamente el uso de las interrupciones en los sistemas de tiempo
real.
1 Número de trabajos procesados por unidad de tiempo.
interrupciones que sean más adecuados para los sistemas operativos destinados a
temporal y la confiabilidad.
Para la consecución de nuestro objetivo, partimos de la hipótesis de que, a pesar de que los
actuales dan como resultado la existencia de dos tipos de actividades asíncronas ejecutables
denominadas ISRs y tareas (procesos o hilos), cada una de ellas con esquemas propios de
o Analizamos las razones por las cuales los esquemas tradicionales de administración de
real.
o Argumentamos las razones por las cuales, una estrategia completamente integrada para
o Hacemos una evaluación del esquema completamente integrado propuesto por nosotros
eventos externos, e cual permite poner de manifiesto bajo que condiciones pudiera
administración de interrupciones para luego exponer las dificultades que este presenta para
trabajo; así como, se fundamentan las ventajas que para el caso de sistemas de tiempo real
interrupciones de bajo nivel portable que puede ser utilizado como apoyo para la
último, se hace un contraste del modelo integrado propuesto con las alternativas existentes
inconvenientes.
una de las estrategias de emulación. Este análisis pone de manifiesto los compromiso entre
respuesta temporal en el peor caso y eficiencia de cada una de las variantes de emulación.
de Interrupciones
En este capítulo damos a conocer las dificultades que presentan los mecanismos actuales de
manejo de interrupciones para el caso de los sistemas operativos de tiempo real. Primero se
brindan los sistemas operativos (sean o no de tiempo real) para la administración del
mecanismo de interrupciones del hardware (sección 2.5). Todo esto sirve de marco de
referencia para finalmente presentar las dificultades que presenta este esquema para el caso
Dos fuerzas significativas provocan que los sistemas de cómputo penetren cada vez más en
la vida cotidiana de las nuevas generaciones de seres humanos: por un lado está la
necesidad cada vez más creciente en la sociedad moderna de equipos con mayores
empotrados.
Un sistema embebido es un sistema de cómputo incluido en otro sistema y que forma parte
esencial de él. Dicho en otras palabras, no se percibe como un sistema de cómputo, sinó
características significativas que los diferencian de los sistemas de escritorio. Entre ellas,
una de las más importantes y que está presente en muchos de ellos es la necesidad de operar
en tiempo real.
sistema de cómputo que tiene que responder con restricciones de tiempo y de manera
corrección no sólo depende del resultado lógico del cómputo, sino también del tiempo en el
cuál este se produce [88]. Es decir, cada resultado debe darse en un plazo de tiempo
De manera general, las restricciones de tiempo en un sistema de tiempo real pueden ser
que pueden clasificarse como duros (͞hard͟), firmes (͞firm͟), o suaves (͞soft͟). Un plazo
que un plazo es firme si el resultado producido por la tarea correspondiente, deja de ser útil
plazo que no es ni duro ni firme se dice que es suave, esto es, el resultado tiene mayor
cumplimiento.
Una concepción errónea muy común y arraigada es la creencia de que un sistema de tiempo
real sólo tiene que ser rápido. Básicamente, ser rápido generalmente es una condición
necesaria, pero no suficiente. Un sistema de tiempo real necesita cumplir plazos explícitos
predecible. Esto es, debiera ser posible demostrar en la fase de diseño que todas las
las cotas en los tiempos de ejecución y los plazos de todas las tareas de manera que puede
ser analizado formalmente. De este modo, el diseñador puede tener una temprana
tomar así las acciones correctivas apropiadas. En otras palabras, tiempo real no es
Los requerimientos antes descritos traen como consecuencia la necesidad de contar con
sistemas operativos de propósito específicos sobre los cuales poder realizar este tipo de
aplicaciones. A este tipo de sistemas operativos se les conoce como sistemas operativos de
tiempo real.
que se satisfacen los requerimientos, sujeto a las suposiciones que se hagan. En especial, en
cumplimiento de los requerimientos temporales aún bajo suposiciones del peor caso. Esta
cualidad está ausente en los sistemas operativos de propósito general. Un sistema operativo
para aplicaciones de tiempo real confiables tiene que satisfacer los siguientes
requerimientos:
supervisión de plazos).
principal.
de un sistema de tiempo real, tener tal sistema operativo no evita que sobre el se
operativo de tiempo real pero que tiene que responder a comunicaciones a través de una red
Ethernet, nunca será un sistema de tiempo real duro porque Ethernet como tal no es
operativo con multitarea cooperativa como Windows 3.11, el sistema tampoco será de
En otras palabras, un sistema de tiempo real contiene todos los elementos, incluyendo el
operativo de tiempo real es solo un elemento del sistema completo de tiempo real. La
Los sistemas de tiempo real están compuestos por un conjunto de actividades asíncronas o
sistema operativo que se encarga de asignar el tiempo de CPU a las distintas actividades del
restricciones de tiempo.
Los estándares de sistemas operativos de tiempo real actuales están basados casi en su
ITRON ʹ ͞Interfaz for The Real-time Operating system Nucleus͟ y ʅITRON [78]). Para
de planificación:
o Modelos basados en la máxima utilización del procesador que garantiza que el conjunto
de tareas (ʏ1
,ʏ2
, ͙,ʏn
Análisis de Tasa Monótona o RMA (͞Rate Monotonic Analysis͟), presentada por Liu y
los períodos ʹ a menor período mayor prioridad). Según este modelo, el conjunto de
<
inUn
1
21 1 ( )
Tasa Monótona fue presentada por Lehoczky, Sha y Ding en [52] y está basada en los
independientes, es factible de planificar, para todas las fases entre tareas, si y sólo si:
jj
jT
lT
lT
iinC
(k,l) R 1
1
, 1 ,min
o Modelos basados en la obtención del tiempo de respuesta de las tareas. Este método de
prioridades estáticas.
todos los desfases entre tareas, si y sólo si, el tiempo de respuesta de la tarea i es menor
o igual al plazo de dicha tarea (Ri Di) y el tiempo de respuesta puede calcularse como:
jj
iiC
CR
1
1
El soporte de los modelos anteriores por parte del planificador del sistema operativo de
tiempo real es lo que permite que sobre este se puedan construir sistemas de tiempo real
con la certidumbre de que el conjunto de tareas que conforman la aplicación cumpla con las
restricciones temporales
Las interrupciones son cambios en el flujo de control, no ocasionados por el programa que
se ejecuta, sino por algún otro suceso que necesita el servicio inmediato de la CPU por lo
general relacionado con los dispositivos de E/S. Por ejemplo, un programa puede pedirle al
controlador de disco que empiece a transferir información y que genere una interrupción
El controlador de
dispositivo emite
una interrupción.
La CPU termina la
ejecución de la
instrucción actual.
de la interrupción al dispositivo.
Guarda el resto de
la información de
estado de la CPU
Da el servicio que
demanda la
interrupción
Restaura información
de estado de la CPU
Restaura valores
originales del PC
y las banderas
Hardware Software
La Figura 1 muestra, en forma muy simplificada, los pasos y los componentes involucrados
detenga el programa en curso, salve su estado (es decir, se guardan todos los contenidos de
o ISR (del ingles ͞Interrupt Service Routine͟) la cual realiza alguna acción apropiada para
código interrumpido exactamente en él mismo estado en que estaba cuando tuvo lugar la
interrupción, lo cual se logra restaurando los registros internos al estado que tenían antes de
procesamiento.
ejecutan algunos códigos, pero cuando todo termina, la computadora se debe regresar
de E/S por tanto, el mecanismo de interrupción tiene que permitir identificar del origen de
la petición de interrupción. Con ese propósito, por lo general se incluye un determinado
número de líneas de petición de interrupción o IRQ (͞interrupt request line͟), cada una
interrumpir, envía una señal por su línea de petición. Con este arreglo, el contador de
prioridad del procesador). Si el nivel de prioridad actual del procesador es mayor o igual
Para auxiliar al núcleo de la CPU (͞CPU core͟) a administrar las diferentes fuentes, es
común contar con un hardware de interrupciones auxiliar (el cual pudiera estar externo o
contiene varias líneas de petición de interrupción IRQ por donde llegan las peticiones
provenientes de los distintos dispositivos externos y una salida de interrupción que utiliza
siguientes pasos:
en relación con las demás peticiones que podrían haberse emitido de forma
reconocimiento de interrupción.
dirección de la ISR.
6. Por último, la CPU sitúa en la pila el contexto actual, inhabilita las interrupciones, y
salta a la ISR.
CPU
Petición de Interrupción
Reconocimiento
de Interrupción
Vector
EOI
Dispositivo de E/S
PIC
petición de interrupción (ver Figura 2). Como consecuencia de este arreglo, existen tres
individualmente y/o sobre la base de sus prioridades. Típicamente, existen uno o más
abstenerse de solicitarle una interrupción a la CPU mientras se está dando servicio a una
petición de mayor prioridad), el PIC tiene que llevar la pista de que ISR está procesando
la CPU en todo momento. Con este propósito, cada vez que la CPU reconoce una
interrupción que identifica cual ISR debe ejecutar, el PIC también registra que dicha
cuando la CPU ha finalizado de servir una petición. Con este propósito, luego de que la
Interrupt͟). En algunas arquitecturas (como por ejemplo la x86) este comando se lleva a
cabo escribiendo de forma explícita un código apropiado a un registro del PIC. En otras
arquitecturas (por ejemplo los procesadores Z80 y Z180) este comando lo suministra de
debe dar el software (la ISR) a la IRQ está dividido en dos partes: la primera parte es la
que se acaba de mencionar y está dirigida al dispositivo que emitió la petición; mientras
que la segunda, mencionada en el punto anterior, comprende el envío del EOI al PIC.
dependiente del PIC, por lo que es común para todos los dispositivos en un sistema.
Operativo
y las rutinas de software que le dan servicio. En otras palabras, las interrupciones señalan la
mismo que el proceso de señalar cierto evento, como por ejemplo la finalización del uso de
A pesar de estas similitudes, con el afán de lograr una mayor eficiencia y una menor
Las tareas son una abstracción propia del modelo de concurrencia soportado por el núcleo
Las interrupciones, por su parte, son una abstracción del hardware de la computadora y la
posibilidad de controlar de forma directa esta abstracción, quizás con un mayor nivel de
seguridad. Sin embargo, ninguna de estas operaciones es necesaria para las tareas ordinarias
Al estar fuertemente apoyado en el hardware, este enfoque tiene como ventaja un mejor
desempeño del sistema y un menor costo operativo, razón por la cual ha sido el método
Sin embargo este enfoque da como resultado que estos sistemas operativos suministren en
realidad dos formas de actividades asíncronas: los procesos o tareas y las ISRs. Asociado a
semántica diferentes que pueden utilizarse sólo para el código perteneciente a una forma
independientes para cada caso. La Figura 3 muestra algunos ejemplos de esta dicotomía.
Interrupción
Interrupción.
Conmutación
de Contexto
Automática y completamente
transparente al usuario
y restaurar el contexto.
IPC (semáforos)
de Hardware
sistema operativo.
Las ISRs son actividades iniciadas por una fuente de interrupción que demanda un servicio
de acuerdo a sus prioridades de hardware. Las tareas por su parte, se activan por eventos
generados por software (que incluyen eventos periódicos) y su planificación la lleva a cabo
el planificador del sistema operativo según sus prioridades de software. Este esquema con
software, trae como consecuencia que estas últimas se ejecuten sólo cuando no existan
Planificador
del Núcleo.
Hardware de
Interrupciones
Prioridades de
Hardware
Prioridades de
Software
( Manejadores de
Interrupción )
( Tareas )
Máxima
Mínima
a tiempo y las únicas actividades con requerimientos de respuesta en tiempo real, son las
ISRs. En consecuencia, esta disposición tiene sentido, pues logra una baja latencia en las
respuestas a las peticiones de interrupción, permitiendo que no se pierdan los datos sólo por
que existen en el sistema, hay que considerar tanto la sincronización entre actividades del
mismo tipo, como entre actividades diferentes (ISRs y tareas). Según se muestra en la tabla
En el caso de las tareas, la sincronización entre ellas se realiza usando cualquiera de los
El caso más simple (por ejemplo en Windows CE versión 2.0 [95]) es que todos los
niveles de interrupción están habilitados de forma tal que expropian a cualquier tarea.
están inhabilitadas. En esta configuración todas las ISRs pueden suponer exclusión
prioridad y permitir las peticiones de mayor prioridad durante la ejecución de una ISR.
En este esquema, conocido como interrupciones anidadas, cada ISR se ejecuta como
una sección crítica con respecto a las ISRs de menor prioridad y las tareas. Además,
debido a que las interrupciones de la misma prioridad están inhabilitadas, una ISR no
sincronización entre entidades del mismo tipo, sino en la sincronización cruzada entre
tareas e ISRs. Las ISR y las tareas se comunican a través de memoria compartida y todas
las operaciones ejecutadas sobre ésta tienen que ser mutuamente exclusivas. Obsérvese que,
aunque las ISRs son secciones críticas automáticas con respecto a las tareas, lo contrario no
es cierto. Los mecanismos para garantizar el acceso exclusivo a las secciones críticas entre
De ninguna forma, una ISR puede bloquear a la tarea interrumpida. Por tanto, la exclusión
mutua entre ISRs y tareas se puede conseguir sólo inhabilitando las interrupciones
mientras se accede al dato compartido. Sin embargo, no es conveniente inhabilitar de forma
(͞responsiveness͟) del sistema a las interrupciones urgentes. Por tanto, los segmentos de
código que usan el nivel de interrupción de la CPU para sincronización deben situarlo sólo
modo usuario, y a que las aplicaciones no pueden modificar el nivel de prioridad de la CPU
(se ejecutan con todas las interrupciones habilitadas). En estos sistemas, sólo es posible
actuar sobre el nivel de interrupción de la CPU cuando las tareas ejecutan el código del
ningún peligro de que ocurra una conmutación de contexto mientras ha sido alterado el
CPU, será restaurada antes de que sea posible una conmutación de contexto restringiendo
y de Tiempo Real.
(sección 2.5), su empleo presenta serias dificultades en este entorno. En esta sección damos
una panorámica de las dificultades que este esquema presenta en cuatro esferas
necesario suministrar protección contra dos errores comunes: el error del cierre de
El problema del cierre de interrupción roto está asociado a la necesidad de rastrear los
ilustra en la Figura 6.
En la figura una tarea de alta prioridad TH se bloquea esperando un evento externo que será
señalado por la interrupción IH (instante t1). Ello provoca que comience a ejecutarse una
tarea TL de baja prioridad la cual elevará el nivel de interrupción de la CPU hasta el nivel
correspondiente a IL con el propósito de acceder a una sección crítica que comparte con
dicha ISR (instante t2). Si embargo, mientras se ejecuta en la sección crítica se produce una
interrupción de mayor prioridad que provoca la ejecución de la ISR IH. Esta ISR señala el
evento que desbloquea a la tarea TH (instante t4) provocando que esta expropie a la tarea de
misma que pudiera ser inferior al nivel de interrupción de la tarea interrumpida (en este
caso se habilitan todas las interrupciones). Mientras se ejecuta esta nueva tarea TH, puede
ocurrir una interrupción del nivel de prioridad que se quería evitar (IL en el ejemplo). Para
TL
TH
IL
IH
L(L) U()
Menor Prioridad
Mayor Prioridad
t1 t2 t3 t4 t5 t6 t7 t8 tiempo
ISRs
Tareas
cambios al hacer una conmutación de contexto. Aunque esto resuelve los problemas de
seguridad, se hace menos predecible el comportamiento global del sistema porque las tareas
expropiaron.
Para evitar este problema, muchos núcleos obligan a que las tareas siempre eleven el nivel
de prioridad de la CPU al más alto posible. Esto inhabilita todas las interrupciones evitando
Comúnmente una ISR hará al menos una llamada al núcleo para indicar la ocurrencia de
algún evento. Las operaciones de este tipo (por ejemplo un signal sobre un semáforo) no
pueden bloquear a la tarea interrumpida. Sin embargo, pueden provocar que se ponga lista
finalice la ISR, el resto de la misma no se ejecutará hasta que la tarea interrumpida (en el
contexto de la cual se está ejecutando la ISR) sea ejecutada nuevamente en la CPU. Esto
inestable. En consecuencia, si estos servicios se invocan dentro de una ISR, el núcleo tiene
que posponer cualquier conmutación de contexto hasta que la ISR haya finalizado, instante
en que tiene que ejecutar cualquier conmutación de tarea pendiente. Por tanto estos
servicios se tienen que comportar de forma distinta si son invocados desde una ISR o desde
iniciado una ISR. El núcleo incrementará un contador que utiliza para determinar el
nivel de anidamiento de ISRs. Justo antes de finalizar, el código de la ISR invoca a otro
servicio para notificar su salida (por ejemplo leaveISR()). Este disminuye el contador
de anidamiento y al llegar a cero, si hay alguna tarea de mayor prioridad lista, ejecuta la
de este esquema es que pudiera ocurrir una interrupción de mayor prioridad antes de
por nivel y en los cuales el dispositivo que levantó la interrupción original la seguirá
tarea que se estaba ejecutando al inicio de todo el proceso pase nuevamente a ser la
operativos de tiempo real como por ejemplo OSEX [70] y C/OS [48].
directamente al núcleo del sistema. Esto permite que éste determine si está dentro de
La dificultad de este esquema está dada porque una tarea regular pudiera haber elevado
transcurso de ésta se produce una interrupción de mayor prioridad, que activa a una
estaba ejecutando una ISR (ya que se guía por el nivel de interrupción) y pospondrá
también el error del cierre de interrupción roto (ver Figura 6) y por tanto es correcto
sistema.
usado dos alternativas para evitar este error de ͞conmutación muy tarde͟:
podrán ponerse listas tareas de mayor prioridad, por tanto no habrán conmutaciones
pendientes.
de interrupción de la CPU, sino que invocan un servicio del núcleo para restaurarlo.
El núcleo puede entonces verificar si, al restituirse al nivel más bajo de prioridad,
SSX5 [97].
Las diferencias existentes entre los mecanismos de sincronización utilizados según el tipo
particulares para la cooperación entre éstas, en donde sólo debiera existir un número
limitado. Como ejemplo, supóngase la sincronización de condición entre las ISRs y las
para el caso de las ISRs. Esta particularidad introduce todo un conjunto de variantes para
que ahora se tienen que tratar ya sea desechando el dato o situando datos más frescos o
volviendo a obtener los datos anteriores (entre otras posibilidades). Esto, en dependencia de
Manejo de Excepciones
interrumpida, el cual no está preparado para tratar excepciones ocurridas en actividades que
la propagación va a salir de una ISR y si es el caso, detenerla y sólo abortar la ISR. Esto
provoca la necesidad de situar y eliminar un marco de excepción como parte del protocolo
independientes.
requerimientos de ejecución a tiempo de una tarea, tendrán mayor importancia que los de
sistemas de tiempo real, en donde además, los requerimientos de respuesta a tiempo para
algunas interrupciones pueden estar incluso en el mismo rango que los de las tareas con
Ambos espacios de prioridades pueden interactuar de forma que interfieran el uno con el
otro. En específico, las tareas de mayor prioridad del sistema quedan constantemente bajo
la interferencia de los eventos de hardware necesarios sólo para tareas de baja prioridad. Es
posible que las tareas de baja prioridad o incluso tareas con requerimientos de tiempo real
suave que estén asociadas a interrupciones de E/S (por ejemplo la atención al operador) no
de cumplir con los plazos de las tareas y se manifiesta como una disminución en la cota
máxima permisible de utilización de la CPU para que el conjunto de tareas sea factible de
planificar.
Aunque los argumentos antes expuestos en contra del modelo tradicional de manejo de
interrupciones son ya de por sí muy importantes, no son los únicos. Quizás el argumento
más significativo contra de este modelo se puede encontrar en su misma razón de ser:
latencia de interrupción sobre el cuál puede actuar el núcleo del sistema operativo es el
de interrupción estos sistemas hacen todo su esfuerzo por inhabilitar las interrupciones sólo
por períodos de tiempo muy breves. Sin embargo, simultáneamente, este diseño no puede
impedir que las aplicaciones inhabiliten las interrupciones ya que es la única forma posible
En realidad, la respuesta del sistema como un todo a las interrupciones no puede ser mejor
que el tiempo máximo por el cual se inhiben las interrupciones en cualquier parte del
sistema. Como la aplicación puede inhabilitar las interrupciones por más tiempo que el
núcleo, si ello ocurre, la latencia de interrupción en el peor caso será la suma de la latencia
introducida por la CPU y el peor caso del tiempo con interrupciones inhabilitadas de la
aplicación. En conclusión, lo más que puede hacer el núcleo es establecer una cota mínima
2.7 Resumen
tiempo real arroja una rápida respuesta a los eventos externos y un menor costo operativo.
(peticiones de) interrupciones siempre tienen mayor prioridad que cualquier tarea o proceso
de cómputo. Por el contrario, en los sistemas de tiempo real, los requerimientos de tiempo
de respuesta de algunas ISRs pueden estar incluso por debajo que cualquier tarea del
sistema. En este caso, ambos espacios de prioridades pueden interactuar de forma que
interfieran el uno con el otro. Específicamente, bajo el modelo tradicional, las tareas de
sólo para tareas de baja prioridad. Por otro lado, tareas de baja prioridad asociadas a
minimizar esta latencia, el núcleo inhabilita las interrupciones sólo por períodos de tiempo
muy breves. Sin embargo, este diseño no puede impedir que las aplicaciones inhabiliten las
realidad, el tiempo de respuesta del sistema a las interrupciones no puede ser menor que el
tiempo máximo por el cual se inhiben las interrupciones en cualquier parte del sistema.
Dado que la aplicación puede inhabilitar las interrupciones más tiempo que el núcleo, la
latencia de interrupción en el peor caso será la suma de la latencia introducida por la CPU y
conclusión, en el modelo tradicional lo más que puede hacer el núcleo es establecer una
prioridad, para acceder a una sección critica que comparte con una ISR de nivel medio,
eleva el nivel de interrupción hasta ese nivel, puede ocurrir una interrupción de nivel alto
que active a una tarea de alta prioridad y expropie a la tarea de baja prioridad. Esto
tarea de baja prioridad. Para evitar esta situación el núcleo podría mantener el estado de las
predecibilidad del sistema porque las tareas se ejecutarán con varios estados de
alternativa es obligar a que las tareas siempre sitúen el nivel de interrupción más alto
posible, evitando así cualquier conmutación de contexto. Sin embargo, esta solución
menos una llamada al núcleo para indicar la ocurrencia de algún evento. Esta llamada
contexto, antes de que finalice la ISR, el resto de la misma no se ejecutará hasta que la tarea
estos servicios se invocan dentro de una ISR, el núcleo tendrá que posponer cualquier
conmutación de contexto hasta que la ISR finalice. Todas las soluciones existentes
provistas para el modelo tradicional para resolver este problema y que garantizan la
actividad asíncrona, trae como resultado una gran diversidad de situaciones para la
cooperación entre estas, donde solo debería existir un número limitado. Esta situación,
3Antecedentes y Trabajos
Relacionados
interrupciones de Unix seguido por el esquema utilizado por los sistemas operativos más
ponen de manifiesto las dificultades fundamentales que cada uno de esos modelos
presentaron y cómo estas se han ido resolviendo en los sistemas más recientes y por la
actualidad por los sistemas embebidos y de tiempo real. A lo largo de esta exposición se
pone de manifiesto como los sistemas operativos de tiempo real actuales han adoptado
propósito general. Por último, concluimos destacando que ninguna de estas soluciones
interrupciones. Los mejores exponentes de este tipo de sistemas operativos son los sistemas
Unix clásicos (Unix Sexta Edición AT&T [59] y versiones de Berkeley previas al BSD 4.2
[72]).
En los sistemas Unix clásicos el software del sistema operativo (y de manejo de los
dispositivos) estaba dividido en una mitad superior (͞top half͟) y una mitad inferior
forma procedural en el contexto del proceso actual en respuesta a llamadas al sistema. Por
su parte, la mitad inferior incluye todo el código que se ejecuta como parte de las ISRs.
la petición de interrupción. Las mitades superior e inferior del núcleo se comunican a través
arquitectura ha sido ampliamente utilizada por muchos otros sistemas operativos, al punto
2 No confundir esto con los manejadores de interrupción ͞top half͟ y ͞bottom half͟ de Linux.
La terminología
͞top halt͟ y ͞bottom half͟ fue acuñada por el Unix BSD [64] para referirse al código de la mitad
superior e
usa aquí.
Para evitar el acceso concurrente a las estructuras de datos internas del núcleo por
nunca se le quita la CPU a un proceso mientras se ejecuta en la mitad superior del núcleo
(dentro de una llamada al sistema) para darle el control a otro proceso. Esto no sucede ni
siquiera cuando la interrupción del reloj detecta que ha vencido el cuanto de tiempo del
proceso actual mientras está dentro del núcleo. Si esto sucede, la replanificación (o
invocación del planificador para llevar a cabo la conmutación de contexto) no tiene lugar
inmediatamente; en su lugar, la ISR del reloj simplemente activa una bandera interna del
núcleo3 para indicarle a éste que ejecute el planificador después de que se haya finalizado la
llamada al sistema y se esté por devolver el control al modo usuario4. El resto de las
replanificación; en su lugar, sólo solicitan que esta se produzca (cuando sea posible) y
siempre devuelven el control al mismo código del núcleo que se estaba ejecutando previo a
la interrupción.
Dentro (de la mitad superior) del núcleo de Unix los procesos deben renunciar
proceso ha finalizado sus actividades en modo núcleo y está en camino de retornar al modo
usuario (si verifica que la bandera interna solicita una replanificación ʹ según se dijo antes);
3.1.3 Sincronización de condición dentro del núcleo (y entre mitad superior e inferior)
Es común que un proceso ejecutando el código (de la mitad superior) del núcleo necesite
esperar a que finalice algún evento. El ejemplo más obvio es una E/S: cuando un proceso
de transferencia de E/S; sin embargo, puede pasar un largo tiempo antes de que ésta
modo que es la ISR (dentro del manejador de dispositivo) se entere que la transferencia
superior del manejador invoca a sleep cuando quiere esperar por un evento, y la mitad
inferior invoca a wakeup cuando ocurre el evento según se muestra en la Figura 7. En más
detalle:
3 El nombre original de esta bandera en la edición 6 de At&T en SVR3 y BSD 4.3 era runrun y
en Linux,
esta bandera tiene el nombre de need_resched.
usuario (ejecutando el programa de aplicación), la ISR del reloj dentro del núcleo invoca al
planificador de
¿Evento? sleep()
No
sleepqueue wakeup()
Si
¿Evento?
Si
Maneja Evento
Top half
Bottom half
o El proceso emite una llamada al sistema (por ejemplo read()), la cual lo lleva a
modo núcleo.
El carácter no expropiable del núcleo garantiza que ninguna interrupción pueda afectar el
orden de ejecución del código de la mitad superior del núcleo. Sin embargo, la ejecución de
un proceso dentro del núcleo puede ser interrumpida temporalmente por (una ISR de) la
mitad inferior del núcleo en dependencia del nivel de prioridad de interrupción IPL
(͞interrupt priority level͟) actual. Cada interrupción de dispositivo tiene asociado un IPL y
sólo puede interrumpir al procesador si su IPL es mayor que el IPL actual. Mientras se
ejecuta una ISR (código del la mitad inferior), el IPL actual se hace corresponder con el
Para evitar situaciones de carrera durante el acceso a las estructuras de datos compartidas
entre los códigos de la mitad superior e inferior; el código de la mitad superior eleva
dichas estructuras de datos compartidas. El valor al cual situar el IPL se elige sobre la base
del nivel de prioridad del dispositivo que comparte las estructuras de datos que la mitad
si se pierden interrupciones5.
proteger mucho más objetos y generalmente tiene que bloquear las interrupciones
La solución adoptada por los Sistemas Operativos de Red (VMS 1.0+[43], BSD 4.2+[64],
NT [85] y Linux [11]) consiste en dividir la atención a las interrupciones en dos niveles que
administración de buffers; o sea, las funciones que tienen que llevarse a cabo antes de
que sea posible volver a habilitar las interrupciones provenientes del dispositivo
desde el manejador de primer nivel (que sitúa en cola la petición) y que permite
postergar el procesamiento de más baja prioridad para que sea ejecutado por un
las ISRs del primer nivel y baja el IPL. Estos manejadores se ejecutan entonces con
última será interrumpida igual que ocurre con las demás tareas de baja prioridad.
Entonces la ISR de primer nivel puede solicitar que se ejecute otra (o incluso la misma)
En sistemas comerciales es común que se emitan múltiples versiones con errores antes de
atinar con la versión
͞correcta͟.
segundo nivel puede ser interrumpida por una ISR de primer nivel, pero nunca puede
ser interrumpida por otra interrupción de software de segundo nivel similar. En otras
palabras, los manejadores de este segundo nivel nunca pueden ser interrumpidos a si
Esta estructura de dos niveles tiene como propósito reducir significativamente la cantidad
de tiempo durante el cual están inhabilitadas las interrupciones de hardware (nivel IPL alto)
El código de la parte del núcleo no dirigido por interrupción (mitad superior) sólo
necesita inhabilitar las interrupciones en los casos en que tenga que acceder a
estructuras de datos compartidas con las ISRs. Si se restringen los servicios que pueden
ser invocados desde las ISRs de primer nivel a unos pocos que no acceden a datos
compartidos con la parte del núcleo no dirigida por interrupción (por ejemplo, sólo a la
Aun en los casos en que el núcleo nunca inhabilitara las interrupciones para acceder a
las secciones críticas, ello no significa que estas estén siempre habilitadas. Cada vez
que se recibe una interrupción, el procesador hace una inhabilitación automática de las
interrupciones al elevar el IPL hasta el nivel de la interrupción correspondiente para
las interrupciones.
segundo nivel mientras se ejecuta el código normal de la parte no dirigida por interrupción
del núcleo. El núcleo puede proteger fácilmente sus secciones críticas con los manejadores
compartidos con la parte no dirigida por interrupción del núcleo para que sea ejecutado en
los manejadores de segundo nivel. Cuando la parte del código del núcleo no dirigida por
interrupción desea entrar en una sección crítica compartida con (los manejadores de
segundo nivel de) la parte dirigida por interrupción, puede inhabilitar a las interrupciones
de software relevantes para evitar que estas los interrumpan. Al final de la sección crítica,
manejador pendiente que haya sido situada en cola durante la sección crítica por las ISRs
de primer nivel.
Cada nivel puede ser interrumpido por el código ejecutándose a un nivel superior, pero
nunca será interrumpido por código ejecutándose al mismo nivel o a un nivel inferior
(excepto para el código de modo usuario que siempre será expropiado por otros procesos
Niveles de
código es no expropiable.
NT y en Linux.
niveles se hacen corresponder con los niveles de petición de interrupción de hardware; así
los núcleos de Unix tradicionales. NT posee una arquitectura alternativa que combina la
arquitectura clásica de micro-núcleo (͞micro-kernel͟) (introducida por sistemas tales como
Mach [3] y Chorus [5]) con la arquitectura estratificada (introducida por el sistema THE
que se denomina núcleo en NT es sólo una parte muy pequeña del ejecutivo que sólo
no expropiable [85]; ello quiere decir que, aunque el código del núcleo puede ser
6 La arquitectura monolítica se refiere a grandes rasgos a que todo el sistema operativo está
contenido dentro
de un gran núcleo que incluye todas las funciones del sistema operativo.
suspendido temporalmente por una interrupción para la ejecución de una ISR esta siempre
devolverá el control al núcleo sin expropiar al hilo actualmente en ejecución (los hilos
dentro del núcleo no son expropiados ni siquiera cuando se le vence su cuanto de tiempo).
Cuando un hilo que se ejecuta dentro del núcleo (con un nivel IPL 0) necesita esperar por
Intel
Nivel
Alpha
hardware
22
Software
nivel de interrupción elevando (por ejemplo como parte de la ejecución de una Llamada a
sino que solicita una interrupción de nivel despacho/DPC para activar el planificador.
Como el IRQL está en ese nivel, o en uno superior, el procesador pone la interrupción en
espera. Cuando el núcleo termina su actividad actual, reduce el IRQL por debajo del nivel
Aunque los servicios de bajo nivel del núcleo no son expropiables estos son simples y se
ejecutan muy rápidamente de manera que, el hecho de que el núcleo sea no expropiable
en la cual una tarea de alta prioridad ve impedida su ejecución debido a la ejecución de una
tarea de menor prioridad y esto se mantiene por un tiempo no predecible). En NT, el grueso
del código del sistema reside en el ejecutivo, quien implementa las políticas y los servicios
son accedidas por las ISRs, no necesita inhabilitar las interrupciones de hardware; sino que,
simplemente eleva el IRQL del procesador al nivel de despacho/DPC. Esto inhabilita todas
las demás interrupciones de software incluyendo la replanificación de hilos. Sólo en el caso
de que se necesite proteger el acceso a datos compartidos entre el núcleo y las ISRs, es que
el núcleo de NT eleva el IRQL del procesador hasta un nivel más alto inhabilitando
Esta estrategia de sincronización funciona en sistemas con un sólo procesador, pero resulta
evita que ocurra una interrupción en otro procesador. El núcleo necesita garantizar también
cierre de giro (͞spin lock͟) asociado a las estructuras de datos globales (compartidas entre
Mientras un hilo retiene un cierre de giro, existe el peligro de que algún otro código
activado por una interrupción en la misma CPU intente obtener el mismo cierre de giro. En
debido a que precisamente él está impidiendo el progreso del código que pudiera liberar el
cierre. Para impedir una posibilidad de bloqueo mutuo como esta, los cierres de giros tienen
alto y mantenerlo en ese nivel mientras se retiene el cierre (se ejecuta la sección crítica).
Una vez que se libere el cierre, el nivel de interrupción debe disminuirse a su valor previo.
En NT, todos los cierres de giro de modo núcleo poseen un IRQL asociado que siempre se
sitúa a nivel de Despacho o superior. Por lo cual, cuando un hilo está intentando adquirir un
cierre de giro, todas las demás actividades al nivel IRQ del cierre o a niveles inferiores
hilo que sostiene un cierre de giro nunca es expropiado (el IRQL enmascara al mecanismo
de despacho). Esto permite que los hilos que retienen cierres de giro continúen
ejecutándose para que el cierre se libere rápidamente. El núcleo usa los cierres de giro con
alguno8.
de los sistemas operativos de red. Primero, la interrupción es manejada por una ISR muy
Procedimiento Diferido o DPC (͞Deferred Procedure Call͟). Las ISR pueden ser
interrumpidas por ISR de mayor prioridad. Por su parte, todas las DPC se ejecutan, al nivel
núcleo de NT es no expropiable [86][77]. Esto hace suponer que a partir de estas versiones si el
núcleo no está
ejecutando código dentro de una sección crítica protegida por cierres de giros (͞spinlocks͟)
puede ser
protección implícita de las regiones críticas contra secciones del núcleo que pudieran estar
corriendo en otra
CPU.
de prioridad de despacho el cual se encuentra por encima del nivel de prioridad de los hilos
de usuario y del sistema (ver Figura 9). Esto significa que se ejecutan con todas las
inhabilitados (todos están al mismo nivel de prioridad). Los DPC se sitúan en cola en este
Al igual que los sistemas Unix tradicionales, las versiones del núcleo de Linux (previas a la
versión 2.6) son no expropiables y también se pueden dividir en dos mitades: una mitad
por las llamadas al sistema (que se corresponde con el ͞top half͟ de BCD) y la otra mitad
dirigida por interrupción (͞interrupt half͟) que contiene el código que se ejecuta como
Igual que en los sistemas Unix clásicos, ninguna interrupción que se reciba mientras un
proceso (o hilo) está ejecutando el código de un servicio del núcleo, provoca una
para solicitarle al núcleo que ejecute el planificador luego de que se haya completado la
llamada al sistema y se esté por devolver el control al modo usuario. Los procesos (o hilos)
Al igual que otros sistemas operativos de red, Linux implementa una arquitectura estándar
dos secciones: la mitad superior (͞Top half͟) constituida por la ISR que recibe la
interrupción de hardware y la mitad inferior (͞Bottom half͟) que hace el grueso del
[101].
Linux 2.2. Sin embargo, debido a que el diseño original de Linux se hizo para máquinas
con una sola CPU, esta arquitectura de bottom half se convirtió en un cuello de botella en
arquitecturas con múltiples CPU. El problema era que aunque cada una de las CPU podía
manejar una interrupción (͞top half͟) a la vez, la capa de bottom half era de simple hilo, de
modo que el procesamiento diferido por todas las ISRs no se podía distribuir entre todas las
simétrico o SMP (͞Symmetric Multiprocessors͟) en los bottom halves. Esto se llevó a cabo
reemplazando los bottom halves originales con los denominados ͞softirq͟ y ͞tasklets͟.
Una softirq representa una petición para que una función específica se ejecute en algún
instante futuro. Si el mismo tipo de softirq se solicita múltiples veces entonces las
pero las invocaciones de la misma tasklet son serializadas con respecto a si mismas. Por
razones de compatibilidad, los bottom halves del viejo estilo se volvieron a implementar
(͞spinlock͟) global dedicado de modo que cuando uno se está ejecutando en alguna CPU,
legados, todavía le imponía una fuerte restricción al desempeño de Linux 2.4 en sistemas
multiprocesador. Para la versión Linux 2.5 los bottom halves del viejo estilo fueron
eliminados y todo el código que lo usaba se modificó para usar ya sea softirqs o tasklets.
Actualmente el término ͞Bottom Half͟ se usa para referirse a cualquiera de los código
En Linux 2.6 se introdujo otro esquema para planificación de funciones diferidas al que se
le denomina colas de trabajo (͞workqueues͟) y que como diferencias más importantes con
las funciones diferibles antes mencionadas se ejecutan en el contexto de hilos del núcleo.
propuestas
Un problema potencial con la arquitectura de interrupciones en dos niveles es que, como las
extremadamente largos gasta la mayor parte o todo su tiempo procesando las interrupciones
diferido al IPL bajo nunca termina antes de que se reciba la siguiente interrupción,
entregando más datos y requiriendo más procesamiento al IPL bajo. El empleo de buffers
puede absorber pequeñas ráfagas de datos recibidos, pero en última instancia el espacio se
puede agotar y los datos tienen que ser desechados. Si esta situación continua entonces no
se hará trabajo útil porque el sistema gasta todo su tiempo recibiendo datos sólo para
Se han propuestos varias técnicas para enfrentar este problema. Todas ellas se apoyan en
reducir la tasa a la cual pueden ocurrir las interrupciones con el propósito de evitar la
llegada del encierro de recepción; si el sistema está sometido a una sobrecarga
cuando los datos provenientes del mismo ocupan más de algún umbral en los buffers
dispositivo.
inferior ʹ ͞bottom half͟ ʹ en Linux). Al acortar las ISRs, el sistema es capaz de responder a
peor caso. Sin embargo, todas estas variantes de manejadores de interrupción diferidos se
planifican antes que todas las tareas de usuario. Por tanto, todo el procesamiento de
interrupciones en estos sistemas se ejecuta efectivamente a una mayor prioridad que todas
las tareas de usuario, incluyendo los procesos de tiempo real. Para las aplicaciones de
usuario críticas en tiempo que están impedidas de ejecutarse, hay poco beneficio en el
hecho de que el trabajo se esté haciendo en manejadores diferidos en vez de en las ISRs
procesamiento diferido. Este tiempo está completamente fuera del control del planificador
del sistema y fluctúa grandemente de modo que introduce una perturbación al planificador
(͞botton half͟) de Linux 2.4. Este consiste en supervisar el tiempo consumido por los
manejadores diferidos y detener las subsiguientes ejecuciones de los mismos una vez que
mismos. De esta forma, el exceso de carga de trabajo por encima del tiempo de umbral
establecido se procesa cuando las peticiones de manejadores diferidos están por debajo del
fijo sino que se obtiene dinámicamente usando una estimación basada en el tiempo
umbral a la carga de E/S consigue evitar variaciones bruscas del tiempo consumido
ejecución de los procesos de usuario; todo ello sin introducir una demora en el servicio a
diferibles (conocidos como bottom halves, softirqs y tasklet ʹ ver sección 3.2.2) luego de la
ejecución de la ISR de primer nivel. Este planificador hace una preedición de la prioridad
del proceso que hizo la solicitud (y que fué beneficiado por la interrupción) para determinar
de forma más precisa cuando planificar la ejecución del manejador diferido. Además, luego
asíncronas (hilos, tareas o procesos) dedicadas. La idea general de este esquema consiste en
bajo nivel genérico el cual hace lo necesario para activar a una actividad asíncrona (hilo,
micro-núcleo; e Interrupciones como hilos del núcleo. A su vez, en este último se presentan
dos variaciones ejemplificadas por el modelo de interrupciones como hilos de Solaris 2.0
(ver sección 3.3.2) y el modelo de interrupciones como hilos de los sistemas de tiempo real
implementa las funciones fundamentales que sirven de base para extensiones modulares y
transportables que implementan los servicios menos esenciales del sistema. Típicamente el
componentes encima del micro-núcleo y se comunican unos con los otros mediante el
empleo de los servicios IPC que suministra el micro-núcleo. Es interesante que los
núcleo como tal. Este sistema fue diseñado por Brinch-Hansen para la computadora RC
El núcleo del sistema de la RC 4000 suministró los mecanismos básicos para crear un árbol
petición y respuesta entre dos procesos. Según el propio Brinch Hansen, la elección de este
esquema estuvo condicionada por una decisión temprana de tratar a los dispositivos de E/S
como procesos, que reciben comandos de E/S como mensajes y devuelven acuses de
recibos o respuestas [15]. Los manejadores de dispositivos se codificaban de forma tal que
convertían las interrupciones del dispositivo y los registros en mensajes. Así, un proceso
de dispositivo crearía un mensaje a partir del carácter de entrada y lo enviaría al que está
El sistema Mach [3], se basó en los mismos principios, acuñando el término micro-núcleo
(͞microkernel͟). Otro micro-núcleo contemporáneo con Mach fue Chorus [75], ambos
micro-núcleo. Mach, Chorus y otros muchos seguidores de finales de la década de 1980 son
dispositivo (͞device drivers͟) como servidores a nivel de usuario fuera del núcleo. Esto
Así los manejadores pueden distribuirse a los usuarios finales independientemente del
mecanismos que les permitan a los manejadores de dispositivo el acceso a los dispositivos y
captura todas las interrupciones pero no se involucra en el manejo específico del dispositivo
lugar sólo genera un mensaje para el proceso o hilo de nivel de usuario asociado con la
completamente fuera del núcleo en el contexto de una tarea hilo o proceso de la forma
tiene la ventaja adicional de que los manejadores de dispositivo se benefician del empleo de
Driver thread:
do
else . . .
while (TRUE);
3.3.2 Modelo de manejo de interrupciones como Hilos del Núcleo en Solaris 2.0.
2.x (SunOS 5.0) [31]. En Solaris un hilo de núcleo es la entidad fundamental que es
planificada y despachada en las CPUs del sistema. Los hilos de núcleo son muy ligeros,
sólo poseen una pequeña estructura de datos y una pila. La conmutación entre hilos de
virtual. Los hilos de núcleo (y el núcleo de Solaris) son completamente expropiables (los
en el que las interrupciones son manejadas como hilos del núcleo. Estos hilos de
interrupción pueden crearse dinámicamente y se les asigna una mayor prioridad que a
todos los demás tipos de hilos. Ellos usan las mismas primitivas de sincronización que los
demás hilos y por tanto se pueden bloquear si necesitan un recurso retenido por otro hilo.
En consecuencia, el núcleo no necesita utilizar el IPL del procesador para protegerse de las
excepcionales [45].
costoso crear un nuevo hilo para cada interrupción. El núcleo mantiene un banco de hilos
contiene un hilo por nivel de interrupción por cada CPU, más un único hilo en todo el
dentro del núcleo eleva el IPL para evitar interrupciones adicionales del mismo nivel o de
nivel inferior. Luego asigna un hilo de interrupción desde el banco y conmuta el contexto
(͞pinned͟), lo que significa que no puede ejecutarse en otra CPU. Cuando el hilo de
interrupción, este se ejecuta sin ser inicializado completamente. Esto significa que no es un
hilo ͞con todas las de la ley͟ y no puede ser desplanificado. La inicialización se completa
estado completo del hilo de interrupción convirtiéndose en un hilo capaz de ser planificado
las interrupciones. Sin embargo, se evita la necesidad de manipular el IPL del procesador
dejarlas bloqueadas mientras se está dentro de una sección crítica del núcleo)9. Debido a
que las operaciones de sincronización son mucho más frecuentes que las interrupciones, el
resultado es una mejora del desempeño, siempre y cuando las interrupciones no se bloqueen
bloquean. El trabajo de convertir una interrupción en un hilo ͞real͟ se realiza sólo cuando
existe contención por cierre. El compromiso aquí es que el hilo interrumpido queda clavado
termine o se bloquee lo cual puede introducir una inversión de prioridad temporal. Sin
inmediata (sin pasar por la trayectoria normal del planificador) es posible en Solaris por dos
razones:
(1) los hilos de interrupción poseen una prioridad mayor que el resto de los hilos en el
hardware. Esto garantiza que siempre que se recibe una interrupción no puede haber
otro hilo (no asociado a interrupción) de mayor prioridad listo para ser ejecutado.
(2) porque su núcleo es completamente expropiable; o sea, que permite que ocurra una
interrupción (sin necesidad de tener que esperar a que el hilo actual abandone la
9 En [45] se documenta que la carga operativa adicional de recibir una interrupción (respecto
al método
instrucciones las cuales elevan y disminuyen la prioridad de interrupción del procesador. Debe
considerarse
además que el SPARC tiene integrado dentro de la CPU la lógica para controlar el nivel de
interrupción del
lugar en momentos específicos en que el núcleo está en un estado consistente. En este caso
interrupción.
3.3.3 Interrupciones manejadas como hilos en los sistemas Linux para Tiempo Real
Motivados por la necesidad de hacer que el núcleo de Linux fuese más sensible
(͞responsive͟) a los eventos externos de modo que fuese adecuado para aplicaciones con
de hilos del núcleo (Manas Saksena ʹ TimeSys. ʹ [79], Steven-Thorsten Dietrich et. al. ʹ
Montavista ʹ [29], Heursch et. al [36] y Yang et. al. [103]). Estas modificaciones han
tenido el propósito de reducir la latencia de expropiación, la cual puede ser muy elevada en
Estos trabajos estuvieron precedidos por los primeros enfoques para introducir la
expropiación al núcleo de Linux: los parches de expropiación [5][96] y los parches de baja
latencia [104]. Las primeras implementaciones de estos parches protegían las secciones
críticas dentro del núcleo mediante cierres de expropiación (͞preemption locks͟) que
inhabilitaban la expropiación durante las mismas [5]. El siguiente paso fue sustituir los
cierres de expropiación por mutexes de modo que la expropiación fuese posible incluso
mientras el núcleo está dentro de una sección crítica [96]. Estas técnicas lograron reducir
convencional; sin embargo todavía no logran obtener valores suficientemente bajos (ver
mientras se está ejecutando una ISR o incluso los manejadores de segundo nivel.
los manejadores diferidos. Todavía los tiempos de ejecución de los manejadores de primer
nivel o ISRs difieren significativamente de una interrupción a otra. Como las ISRs se
ejecutan con las interrupciones inhabilitadas todavía se hace muy difícil predecir el tiempo
propio contexto de hilos del núcleo. Bajo este esquema, todas las interrupciones (excepto la
del temporizador) se dirigen hacia un manejador de bajo nivel en el núcleo cuyo único
previamente está durmiendo. Este hilo puede entonces ser ejecutado posteriormente con
todas las interrupciones habilitadas y bajo el control del planificador de hilos. Los hilos del
2) Como los hilos del núcleo destinados al manejo de interrupciones son expropiables, si
llega una interrupción de mayor prioridad mientras se está ejecutando el hilo del núcleo,
3) Todas las interrupciones ejecutan una ISR común que da el mismo servicio y consume
el mismo tiempo de ejecución para todas las interrupciones. De este modo, se puede
1) En Solaris 2.x+, las prioridades de los hilos de interrupción se corresponden con las
mismas prioridades de las interrupciones de hardware sólo que mapeadas a la parte más
alta (de mayor prioridad) del espacio de prioridades de los hilos convencionales
2) En Linux, la ISR general que se ejecuta cuando ocurren las interrupciones no esquiva la
trayectoria de planificación normal del núcleo (como ocurre en Solaris 2.x+ ʹ sección
será entonces planificado del mismo modo que los demás hilos.
aceptan una entrada, la procesan, y producen algún tipo de salida. A este tipo de sistemas
real se caracterizan por ser sistemas reactivos (͞reactive systems͟) [34] o dirigidos por
eventos (͞event-driven͟) que pasan una gran parte del tiempo en un estado de espera por
eventos o estímulos ante los cuales reaccionar. Una vez terminadas las acciones de manejo
de estos eventos (reacción), tales sistemas regresan al estado de espera por el siguiente
evento [81].
Los estímulos primarios son generados por el hardware a partir de eventos internos
de hardware. El estimulo primario interno más común es el tic del reloj del sistema (que
marca el paso del tiempo). Los estímulos primarios externos comprenden una amplia
variedad dependiendo de la aplicación de que se trate. Ejemplos de este último tipo son la
depresión de un botón (o tecla), un clic del ratón, la llegada de un paquete de datos, etc.
para manejarlo. Esta reacción puede ser la emisión una acción de respuesta al entorno
tareas listas) de una tarea (hilo o proceso) que previamente no era ejecutable. Estos eventos
ejecución de la misma.
No importa que estos eventos sean internos o externos, una característica importante de los
primarios se hace más evidente dado que, en el caso de los eventos externos, son emitidos
fuera del control del software. En el caso de los eventos de software internos, un análisis
ingenuo pudiera llevar a pensar que al ser generados por el propio software, tienen un
carácter predecible. Sin embargo, aunque es cierto que son emitidos por el software del
sistema, este lo hace sólo en respuesta a los eventos primarios (que están fuera de su
control) lo cual lo convierte en impredecibles. Por ejemplo, los instantes en que se activa
dependen de la tasa con que estos mensajes se reciben y la longitud de los mismos, aspectos
Un aspecto importante del entorno exterior es que este está compuesto por una variedad de
elementos del mundo real (por ejemplo, servo mecanismos, actuadores, magnitudes físicas
sensores) que operan o evolucionan en paralelo e independientemente los unos de los otros
estos sistemas es concurrente por naturaleza. En cada instante pueden existir múltiples
actividades de cómputo a ser ejecutadas. El núcleo del sistema operativo de tiempo real
La ejecución de los elementos de software encargados de manejar los distintos eventos que
cómputo (en un sistema de tiempo real, el tiempo de CPU es el recurso más importante).
Debido a que estos recursos de cómputo son limitados y además debido al conflicto
potencial en las demandas y el acceso a los mismos por parte de las distintas actividades de
disponibles los recursos necesarios para la ejecución del software encargado de su manejo
(por ejemplo el tiempo de CPU se tiene que dedicar a ejecutar otra actividad cuyo plazo de
respuesta es más urgente en ese instante). Como consecuencia, las actividades de software
sino que, es necesario diferir su ejecución según algún algoritmo de planificación que
permita satisfacer los requerimientos de todas las actividades de cómputo bajo las
Dado que en los sistemas de tiempo real el recurso más importante es el tiempo, el
algoritmo de planificación debe ser tal que posibilite el establecimiento de garantías del
cumplimiento de los plazos de respuesta a los eventos externos. Esto se consigue mediante
suposiciones de diseño y determinada caracterización del sistema) sea posible conocer por
anticipado (o sea predecir) los tiempos de respuesta a eventos cuyo instante o patrón de
este sentido podemos concebir la planificación de tiempo real como un mecanismo que le
͞introduce͟ la predecibilidad al sistema y que, de alguna forma, funciona como una barrera
(͞firewall͟) a la impredecibilidad.
A las actividades de cómputo que se ejecutan bajo el control del planificador de tiempo real
tiempo real debería planificar todas las actividades dentro del sistema; sin embargo, en los
sistemas reales algunas cosas están fuera de su control. Ejemplo de ello son: el servicio a
las interrupciones (ejecución de las ISRs); los accesos directos a memoria o DMA; los
alguna razón son ejecutadas con una ͞prioridad͟ mayor que el propio planificador del
sistema11. Todas estas actividades utilizan una fracción de los recursos del sistema (como
tiempo de CPU) pero no están controladas por el planificador de tiempo real por lo que se
11 En realidad estas actividades son planificadas por planificadores que poseen precedencia
sobre planificador
de tiempo real del núcleo del sistema. Por ejemplo, las actividades de DMA son planificadas
por el
controlador del bus del sistema y en muchos esquemas le ͞roban͟ tiempo a la CPU principal en
los accesos al
bus. Las ISRs son planificadas por el controlador de interrupciones del hardware según sus
prioridades de
hardware (como se vio en la sección 2.5.1). Los manejadores de vencimiento de tiempo son
planificados por
el manejador de interrupción del tic de reloj del sistema según sus instantes de vencimiento.
programadores de sistemas de tiempo real llevan a cabo grandes esfuerzos para reducir el
propósito general y los sistemas operativos de tiempo real, la gran mayoría de los núcleos o
cuando más son ligeras adaptaciones de los utilizados en los sistemas de propósito general.
El método usado con mayor frecuencia en sistemas operativos pequeños y ligeros consiste
simple en el cual el sistema operativo no crea ninguna nueva abstracción de alto nivel para
la administración de las interrupciones; sino que, hace uso de las abstracciones brindadas
utilizado en los Unix tradicionales (ver sección 3.1); sin embargo, existen tres diferencias
servicio interno especial del núcleo para desbloquear al proceso en espera del evento
(según el protocolo de dormir/despertar descrito en la sección 3.1.3). En la arquitectura
de manejador unificado, a las ISR les está permitido invocar a cualquier servicio del
sistema operativo para interactuar con las tareas o hilos de aplicación (o solicitar
recursos del sistema) con la única restricción de que este servicio no tenga la
2. Dado que en la arquitectura Unix tradicional, las ISRs no invocan servicios del núcleo,
arquitectura de manejador unificado, los servicios invocados dentro de una ISR pueden
forma explícita el acceso a estas estructuras de datos internas. Como el código invocado
desde una ISR no puede bloquearse para esperar a que estas estructuras sean liberadas,
ISR, hasta tanto el recurso esté disponible. Esto se consigue inhabilitando brevemente
las interrupciones mientras algún servicio del sistema está modificando estructuras de
planificables (ver sección 3.4.5), en el mejor de los casos, su presencia disminuye la eficiencia
del
planificador
13 Aunque los servicios del núcleo no necesitan inhabilitar las interrupciones, si lo hacen
algunas funciones
internas del núcleo que pueden ser invocadas desde las ISRs como por ejemplo las funciones
de
manejadores de dispositivo tienen que inhabilitar las interrupciones para acceder las
estructuras de datos
compartidas entre las partes superior e inferior del manejador de dispositivo (ver sección
3.1.4).
cambios no coordinados a los datos críticos que están siendo utilizados por el código en
ejecución.
que significa que si el código de la ISR provoca que se active una tarea de más
prioridad que la tarea actual mientras la tarea actual está ejecutando algún código del
actual abandone el código del núcleo. El carácter no expropiable del núcleo evita el
Esto significa que si, producto de una llamada a servicio realizada dentro de una ISR, se
requiere que el núcleo sea no expropiable ya que las secciones críticas del núcleo se
HIH
Sincronización de Hardware
No expropiable y
No interrumpible
Tarea
Expropiable e
Interrupible
Cierre de IRQs
Estado
Peticiones de
Interrupción no
Predecibles -IRQs
AltaPrioridad
Baja
Prioridad
Algoritmo de
Planificación en
Tiempo Real
Planificador/caracteristicas
Planificador
del Núcleo
Hardware de
Interrupción
(PIC)
Dispositivo
de E/S
"Barrera a la impredecibilidad"
Variaciones
Núcleo no expropiable:
mediante el protocolo de
dormir/despertar
(sleep()/wakeup()). Es el
Unix Tradicionales.
Núcleo expropiable:
Esquema utilizado por los
Sistemas Operativos de
mediante la inhabilitación
de las interrupciones.
sistema. En el extremo superior de la figura se muestra el dispositivo de E/S que genera las
emisión de las interrupciones por los dispositivos como la planificación de esta por parte
del PIC está fuera del control del planificador del núcleo del sistema y por tanto son
núcleo del sistema el cual (en un sistema de tiempo real) ejecuta un algoritmo de
planificación de tiempo real y por tanto los eventos (de software) que este emite
no predecibles mientras que la parte inferior (bajo el control del planificador de tiempo
En la parte central de la figura aparecen las distintas entidades de ejecución dentro del
sistema. En la parte central superior se representa la emisión de una interrupción que
͞Hardware Interrupt Handler͟). Este HIH está bajo el control del PIC y por tanto es una
ejecutan bajo el control del planificador de tiempo real y por tanto son entidades
planificables. El acceso al área de datos común entre tareas e ISRs (estado) se sincroniza
los sistemas Unix tradicionales). Observe que esta última puede verse como una variación
La sincronización del acceso a las secciones críticas dentro del núcleo mediante la
expropiación del sistema lo cual afecta adversamente el desempeño del sistema. Mientras
más tiempo se pase en una sección crítica con las interrupciones desactivadas, mayor la
no ser que los períodos durante los cuales el sistema operativo inhabilita las interrupciones
temporal de las interrupciones de hardware. Algunos Unix (por ejemplo Xinus [21]) y
muchos núcleos comerciales de tiempo real (por ejemplo ʅC/OS-II [48], ThreadX [49],
RTEMS [69], y la especificación OSEX/VDX [70]) utilizan esta arquitectura.
interrupción en una parte crítica y una parte no crítica (ver Figura 13).
con muy baja latencia y bajo el control del hardware de interrupciones. Esta debería
llevar acabo sólo el procesamiento más crítico en tiempo y no hace uso de ningún
servicio del núcleo. Antes de terminar, el HIH puede solicitar la ejecución de la parte
de que se active al planificador de tareas (de tiempo real) del núcleo. Por tanto, estos
SIH tienen prioridad sobre los hilos, pero son interrumpibles por los HIH si llegan
HIH
SIH
Ejecución
Diferida
CPU
Planificador
Prioridad Media
Peticiones de
Interrupción no
Predecibles -IRQs
Dispositivo
de E/S
Hardware de
Interrupción
(PIC)
Alta Prioridad
No expropiable y
No interrumpible
No expropiable
e interrumpible
Algoritmo de
Planificación en
Tiempo Real
Baja
Prioridad
Planificador
del Núcleo
Expropiable e
Interrupible
de software
Tarea
Estado
Estado
Planificador/caracteristicas
"Barrera a la impredecibilidad"
Variaciones
Núcleo no expropiable:
manejadores de
interrupción de software y
protocolo de dormir/
despertar. Es el esquema
Núcleo expropiable:
Sistemas Operativos de
en dos niveles. La
interrupciones de software
inhabilitando las
interrupciones de software.
Esta arquitectura es muy similar al esquema utilizado en los sistemas operativos de red (ver
sección 3.2) con la diferencia de que muchos de los sistemas operativos de red poseen un
(por ejemplo el esquema de ͞top half/bottom half͟ de Linux). Los sistemas operativos de
tiempo real que utilizan este esquema poseen núcleos expropiables que sincronizan el
manejadores de segundo nivel. Además, los manejadores de segundo nivel pueden invocar
primer nivel. Sin embargo, es importante destacar que, al igual que cualquier otra, esta
arquitectura tiene que impedir el acceso concurrente a las estructuras de datos internas del
siguen siendo entidades no planificables fuera del control del planificador de tiempo real.
embebidos y de tiempo real. Ejemplos de estos junto con la denominación que dan a cada
uno de los niveles son: ISR/Rutina de Servicio Diferida ʹ ISR/DSR o ͞deferred service
OS [71].
de los núcleos de tiempo real modernos realizan el segundo nivel de procesamiento de las
Se mantiene una pequeña ISR (denotada como HIH en la Figura 14) que lleva a cabo el
especial suministrado por el núcleo que permite activar a una IST que se encuentra
encarga entonces de llevar a cabo el servicio adicional que necesite la interrupción. Una vez
activada, esta tarea se ejecutará (igual que cualquier otra) bajo el control del planificador
del núcleo y a una prioridad acorde con los requerimientos de la aplicación. ART [98][99],
HARTIK [1] [19] [20], SPRING [89], Windows CE 3+ [33], Nemesis [53], QNX [37],
Timesys Linux [96] son ejemplos de sistemas que utilizan esta estrategia de procesamiento.
Aunque esta estrategia consigue minimizar la perturbación producida por las ISRs la
ejecución de las mismas todavía está fuera del control del planificador de tiempo real y por
de las ISRs se vuelve significativa cuando la frecuencia de las interrupciones es alta, ya que
esta frecuencia de interrupción tampoco es controlada por el planificador sino que depende
HIH
IST
Objetos
Sincronización
CPU
Planificador
Prioridad Media
Peticiones de
Interrupción no
Predecibles -IRQs
Dispositivo
de E/S
Hardware de
Interrupción
(PIC)
Alta Prioridad
No expropiable y
No interrumpible
No expropiable
e interrumpible
Algoritmo de
Planificación en
Tiempo Real
Baja
Prioridad
Planificador
del Núcleo
Expropiable e
Interrupible
Planificador/caracteristicas
"Barrera a la impredecibilidad"
Ejecución
Diferida
Estado
Tarea
Variaciones
Interrupciones como
IPC: Un manejador de
de interrupción en IPC.
Típico de la arquitectura
de micro-núcleo.
Interrupciones como
interrupciones se hace en
Interrupciones como
seudo-hilos: Las
interrupciones se manejan
en el contexto de hilos de
la conmutación se posterga
la conversión a hilo en el
se bloquea
Figura 14. Arquitectura de Manejo de Interrupción a nivel de Hilo
Con el propósito de evitar las dificultades del modelo tradicional para aplicaciones en
tiempo real (sección 2.6), se han propuesto varias alternativas. La más radical de ellas es
empleo indiscriminado de interrupciones como uno de los errores más comunes entre los
tiempo real [60]. Siguiendo este enfoque se destaca la arquitectura disparada por tiempo
(͞time-triggered architecture͟) propuesta por Hermann Kopetz [46] la cual aboga por
evitar las interrupciones a favor del enfoque basado en encuesta (͞polling-based͟) para
interactuar con los dispositivos. Varios sistemas operativos de tiempo real han optado por
inhabilitar todas las interrupciones externas, excepto aquellas que provienen del
temporizador (necesarias para las aplicaciones básicas del sistema). En este caso, todos los
dispositivos periféricos se manejan ya sea por tareas de la aplicación, las cuales poseen
acceso directo a los registros de las tarjetas de interfaz como sucede en el núcleo RK [51]
dispositivo en eventos de tiempo; o por rutinas dedicadas dentro del núcleo, activadas
forma periódica a los dispositivos como ocurre en el sistema MARS [25]. Cualquiera que
sea el caso, debido a que no se generan interrupciones, las transferencias de datos tienen
interrupciones, tiene como desventaja fundamental una baja eficiencia en el uso de la CPU
en operaciones de E/S, ya sea debido a la espera ocupada de las tareas mientras acceden a
los registros del dispositivo así como al empleo de tareas de encuesta periódicas (y el
adecuado de la encuesta).
Otra dirección menos radical consiste en utilizar las interrupciones pero modelar su efecto
planificación. En esta dirección se destaca el trabajo pionero de Jeffay y Stone [39] donde,
inicialmente en [10], los autores proponen una ecuación de recurrencia para obtener la cota
superior del costo del manejo de interrupciones en ISRs durante cualquier intervalo de
tiempo dado y suponiendo que se conocen los tiempos mínimos entre llegadas delas
válido para esquemas de planificación tanto con prioridades estáticas como prioridades
dinámicas. Más recientemente, varios trabajos han propuesto otros métodosde análisis que
tienen en cuenta las interrupciones como las actividades de mayor prioridad en el sistema.
planificación que integra las técnicas de planificación estática, con técnicas de cálculo de
exacto de tiempo de respuesta que utiliza información acerca de los instantes de liberación
El trabajo de Brylow, Damgaard y Palsberg [17] presenta técnicas de análisis estático para
el análisis de software dirigido por interrupciones al nivel del código ensamblador. Estas
técnicas permiten obtener entre otros aspectos cotas máximas en la latencia de interrupción.
sobrecarga del tratamiento de las interrupciones. La ecuación obtenida permite evaluar los
las ISRs de modo tal que su única función sea enviar una señal a un servidor aperiódico
[87]. Entonces se utilizan los métodos de análisis en tiempo real que tengan en cuenta la
sobrecarga del manejo de interrupciones aquí presentados (por ejemplo [33] y[18])
tenerlo en cuenta a la hora de aplicar los análisis de factibilidad por si mismos no consiguen
los peores casos de esta inversión de prioridad arrojan resultados excesivamente pesimistas
considerablemente los costos del sistema para poder garantizar las respuestas a tiempo en
situaciones no previstas del entorno). En esta situación los sistemas dirigidos por
condición en que las interrupciones externas son señaladas con la suficiente frecuencia
como para que las demás actividades que se ejecutan en el procesador queden en inanición.
que no es más que una pequeña pieza de hardware o software que limita la tasa de llegada
recientemente por Coutinho, Rufino y Almeida en RTEMS utilizando filtros digitales para
3.5 Resumen
En este capítulo hemos visto las diferentes estrategias utilizadas por los sistemas operativos
mecanismos que se han ido introduciendo han tenido como propósito fundamental
comportamiento en el caso promedio y una mayor rapidez de respuesta. Sin embargo, como
capítulo precedente (sección 2.6). En la comunidad de tiempo real podemos identificar dos
para tener en cuenta el costo de las interrupciones (que se administran básicamente por los
eficiente de los recursos del sistema (incluyendo el consumo de energía); mientras que el
segundo, tiene que ser complementado con técnicas de manejo de sobrecargas para poder
lograr predecibilidad (sección 3.4.6) y aún así trae consigo un uso ineficiente de los
recursos ahora debido a que las garantías de factibilidad de planificación sólo pueden
Interrupciones y Tareas
la administración de la ISRs y las tareas se diferencia en todos los detalles, a un nivel más
un modelo que haga desaparecer todas las diferencias entre estas podrá resolver los
simplicidad será más adecuada para el desarrollo de sistemas más confiables y seguros.
En este capítulo presentamos este modelo completamente integrado; así como, las
ecuaciones para los análisis de factibilidad de planificación del modelo tradicional y del
modelo integrado. Estas ecuaciones ponen de manifiesto las ventajas del modelo integrado
que puede ser utilizado para incorporar este esquema integrado en un núcleo de tiempo real.
Por último, hacemos un análisis comparativo de las características del modelo integrado
con respecto a las alternativas existentes para el manejo de eventos externos en sistemas de
tiempo real. Este análisis pone de manifiesto las ventajas de este modelo para este tipo de
sistemas.
entre las tareas convencionales (periódicas, esporádicas) y las tareas que dan servicio a las
por Software o SAT (͞software activated tasks͟); mientras que las segundas son activadas
por interrupciones de hardware o IRQ, por lo que las denominamos Tareas Activadas por
En este modelo integrado las HAT son las tareas que dan servicio a las interrupciones de
hardware y en consecuencia sustituyen a las ISRs. Usamos el término HAT en lugar de, por
destacar la novedad del concepto y diferenciarlo de otros sistemas operativos (como los
descritos en las secciones 3.3 y 3.4.3.3) que sin llevar a cabo una integración total, también
dan servicio a las interrupciones a nivel (o en el contexto) de tareas y que pueden estar
Interrupt Handler͟) universal situado al nivel más bajo del núcleo. Este LLIH convierte las
Con este modelo, lo que antes eran ISRs ahora son HAT que permanecen en algún estado
no elegible para ejecución hasta tanto ocurra la interrupción. El estado específico en que
permanecen las HAT hasta tanto ocurra la interrupción depende del modelo de tareas. Por
ejemplo, para modelos de tareas que se ejecutan permanentemente, las HATs pudieran
mensajes). Cuando sucede la interrupción, el LLIH universal, al nivel más bajo del núcleo,
hará lo necesario para hacer ejecutable la HAT (un signal() sobre el semáforo o variable de
condición o un send() al buzón según sea el caso). Cualquiera sea el caso, el efecto será que
Esta variante suministra una abstracción que delega al núcleo los detalles del tratamiento de
bajo nivel de la interrupción, a la vez que elimina las diferencias entre las ISRs y las tareas.
sincronización y comunicación entre ellas ofrece, entre otras, las siguientes ventajas:
o Las HATs se ejecutan en un ambiente en donde pueden invocar sin restricción cualquier
o Facilita el desarrollo y mantenimiento del sistema, por contar con un mecanismo único
contexto de tarea.
Observe que esta integración es más completa de la que se logra con la implementación de
interrupciones como hilos en Solaris o Linux (sección 3.3) ya que en estos sistemas lo que
sucede en realidad es que las ISRs se ejecutan en el contexto de hilos dedicados; sin
ISRs. Solo que las ISRs ahora se ejecutan en su propio contexto de hilo y no en el contexto
flexible para todas las actividades (sean activadas por eventos de software o de hardware).
las actividades asíncronas sean SAT o HAT utilizando un espacio unificado de prioridades
Planificador
del Núcleo.
Hardware de
Interrupciones
Espacio de
Prioridades
Unificado
( Manejadores de
Interrupción )
( Tareas )
Máxima
Mínima
Es importante destacar que esta planificación integrada incluye la planificación de las IRQs
(no sólo la HAT asociada). Esta es una diferencia fundamental con otras propuestas (como
las descritas en las secciones 3.3 y 3.4.3.3) que integran la planificación de las actividades
(hilos) de interrupción y en las que todavía las mismas IRQs quedan completamente fuera
del control del planificador y por tanto pueden llegar en cualquier momento. La necesidad
de planificar las IRQ como tal es la razón por la cual es necesaria la participación del
Este esquema de planificación unificado permite que a todas las actividades del sistema de
para registrar las ISRs en el núcleo evitando los errores potenciales (sección 2.6.1.2).
(sección 2.6.3).
(sección 2.6.1.1).
IST Tarea
HIH Estado
En el
modelo
integrado
se planifican
las
IRQs
Modelo Integrado
CPU
Peticiones de
Interrupción no
Predecibles -IRQs
Dispositivo
de E/S
Algoritmo de
Planificación en
Tiempo Real
Baja
Prioridad
Planificador
del Núcleo
Expropiable e
Interrupible
Planificador/caracteristicas
"Barrera a la impredecibilidad"
Ejecución
Diferida
Objetos
Sincronización
Variaciones
Implementación en
Algoritmos de emulación
capítulo)
modelo integrado aquí propuesto y que puede ser contrastada con las figuras
anteriores es que ahora las mismas IRQ están bajo el control del planificador de tiempo real
LLIH bajo el control del planificador de tiempo real convirtiéndose en una entidad
completamente predecible.
Interrupciones
Con el propósito de valorar la factibilidad del modelo integrado desde el punto de vista de
Según la teoría del Análisis de Tasa Monótona o RMA, una tarea ti es factible de planificar
U Ui lub (1)
CPU, que para una asignación de prioridades estáticas como la Planificación de Tasa
prioridades dinámico como Primero el Plazo más Próximo (͞Earliest Deadline First͟). Se
supone que la Ui es la fracción de utilización de la CPU debido a la tarea ti, más la fracción
j P(i ) j
iT
U (2)
tareas tj de mayor prioridad que ti con período Tj < Ti y tiempos de cómputo Cj.
Luis Eduardo Leyva del Foyo 66
Ck
Ck
tk
S S(i)
ti
tk
L L(i)
Tk
S < Ti < Tk
Tk
Tk
Ti Ci
ISRs
Tasks
Mayor
Prioridad
Menor
Prioridad tiempo
( no de
tiempo real )
perturbación
(tiempo real)
(tiempo real)
interrupciones independiente.
planificación de una tarea ti de tiempo real crítico se puede describir utilizando la Teoría de
Planificación en Tiempo Real Generalizada [44]. Como se muestra en la Figura 17, en este
Aquella asociada a interrupciones con tiempos mínimos entre llegadas inferiores a los
de la tarea de tiempo real i t pero que no están asociadas a tareas sin requerimientos de
de ISRs tk
S y períodos
Tk
S/Tk
S.
Aquella asociada a ISRs con requerimientos de tiempo real crítico, pero que poseen un
tiempo mínimo entre llegadas mayor que el de la tarea ti. A esta perturbación se llama
expropiar a ti una sola vez. En consecuencia, la utilización en el peor caso debido a una
L/Ti.
entonces como:
() () ()
kLi
kSii
S
k
jPij
iC
TT
U (3)
Los dos primeros términos son idénticos a los de la ecuación (2). Por tanto, el tercer y el
cuarto término se pueden interpretar como la disminución que se produce en la menor cota
prioridades de interrupción. Sea esta disminución Uis, entonces la ecuación (1) se puede
escribir:
donde:
()()
1
kLi
kSii
is C
TT
U C (5)
Obsérvese sin embargo que la ecuación (3) no tiene en cuenta la afectación a la utilización
cual se inhabilitan las interrupciones en cualquier parte del sistema, entonces la ecuación
kLi
kSii
jPij
iCI
TT
T
C
()()()
interrupciones *
is U quedaría como:
kLi
kSii
is C I
TT
UC
()()
* 1 (6)
S, Ck
esta forma, una ISR sólo hará el procesamiento necesario para evitar la pérdida de datos y
activar una tarea que llevará a cabo el servicio adicional que necesite la interrupción.
hilos previamente descrito en la sección 3.4.3.3 (y la Figura 14) del capítulo anterior en el
cual el manejo de la interrupción se divide en una pequeña ISR o HIH y una Tarea de
Servicio de Interrupción o IST. Con este esquema, la respuesta real a un evento ocurre
entonces dentro de esta tarea con la cuál la ISR se comunica. Una vez activada, esta tarea se
ejecutará, igual que cualquier otra, bajo el control del planificador del núcleo y se le puede
hilos. Como se puede observar, ahora cada una de las ISRs (actividades en los conjuntos
correspondientes ISTs. Como puede observarse en la Figura 17, estas ISTs pertenecen al
conjunto U(i) de tareas que poseen menor prioridad que la tarea de ti y por tanto no
ISRs
Mayor
Prioridad
Menor
Prioridad
perturbación
Tk
S Ck
Tk S
S < Ti < Tk
Ti Ci
Tk
L Ck
tk
S S(i)
( no de
tiempo real)
ti
L L(i)
( tiempo real)
ti
(tiempo real)
Tareas
tk
U U(i)
(no interfieren)
En realidad, aunque esta estrategia consigue minimizar la perturbación producida por las
intervalo de tiempo hace al sistema no predecible y puede provocar que algunas tareas
incumplan sus plazos. Con el propósito de abordar este problema algunos sistemas
intervalos de tiempo [68], [74]. Sin embargo, está claro que estos mecanismos introducen
Con el esquema anterior, el tiempo de respuesta de extremo a extremo real del evento
coincide con el tiempo de respuesta en el peor caso de la tarea asociada con la cual la ISR
evento externo utilizando varias estrategias para modelar las ISRs. Sin embargo, nosotros
tarea ti con tiempo de cómputo Ci y tiempo mínimo entre llegadas Ti se puede obtener
jPij
ii
iC
R
RCB
()
(7)
Donde Ri
n es el n-ésimo
tareas con mayor prioridad que ti. El tercer término de esta ecuación representa la
interferencia total que experimenta ti debido a las tareas en el conjunto P(i). Esta iteración
n-1 = Ri
n; o
no satisfactoriamente, cuando Ri
Para tener en cuenta el efecto que sobre el tiempo de respuesta de la tarea ti ejerce la
ecuación (7) la interferencia que los conjuntos de ISRs S(i) y L(i) ejercen sobre el tiempo de
()()
()
1
kLi
kSik
jPij
ii
iCC
R C B (8)
Para una mejor interpretación la ecuación está dividida en dos secciones delimitadas por
paréntesis. La primera sección incluye tres términos idénticos a los de la ecuación (7). El
primer término de la segunda sección introduce la afectación debida las ISRs en el conjunto
S(i) (que pueden expropiar múltiples veces a la tarea ti) mientras que el segundo término de
la segunda sección introduce la afectación debida a las ISRs en el conjunto L(i) (que en el
peor caso, sólo pueden expropiar una vez a la tarea ti). Esta segunda sección se puede
espacio de prioridades de interrupción independiente. Sin embargo, debido a que (8) es una
como se hizo para el caso de la utilización. Mucho más importante es la observación de que
dar como resultado un incremento muy grande en el tiempo de respuesta de la tarea que
como ISRs. Esta sobrecarga se refleja, como es natural, en una disminución del límite
H y tiempo
en una ISRs en el modelo tradicional. Sea I el tiempo total de CPU consumido por el
la interrupción como tal. Entonces, bajo el esquema tradicional, el tiempo total de CPU de
I Hj
Hj
C c
consumo de CPU debido a las ISRs que, en virtud de sus períodos inferiores al período de
la tarea ti, les corresponde una prioridad de tasa monótona mayor a la prioridad de la tarea ti
(conjunto H(i)) y el resto de las tareas de mayor prioridad que no son ISRs (conjunto P(i) ʹ
( ( ) ( )) j H(i)
I Hj
jPiHij
Ii
iT
(9)
Por el contrario, en el modelo integrado todas las actividades en el conjunto H(i) se tratan
consumo de CPU Hj
HP
j C c 2
Donde 2ɷP tiene el cuenta el tiempo de las dos conmutaciones de contextos asociadas a la
expropiada. En consecuencia, para el casi del modelo integrado, la ecuación (2) se puede
escribir como:
( ( ) ( )) ( )
jHi
Hp
jPiHij
Pi
iT
c
(10)
tratamiento de las actividades en el conjunto H(i) como tareas, en lugar de hacerlo como
()()()
22
jHi
pI
jHij
I Hj
jHij
p Hj
PI
iTT
UUU
j H(i )
PI
iT
U (11)
La sobrecarga del modelo integrado será menor que el efecto de inversión de prioridad del
iS
PI
i U U (12)
UiS
PI (ecuación 9)
la mayoría de los casos el ahorro que se obtendría mediante el tratamiento al nivel de ISR
de planificación que este introduce, debido a los diferentes tipos de inversión de prioridad
En cualquier caso, pudiera ser posible diseñar un modelo híbrido con una configuración en
la cual algunas actividades son tratadas como ISRs y otras como HATs para satisfacer la
condición establecida en (12). Por ejemplo, cómo la interrupción del temporizador siempre
tendrá la mayor prioridad en el sistema y nunca será manejada por una aplicación, podría
ser considerada una ISR. Esto reduce el conjunto H(i) y por tanto disminuye Ui
PI.
un micro-núcleo experimental.
establecido como requerimiento que este subsistema suministre un nivel de abstracción tal
que permita que el resto del núcleo sea completamente independiente del hardware de
El diagrama UML de la Figura 19, muestra las relaciones entre los diferentes
componentes14 del núcleo involucrados en la administración de interrupciones. Todos los
componentes del núcleo que tienen que interactuar con el componente de administración de
formato ejecutable que brinda una abstracción bien definida y a cuyos servicios; así como a su
configuración,
se pueden acceder a través de una interfaz de modo que puede ser: (1) intercambiado
fácilmente por otro
misma interfaz.
+setInterruptPriority)() : void
+getInterruptPriority() : Byte
+getIntrSyncSet() : SYNCSET
+initKrnlInt() : void
+endKrnlInt() : void
«interface»
iKRNLINT
+IRQHandler(irq:BYTE)() : void
+panic(irq:BYTE)() : void
«implementation class»
KRNLINT
+enableIrq() : int
+disableirq() : int
+setIrqPriority() : void
+setIrqLevel() : void
+endIrq() : void
+initIrqHardware() : void
+restoreIrqHardware() : void
«interface»
iINTHAL
+addSync() : int
+deleteSync() : int
+getSync() : SYNCID
SYNCSET
Abstracción de Objetos
de Sincronización ofrecida
y sincronización
Figura 19. Diagrama UML que muestra los diferentes módulos del subsistema de
que contiene el código dependiente del hardware y que recibe el nombre de Capa de
iINTHAL.
es el suministro de mecanismos de bajo nivel que le permitan al resto del sistema (en
generar una señal sobre los objetos de sincronización cada vez que se produzca una
Para ello este módulo crea la abstracción de Interrupción del Núcleo cada una de las
predefinidos. A cada interrupción del núcleo se le puede asociar una prioridad dentro de
Núcleo (en la implementación actual este valor puede estar entre 0 y 255). Se ofrece
asociados a cada interrupción. A través de este servicio el resto del núcleo puede
que debe ser invocado como parte del arranque del sistema para inicializar el componente
de administración de interrupción.
bajo nivel. Esta se ocupa de los aspectos dependientes del hardware de interrupción de la
máquina de forma que el resto del sistema sea lo más independiente posible de su
Request͟) y van desde IRQ0 hasta IRQn (donde el número n depende del sistema).
independiente de la arquitectura) que va desde 0 hasta 255, siendo 255 la mayor prioridad y
1 la menor (ver figura Figura 20). El valor 0 está reservado e indica que el nivel de
interrupción correspondiente está inhabilitado. Sin embargo, el HAL asigna a cada petición
de interrupción una prioridad de hardware por defecto cuyo orden de prioridad (no los
valores absolutos) coincide con el impuesto por el hardware de interrupción del sistema. El
HAL de interrupciones sitúa estas prioridades por defecto en el rango configurable que se
255
MaxDefault
MinDefault
IRQLevel Nivel de interrupción por debajo del cual las interrupciones están
concierne al núcleo, las IRQ pueden estar en dos estados: capturadas o ignoradas.
un error y se invoca al servicio panic(). Cuando se inicia el sistema, todas las IRQs
Interrupciones habilitadas: son aquellas cuyo nivel IRQ está por encima del nivel
Interrupciones inhabilitadas: son aquellas cuyo nivel IRQ es menor o igual que el
IRQHandler().
El servicio initIrqHardware() debe ser invocado como parte del arranque del núcleo del
sistema y sirve para inicializar el INTHAL. Como se dijo antes, al iniciar el sistema, todas
las IRQ están inhabilitadas. Puede utilizarse el servicio enableIrq( irq, priority ) para
parámetro priority especifica el nivel de prioridad deseado para la IRQ. Si dicho parámetro
se sitúa en 0 se utiliza el nivel de prioridad por defecto. Este servicio puede devolver
captured
ignored
enabled
disable
setIrqLevel(priority)
/IrqPriority = priority
enableIrq(irq,priority)
/irqPriority = priority
setIrqPriority(irq,priority)
/irqPriority = priority
IRQs; sino que también, arroja un peor caso más grande que el necesario en la
3. Enmascarar todas las IRQs con prioridades menores o iguales que Pc: esta opción
equivale a igualar el nivel de IRQ físico (máscara física) con el nivel de prioridad del
sistema (nivel de IRQ virtual). Con esto se garantiza que una vez ocurrida la
de prioridad del sistema sea mayor o igual al nivel actual. En esta variante, el servicio
sobrecarga en la conmutación de contexto pero ofrece la ventaja de que para cada nivel
de prioridad puede ocurrir sólo una interrupción indebida (su ocurrencia enmascara
todas las demás) lo que arroja el mejor valor posible de la la perturbación en el peor
Una vez ocurrida y enmascarada una interrupción indebida, esta debe recordarse para
cuando la prioridad del sistema baje lo suficiente como para permitir su ocurrencia. En este
del servicio del HAL setIrqLevel(). Esta opción tiene como ventaja la total
INTHAL.
Vale la pena señalar que esta opción es la única disponible cuando se utiliza un
de entrada/salida a las secciones críticas del núcleo y siempre este servicio será más
los sistemas operativos de tiempo real, lo anterior no es válido. Ello se debe primero a
diseño:
secciones críticas del núcleo sino que se invoca como parte de cada conmutación de
crítica del kernel por tanto no es posible simular una interrupción desde
setIrqLevel(). Obsérvese que con el empleo del modelo integrado aquí propuesto se
inmediata), mientras que las secciones críticas más externas se protegen utilizando
prioridades disponibles).
peor caso del servicio setIrqLevel(). Por consiguiente cualquier mínimo incremento
posibilidad de notificarle este evento al núcleo para que este sea el que se encargue de
(IRQHandler (IRQ)) siempre que ocurriese una interrupción debida y a otro punto de
entrada distinto en los casos en que la interrupción sea indebida; (2) invocar siempre a
que se produjo es debida o indebida ya que este tiene suficiente información para
diferenciar la una de otra (con el nivel de prioridad del sistema) e incluso pudiera
El hecho está en que cuando ocurre una interrupción (se invoca a IRQHandler(irq)) la
tarea del núcleo es señalar a los objetos de sincronización asociados a dicha IRQ e
de que sólo pueden asociarse a una IRQ objetos que tengan capacidad de memorizar las
capacidad de recordar una interrupción indebida. En este caso, una interrupción debida
espera por ella (esta tiene mayor prioridad) mientras que la ocurrencia de una
expropiación de la tarea actualmente en ejecución (su IST posee menor prioridad). Esta
suficiente.
En el caso de que se esté en modo de enmascaramiento virtual y ocurre una interrupción i
cuya prioridad Pi > Pc, entonces el LLIH del INTHAL debe realizar las mismas
enmascaramiento de la IRQ.
La tabla de la Figura 34 resume las diferencias entre la idea inicial del enmascaramiento de
Sistemas a los
que se destina
Sistemas operativos de
Propósito general
Sistemas operativos de
tiempo real
Enmascaramiento
Físico
simplificar la implementación
garantizar la predecibilidad
temporal
Omisión de la
ejecución del
manejador de
IRQ indebida
suficiente prioridad)
Registro de
Interrupcio-nes
Indebidas
cada ISR
la IRQ
Ejecución del
manejador
pospuesto
funciona sin ningún tipo de dificultad para el caso de que las líneas de petición de
interrupción sean sensibles al flanco (ver sección 5.1.1) ya que en este caso aunque LLIH
no elimine la causas que originó la petición de interrupción (ni enmascare la interrupción en
el IMR del PIC) no se generarán más peticiones de interrupción. Sin embargo, como se
flanco es que no pueden ser compartidas de forma confiable entre múltiples dispositivos
periféricos. En los sistemas con bus EISA o PCI es posible programar la sensibilidad (al
nivel o al flanco) de cada una de las líneas de petición de interrupción de forma individual.
Solamente los canales de interrupción que se conectan al bus EISA/ISA pueden ser
programados en el modo sensible al nivel con el propósito de ser compartidos entre varios
dispositivos. Esto significa que IRQ0, IRQ1, IRQ2 e IRQ13 deben programarse sensibles al
interrupción debe ser eliminada antes de que se envíe el comando EOI o se produciría otra
registro IMR del PIC sólo en los casos en que la IRQ sea indebida (comportamiento
vez que el LLIH envía el EOI (en el caso de EOI explicito) o si se usa EOI automático, la
invocación al LLIH.
caso de que la línea de petición de interrupción sea sensible al flanco el LLIH sitúe
enmascaramiento de la IRQ indebida que se utilice (ver sección 5.5.3.1) por lo que a
indebida que se produjo (caso 1 de la sección 5.5.3.1). La secuencia de eventos del ejemplo
ilustra el peor caso posible de perturbación a la tarea SAT1 que se produce cuando ocurren
Como puede observarse, en este caso cada una de las peticiones de interrupción de los
provoca la ejecución del LLIH que inmediatamente se percata que es una interrupción
interrumpida (esto ocurre en los instantes t3´ y t4´ para los casos de la IRQ2 y la IRQ1
respectivamente).
Emisión
de la IRQ
por el
dispositivo
externo
Reconocimiento
de la IRQ
en la CPU
Activación
de la HAT
Tasks o la SAT
IRQs
tiempo
prioridad
HAT1
HAT2
SAT2
SAT1
IRQ2
IRQ1
IRQx inhabilitada
Nivel de
prioridad
Leyenda
Figura 35. Enmascaramiento Virtual: Enmascara sólo la IRQ indebida que se produjo.
Con esta variante de emulación las conmutaciones de contextos hacia tareas de mayor
Sólo se producen escrituras de la máscara cada vez que ocurre una interrupción indebida
secuencia de ejemplo, sólo ocurren cuatro operaciones de escritura de la máscara (en lugar
de las 6 que ocurrieron para la misma secuencia cuando se utilizó enmascaramiento físico
explícito ʹ ver sección 5.4.3) para una disminución del 33% de estas operaciones (en el
peor caso). Como puede apreciarse en la figura, el costo de esta reducción (mejora en el
comportamiento en el peor caso). Sin embargo, debido a que el número (dos en estecaso) y
comportamiento predecible.
5.5.5.2 Enmascarar IRQs con prioridades menores o iguales que la IRQ indebida
La Figura 36 muestra el comportamiento para el caso en que se enmascaren todas las IRQs
con prioridades menores o iguales que la IRQ indebida que se produjo (caso 2 de la sección
5.5.3.1). La secuencia de eventos del ejemplo ilustra el peor caso posible de perturbación a
la tarea SAT1 que se produce cuando ocurren todas las posibles IRQs indebidas en orden
Emisión
de la IRQ
por el
dispositivo
externo
Reconocimiento
de la IRQ
en la CPU
Activación
de la HAT
Tasks o la SAT
IRQs
tiempo
prioridad
HAT1
HAT2
SAT2
SAT1
IRQ2
IRQ1
IRQx inhabilitada
Nivel de
prioridad
Leyenda
Para este caso específico, cada una de las peticiones de interrupción de los dispositivos
ejecución del LLIH que inmediatamente se percata que es una interrupción indebida y
indebida. Esto efectivamente enmascara todas las IRQs con prioridades menores o iguales
interrumpida (esto ocurre en los instantes t3´ y t4´ para los casos de la IRQ2 y la IRQ1
respectivamente).
Con esta variante de emulación las conmutaciones de contextos hacia tareas de mayor
cada vez que ocurre una interrupción indebida para enmascararla (instantes t3 y t4) y al
t7͟). Nuevamente, para el caso de la secuencia de ejemplo, sólo ocurren cuatro operaciones
de escritura de la máscara (en lugar de las 6 que ocurrieron para la misma secuencia cuando
se utilizó enmascaramiento físico explícito ʹ ver sección 5.4.3) para una disminución del
33% de estas operaciones (en el peor caso). Sin embargo, la mayoría de las veces ocurrirán
menos aún ya que esto sólo sucede cuando las interrupciones indebidas ocurren en orden
debido a que el número (dos en este caso) y el tamaño de estas perturbaciones están
5.5.5.3 Enmascarar las IRQs con prioridades menores o iguales que el nivel actual
La Figura 37 muestra el comportamiento para el caso en que se enmascaren todas las IRQs
con prioridades menores o iguales que el nivel de prioridad actual (caso 3 de la sección
5.5.3.1). Nuevamente, la secuencia de eventos del ejemplo ilustra el peor caso posible de
perturbación a la tarea SAT1. En este caso, no importa cual sea la petición de interrupción
que ocurra de forma indebida (IRQ1 o IRQ2), su ocurrencia impedirá que cualquier otra
pueda producirse de forma indebida (hasta tanto finalice la tarea en ejecución en ese
instante).
percata que es una interrupción indebida y establece físicamente el nivel de prioridad (de
interrupción) actual. Esto efectivamente enmascara todas las IRQs que pudieran ocurrir de
caso, cuando el dispositivo externo emite la IRQ1 en el instante t4, ésta ya no interrumpe a
la CPU (ya fue enmascarada por el LLIH cuando la IRQ2 ocurrió de forma indebida en t3).
Esta IRQ1 es recordada en el registro IRR del PIC y su emisión a la CPU será demorada
prioridad actual al finalizar la ejecución de SAT1 (lo cual ocurre en el instante t5´).
Igual que en las dos variantes anteriores de emulación con enmascarado virtual, las
máscara para enmascarar IRQs, cada vez que ocurre una interrupción de forma indebida.
ejecución de la SAT1 cuando el sistema intenta conmutar a la HAT2 (que se había activado
a la HAT2 se desenmascara la IRQ1 (no la IRQ2) lo que provoca que el PIC le envíe a la
CPU (planifique) la IRQ1 que estaba pendiente provocando la interrupción de la CPU para
ejecutar la HAT1. Obsérvese que esta conmutación hacia la HAT1 es en efecto una
expropiación a la HAT2 y por tanto no provoca una nueva escritura de la máscara (como
ocurriría en el caso de que se usase enmascaramiento físico ʹ ver sección 5.4.3). Es por esto
ocurre (en el instante t7´) al finalizar la ejecución de la HAT2 como parte de la disminución
del nivel de prioridad (de interrupción) hasta el nivel correspondiente a la tarea SAT2 que
se reanuda. En este caso, la escritura es tal que vuelve a desenmascarar ambas IRQs.
Emisión
de la IRQ
por el
dispositivo
externo
Reconocimiento
de la IRQ
en la CPU
Activación
de la HAT
Tasks o la SAT
IRQs
tiempo
prioridad
HAT1
HAT2
SAT2
SAT1
IRQ2
IRQ1
IRQx inhabilitada
Nivel de
prioridad
Leyenda
En total, en esta secuencia del ejemplo sólo ocurren tres operaciones de escritura de la
máscara (en lugar de las 6 que ocurrieron para la misma secuencia cuando se utilizó
enmascaramiento físico explícito ʹ ver sección 5.4.3 ʹ o las cuatro que ocurrieron cuando
se utilizaron las dos variantes de emulación del enmascarado virtual anteriores ʹ ver
secciones 5.5.5.1 y 5.5.5.2) para una disminución del 50% con respecto al modo de
emulación con enmascaramiento físico. Para este caso, el costo de esta reducción (mejora
comportamiento en el peor caso). Sin embargo, debido a que ahora sólo puede ocurrir una
sola perturbación (para cada tarea) y el tamaño de esta perturbación está acotado, el sistema
Cuando se utiliza enmascarado virtual, el enmascarado de una IRQs sólo puede ocurrir si la
produce sólo, si como parte de una conmutación de contexto (de salida de una actividad),es
Para las actividades en el conjunto P(i) el peor caso se dará cuando todas las IRQs del
P(i) de mayor prioridad que la IRQ correspondiente. En este caso, cada una implicaría una
primera escritura de la máscara como parte de su manejador y una segunda escritura cuando
finalice la actividad en P(i) que fue indebidamente interrumpida por ésta. Sin embargo,
como esta escritura sólo se producirá en el caso de que se haya producido realmente la IRQ,
la misma no se debe asociar a cada conmutación de contexto en P(i); sino que, basta con
asociar dos escrituras de máscara (2ɷM) a cada posible activación de las actividades en H(i).
()
22
jHi
M p Hj
iT
Donde ɶ es el tiempo de ejecución del prólogo asociado a las IRQs no deseadas, que es
IRQs asociadas a cualquiera de las actividades en los conjuntos S(i) y L(i) (no la actividad
de atención como tal) cuando ellas se producen de forma indebida. Este prólogo se encarga
de enmascarar dicha IRQ. En este caso, sólo hay que contabilizar un enmascaramiento por
actividades en S(i) o L(i). Sin embargo, el número de veces que puede ejecutarse este
sección 5.5.3.1). Sea ɶ es el tiempo de ejecución del prólogo asociado a las IRQs no
menores o iguales que la IRQ actual (o sea, casos 1 y 2 de la sección 5.5.3.1), entonces
en el peor caso, cada una de las IRQ del conjunto S(i) L(i) puede ocurrir a lo sumo
<
( ( ) ( )) ( )
()()22
jHi
M p Hj
jPiHij
Pi
iT
T
CSiLi
(14)
Uloss = Ui
<
()
*()()22
jHi
pM
PI
iTT
SiLi
(15)
2) Para el caso en que se establezca la máscara que corresponde con la prioridad actual del
sistema PC (o sea, el caso 3 de la sección 5.5.3.1), entonces sólo puede ocurrir una sola
escribirse como:
( ( ) ( )) ( )
22
jHi
M p Hj
jPiHij
Pi
iT
T
C
(16)
Uloss = Ui
()
*22
jHi
pM
PI
iTT
(17)
Obsérvese que, a diferencia del mecanismo tradicional, consistente en utilizar una ISR
mínima postergando el servicio al nivel de tarea (subsecciones 4.2.1.1 y 4.2.2), este
inversión de prioridad debido a una pequeña perturbación debido a la ejecución del prólogo
ó 17), esta inversión de prioridad es acotada. Este esquema garantiza una administración de
interrupciones predecible con una perdida en la utilización muy pequeña. También observe
que ahora Ui
PI* (Ecuación 14) sólo depende de las HATs en el conjunto H(i) y no de las
tareas activadas por software (como sucede en la Ecuación 12), haciendo al sistema más
escalable
Como un comentario general, vale la pena observar que el esquema de protección optimista
es un caso específico de una técnica de optimización más general utilizada con frecuencia
en los sistemas operativos de propósito general conocida como técnicas perezosas (͞lazy
techniques͟), y que consiste en evitar la ejecución de operaciones costosas hasta que sean
absolutamente necesarias. Aunque estas técnicas se han utilizado para optimizar el caso
más frecuente, en este caso su aplicación a los sistemas operativos de tiempo real nos ha
Una alternativa simple al modelo integrado aquí propuesto que también puede enfrentar el
al PIC (EOI) y acto seguido enmascara la petición de interrupción, evitando con ello
resto de las demás tareas según la prioridad que le corresponda por el planificador (de
forma explícita la petición de interrupción una vez que le haya dado servicio mediante un
funciona como petición (͞request͟) de una interrupción adicional qué sólo pueden ocurrir
efecto similar al empleo del esquema integrado con enmascaramiento virtual y el caso 1 de
enmascaramiento. O sea, a lo sumo puede ocurrir una sola instancia de cada una de las IRQ
asociadas a IHT de menor prioridad que la tarea ti (que serían IRQ no deseadas). Con lo
cual se consigue acotar la inversión de prioridad en el peor caso. Sin embargo, en este caso
se añade la sobrecarga de una escritura de máscara más el envío del EOI a la latencia de
interrupción de todas las IRQs y adicionalmente se añade una segunda escritura de máscara
SeaɷE
OI el tiempo de cómputo asociado al envío del EOI al PIC, entonces la ecuación (9)
<
( ( ) ( )) ( )
()()222
jHi
H
EOI M p Hj
jPiHij
M EOI
Pi
iT
CSiLi
<
()
*()()222
jHi
H
p M EOI
M EOI
PI
iTT
SiLi
(18)
Lo interesante de esta última técnica es que, con el propósito de hacer que las IHT fuesen
diferentes de la IA32 para la cual fue creado originalmente [27]. El resultado es que, como
automático de la petición de interrupción como parte del FLIH trae consigo un aumento
interrupciones del HAL para sistema PC compatibles, así como se muestran los seudocódigos
de cada uno de los mismos
Como se planteo en la sección 5.2, para poder llevar a cabo su tarea el INTHAL tiene que
capturar todas las IRQs. Para ello durante la inicialización el INTHAL (servicio
de forma que todas las IRQ apunten a una entrada dentro de una la Tabla de Entradas de
IRQs del INTHAL. Esta disposición se muestra en la Figura 35. Como se aprecia en el
esquema, esta tabla, situada en la sección de código del INTHAL posee una entrada para
cada una de las IRQs de hardware (un total de 15 entradas en un sistema PC-AT). En
realidad, cada una de estas entradas posee un pequeño código que se encarga de invocar a
estado (capturada o ignorada ʹ ver el diagrama de estado de la Figura 21). Si la IRQ está en
todas las entradas de la Tabla de Entradas de IRQ están configuradas para saltar al LLIH
disableIrq() provocan las transiciones de estado que modifican el LLIH asociado a cada
IRQ.
Figura 39. Cada modo de emulación posee algoritmos diferentes para los Manejadores de
IRQ0
IRQ1
IRQ2
IRQ3
IRQ4
..
IRQ14
IRQ15
Tabla de Vectores de
Interrupción de la CPU
Tabla de Entradas de
Manejadores de IRQ
PANIC_ENTRY
CAPTURED_ENTRY
REFLECTED_ENTRY
CAPT_REFL_ENTRY
IRQ00_ENTRY:
push bx
mov bl00h
JMP
IRQ15_ENTRY:
push bx
mov bl 01h
JMP
IRQ01_ENTRY:
push bx
mov bl 01h
JMP
Descripción
0 0 0 Explícito Soportado
1 0 1 Automático Soportado
2 1 0 Explícito No Soportado
3 1 1 Automático No Soportado
El INTHAL mantiene el estado del VCPIC mediante un conjunto de variables internas cada
Se mantiene los siguientes arreglos de 16 elementos, uno por cada IRQ del sistema:
IRQ_Priority: arreglo de bytes (8 bits) con la prioridad de cada IRQ del sistema. La
IRQ2, que conecta en cascada al segundo 8259, se pone en prioridad máxima (255).
Con esto se consigue que siempre esté habilitada y permita el paso de las interrupciones
desde el segundo 8259, sin tener que hacer una distinción especial para ella en los
algoritmos internos.
IRQ_Mask: arreglo de palabras (16 bits), cada una de las cuales mantiene la máscara a
mayor prioridad y ͞1͟ en los bits correspondientes a las IRQ de prioridad menor o igual
OLD_Level: arreglo de bytes (8 bits) con el nivel de interrupción activo cuando ocurrió
la IRQ particular.
OLD_Mask: arreglo de palabras (16 bits) con la máscara de interrupción activa cuando
ocurrió la IRQ particular.
IRQ_Level: variable de tipo byte que conserva el nivel de prioridad actual del sistema.
correspondiente al IRQ_Level.
Fisical_Mask: variable de tipo palabra que contiene la máscara de interrupción que está
situada realmente en los registros IMR de los 8259s. En el modo de enmascarado físico
En el caso del servicio de inicialización su función es establecer los valores iniciales de las
Los servicios de administración de las prioridades de interrupción son quizás los más
importantes del INTHAL para la implantación del VCPIC. Esos servicios son los que
logran la ilusión de que a las IRQs se le puedan asignar prioridades de forma dinámica y
dentro del mismo espacio de prioridades del planificador del núcleo. Este subconjunto está
conformado por los servicios de interfaz setIrqPriority() y setIrqLevel(); así como, por
cada vez que es necesario situar la máscara en el hardware de interrupción (registros IMR
(Fisical_Mask) con el valor actual de los registros de máscara de forma que se pueda evitar
la costosa operación de E/S necesaria para establecer la máscara siempre que la nueva
segundo servicio setIRQMask(͙) que va a ser invocado siempre que se quiere establecer
primero verifica que la máscara física sea diferente de la máscara que se desea establecer.
Si ello se cumple, establece realmente la máscara en los registros IMR de ambos 8259 y
Set8259IMR (mask) {
Si ( mask Fisical_Mask ) {
Logical_Mask = mask
Fisical_Mask = mask
setIRQMask (mask) {
Si ( VirtualMaskMode = TRUE) {
Set8259IMR(mask)
Sino
Logical_Mask = mask
}
Sino {
Set8259IMR (mask)
8259.
máscara si ello implica habilitar (desenmascarar) una IRQs. En caso de que la nueva
Puede observarse que en todo instante Logical_Mask contiene el valor de la máscara que
operando en el modo de enmascaramiento físico este valor siempre va a ser igual al valor
con el valor de Fisical_Mask (y de los registros IMR de ambos 8259). Sin embargo, en este
modo siempre se tiene que cumplir que Fisical_Mask sea menos o igual de restrictiva que
invariante):
prioridades asignadas a cada una de las IRQs (dentro del espacio de prioridades del
IRQ_Mask ambos con una entrada por cada IRQ posible en el sistema. El primer arreglo
conserva la prioridad actual de cada una de las IRQs (en el espacio de prioridades del
prioridades reflejada en el arreglo obtiene la máscara asociada a cada una de las IRQ. Estas
inhabilitada o viceversa.
*/
t_IRQMask 0
} Si (
IRQ_Priority[t_IRQ] =
Priority )
{
} Si (
IRQ_Priority[t_IRQ] >
Priority) {
} IRQ_Mask[IRQ]
t_IRQMask;
t_IRQMaskBit (1
PUERTO SERIAL
Uno de los defectos de los puertos serie iniciales era su lentitud en comparación con los
puertos paralelos, sin embargo, con el paso del tiempo, están apareciendo multitud de puertos
serie con una alta velocidad que los hace muy interesantes ya que tienen la ventaja de un
menor cableado y solucionan el problema de la velocidad con un mayor apantallamiento; son
más baratos ya que usan la técnica del par trenzado; por ello, el puerto RS-232 e incluso
multitud de puertos paralelos están siendo reemplazados por nuevos puertos seriecomo el
USB, el Firewire o el Serial ATA. Los puertos serie sirven para comunicar al ordenador con la
impresora, el ratón o el módem; Sin embargo, específicamente, el puerto USB sirve para todo
tipo de periféricos, desde ratones, discos duros externos, hasta conexión bluetooth. Los
puertos SATA (Serial ATA): tienen la misma función que los IDE, (a éstos se conecta, la
disquetera, el disco duro, lector/grabador de CD y DVD) pero los SATA cuentan con mayor
velocidad. Un puerto de red puede ser puerto serie o puerto paralelo.
Los puertos serie se usan frecuentemente en estas áreas porque son sencillos, baratos y
permiten la interoperabilidad entre dispositivos
Simplex
Full Duplex
Antes de cada byte de datos, los puertos serie envían un bit de comienzo, el cual es un único
bit con un valor de 0. Después de cada byte de datos, envía un bit de parada para señalar que
el byte está completo. También envía un bit de paridad.
Los puertos serie, también llamados puertos de comunicación (COM), son bi-direccionales. La
comunicación bi-direccional permite a cada dispositivo recibir datos a la vez que los transmite.
Los dispositivos serie usan pines diferentes para el recibir y enviar datos - usar los mismos
pines significaría que la comunicación estaría limitada a half-duplex, y que la información
viajaría en una sola dirección a la vez. Usar pines diferentes permite una comunicación full-
duplex, y puede viajar en ambos sentidos.
Los puertos serie delegan en un controlador o chip especial llamado UART (Universal
Asynchronous Receiver/Transmitter), para funcionar correctamente. El chip UART coge la
salida en paralelo del bus del sistema y la transforma en una forma serie para que se transmita
por el puerto serie. Para que funcionen más rápido, muchos chips UART tiene integrado un
buffer de 16 a 64 Kilobytes en su interior. Este buffer permite al chip hacer un caché de datos
mientras está procesando los datos.
La conexión serie
Con un ejemplo podemos ver mejor como funciona el control de flujo. Tienes un modem que
se comunica a 56 Kbps. La conexión serie entre tu ordenador y tu modem transmite a 115
Kbps, lo cual es el más de la mitad. Esto significa que tu modem está recibiendo más datos
viniendo de tu ordenador, que lo que puede transmitir por la línea de teléfono. Incluso,
aunque el modem tuviera un buffer de 128 K para almacenar datos, se quedaría sin espacio en
el buffer rápidamente y no sería capaz de funcionar adecuadamente con todo ese flujo de
datos.
Con control de flujo, el modem puede parar el flujo de datos de tu ordenador antes de que
desborde el buffer del modem. El ordenador está constantemente enviando una señal en el
pin RTS, y comprobando si hay señal en el pin CTS. Si no hay una respuesta del CTS, el
ordenador para de enviar datos, esperando al CTS para reanudarlos datos. Esto permite al
modem mantener el flujo de datos de manera fluida.
Puerto serial
Los puertos seriales (también llamados RS-232, por el nombre del estándar al que hacen
referencia) fueron las primeras interfaces que permitieron que los equipos intercambien
información con el "mundo exterior". El término serial se refiere a los datos enviados mediante
un solo hilo: los bits se envían uno detrás del otro (consulte la sección sobre transmisión de
datos para conocer los modos de transmisión).
Originalmente, los puertos seriales sólo podían enviar datos, no recibir, por lo que se
desarrollaron puertos bidireccionales (que son los que se encuentran en los equipos actuales).
Por lo tanto, los puertos seriales bidireccionales necesitan dos hilos para que la comunicación
pueda efectuarse.
Ésta es la razón por la cual en este tipo de transmisión, cada carácter se encuentra precedido
por un bit de ARRANQUE y seguido por un bit de PARADA. Estos bits de control, necesarios
para la transmisión serial, desperdician un 20% del ancho de banda (cada 10 bits enviados, 8 se
utilizan para cifrar el carácter y 2 para la recepción).
Los puertos seriales, por lo general, están integrados a la placa madre, motivo por el cual los
conectores que se hallan detrás de la carcasa y se encuentran conectados a la placa madre
mediante un cable, pueden utilizarse para conectar un elemento exterior. Generalmente, los
conectores seriales tienen 9 ó 25 clavijas y tienen la siguiente forma (conectores DB9 y DB25
respectivamente):
Los primeros dispositivos serie operaban a velocidades muy bajas, del orden de 110 a 1200
baudios [2]. Las comunicaciones telefónicas serie actuales están muy cerca del máximo
teórico que pueden soportar los pares de cobre utilizados en la telefonía estándar. Además,
para aumentar el rendimiento de la comunicación se utilizan técnicas de compresión de los
datos a transmitir, y velocidades variables, que pueden ser negociadas entre los equipos que
comunican en función del estado de la línea en cada momento.
§3.2 Longitud del carácter ("Char length"). Se han utilizado caracteres de 5, 6, 7 y 8 bits,
aunque actualmente los datos son enviados como caracteres ASCII, por lo que pueden
utilizarse 7 u 8 bits según se trate del juego de caracteres US-ASCII o el extendido ([pic]
E2.2.1a). El conjunto de bits que componen un carácter se denominan bits de dato ("Data
bits")
§3.3 Paridad ("Parity"). Para poder comprobar la calidad de la transmisión se suele utilizar un
sistema de control de paridad que añade un bit a los bits de datos. Los sistemas utilizados son:
Los sistemas de paridad par e impar se ha explicado al tratar de la memoria ([pic] H5.3); ambos
métodos cuentan el número de unos contenidos en los bits de datos y añade un uno o un cero
según el resultado. Por su parte la paridad Mark indica que se incluirá siempre una marca (bit
de valor "1") como bit de paridad, mientras que la paridad Space añade siempre un espacio
("0"). Evidentemente estos dos últimos sistemas no aportan absolutamente ninguna
información, por lo que son usados muy raramente.
§3.4 Bits de parada ("Stop bits"). Después que se envía un carácter se envía un bits de parada,
que tienen el valor "1" (marca); la duración de este bit puede ser 1, 1.5 o 2 periodos.
§4 Características eléctricas
Como hemos señalado, las normas y terminología de las comunicaciones serie están muy
influenciadas por sus orígenes telegráficos. Esto incluye algunas de las definiciones utilizadas
por la norma RS-232.
Una curiosidad de esta norma es que la transmisión de los caracteres ASCII se realiza
empezando por el bit menos significativo. Puesto que estamos acostumbrados a
representarlos de derecha a izquierda (empezando por el más significativo), podría decirse que
los bits son transmitidos al revés.
Los datos se transmiten en binario, pero no es frecuente referirse a ceros y unos como en la
informática convencional, sino a espacios y marcas.
En la figura 1 se muestran los niveles de tensión correspondientes a las salidas. Como puede
verse, la lógica utilizada es poco convencional, utiliza una lógica bipolar con tensiones
negativas para los "1" lógicos [6].
En la figura 2 se muestran los niveles correspondientes a las entradas. Puede verse que su
espacio de transición es más reducido que para las salidas.
El puerto serial se constituye como una de las más básicas conexiones externas a un
computador, y aunque hoy en día la más utilizada es su forma USB, el puerto serial ha estado
junto a nuestros computadores por más de veinte años. Su principal función es enviar y recibir
datos, bit por bit, y a modo de ejemplo, se puede mencionar entre ellos el puerto de los
antiguos modelos del teclados y modems.
Grosso modo, un puerto serial posee un conector estándar y trabaja con protocolo que
permiten la conexión de dispositivos al computador. Estos puertos son denominados seriales
debido a que este tipo de puertos serializa la información, en otras palabras, toma un byte de
datos y transmite cada uno de los 8 bits uno a uno.
Los puertos seriales se conocen también con el nombre de puertos de comunicación o COM, y
tienen la característica de ser bidireccionales. Ésta característica permite a cada uno de estos
dispositivos tanto recibir como enviar datos. Su normal funcionamiento depende de un chip
especial denominado UART debido a las siglas en inglés para ͞Universal Asynchronous
Reciever/Transmitter͟. Este chip controlador toma la salida paralela del bus del computador y
lo convierte en forma serial, lo que permite la transmisión de los datos a través del puerto.
Dentro de sus principales ventajas se encuentra la necesidad de sólo un cable para poder
transmitir los 8 bits, sin embargo, se demora 8 veces más en realizar esta transmisión que si
contáramos con 8 cables, como sucede con un puerto paralelo. Estos últimos son creación más
nueva, por lo que han sido fabricados para un funcionamiento más rápido y eficiente, lo que
hace pensar que de aquí a algún tiempo más reemplazarán por completo a los puertos serie.
No obstante, la aparición de los puertos USB crece con fuerza y amenaza también la existencia
de los puertos paralelos, por su mayor comodidad y eficacia.
Registros en Microprocesadores.
En microprocesadores, un registro es una porción de memoria ultrarrápida, de poca capacidad
e integrado al microprocesador, que permite almacenar y acceder datos o micro órdenes
usadas frecuentemente. Se emplean para aumentar la velocidad de ejecución de los
programas.
ͻ REGISTROS DE SEGMENTO
ͻ REGISTROS DE CONTROL
Existen 4 registros denominados AX, BX, CX y DX que en realidad tienen asignados usos
característicos, aunque pueden ser utilizados a discreción para cualquier cosa que
necesitemos.
Aunque estos cuatro registros son de 16 bits (como los 10 restantes) , en caso necesario
pueden ser utilizados en dos mitades (nibbles), "High" y "Low", de 8 bits, con lo que puede
considerarse que existen 12 registros de uso general (no simultáneos), los anteriores y sus
mitades: AH; AL; BH; BL; CH; CL; DH y DL.
DATOS:
DIRECCIÓN:
ͻ APUNTADORES DE SEGMENTO:
ͻ REGISTRO INDICE
ͻ APUNTADOR DE STACK
Los registros de banderas sirven parar indicar el estado actual de la maquina y el resultado del
procesamiento, Cuando algunas instrucciones piden comparaciones o cálculos aritméticos
cambian el estado de las banderas.
bits 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1
DF (Direction flag, Direccion). Designa la dirección hacia la izquierda o hacia la derecha para
mover o comparar cadenas de caracteres.
IF (Interruption flag, Interrupcion). Indica que una interrupción externa, como la entrada desde
el teclado sea procesada o ignorada.
TF (Trap flag, Trampa). Examina el efecto de una instrucción sobre los registros y la memoria.
Los programas depuradores como DEBUG, activan esta bandera de manera que pueda avanzar
en la ejecución de una sola interrupción a un tiempo.
SF (Sign flag, Signo). Contiene el signo resultante de una operación aritmética (0=positivo y 1=
negativo).
ZF (Zero flag, Zero). Indica el resultado de una operación aritmética o de comparación (0=
resultado diferente de cero y 1=resultado igual a cero).
AF (Auxiliary carry flag, Acarreo auxiliar). Contiene un acarreo externo del bit 3 en un dato de 8
bits, para aritmética especializada
PF (Parity flag, Paridad). Indica paridad par o impar de una operación en datos de ocho bits de
bajo orden (mas a la derecha).
CF (Carry flag, Acarreo). Contiene el acarreo de orden mas alto (mas a la izquierda) después de
una operación aritmética; también lleva el contenido del ultimo bit en una operación de
corrimiento o rotación.
Registros de segmento
Se dispone de cuatro registros que sirven para contener las direcciones de otros tantos
segmentos (zonas de 64 KB de memoria). Utilizándolos en conjunción con otros registros que
señalan las direcciones concretas dentro de estos segmentos (los desplazamientos), permiten
manejar la totalidad de la memoria direccionable (el bus de direcciones es de 20 bits). Ver al
respecto el epígrafe "Direccionamiento segmentado".
ͻ Segmento de código CS ("Code segment"). Señala la dirección del segmento de código del
programa que se está ejecutando.
ͻ Segmento de datos DS ("Data segment"). Señala la dirección del segmento de datos del
programa en ejecución.
ͻ Segmento de pila SS ("Stack segment"). Señala la dirección del segmento donde está la
pila del programa.
ͻ Segmento extra ES ("Extra segment"). Es un segmento auxiliar a los anteriores, se utiliza
para señalar espacio extra en alguno de los segmentos o para almacenar momentáneamente
direcciones intermedias.
Nota: Puede ocurrir que programas pequeños utilicen el mismo segmento para el código, los
datos y la pila
Registro índice.
Los registros SI y DI están disponibles para direccionamientos indexados y para sumas y restas.
Que son la operaciones de punta.
Registro SI.
El registro índice de 16 bits es requerido por algunas operaciones con cadenas (de caracteres).
En este contexto, el SI está asociado con el registro DS. Los procesadores 80386 y posteriores
permiten el uso de un registro ampliado a 32 bits, el ESI.
Registro DI.
El registro índice destino también es requerido por algunas operaciones con cadenas de
caracteres. En este contexto, el Di está asociado con el registro ES. Los procesadores 80386 y
posteriores permiten el uso de un registro ampliado a 32 bits, el EDI.
Registros de puntero
ͻ El puntero de pila SP ("Stack Pointer"), señala el desplazamiento del final de la pila dentro
del segmento de pila SS. En caso necesario la pila puede crecer a partir de este punto, de
forma que por ejemplo, una nueva invocación de función creará un nuevo registrode
activación que comenzará en este punto.
ͻ El puntero base BP ("Base pointer") señala el desplazamiento (dentro del segmento de pila
SS) donde se encuentra el origen de la zona ocupada por las variables dinámicas.
ͻ Existen dos registros denominados "de índice", en razón de su utilización muy particular; el
índice fuente SI ("Source index") y el índice destino DI ("Destination index"). Generalmente
estos dos registros se utilizan con alguno de los registros de uso general y con ciertas
instrucciones específicamente pensadas para transferir datos (dentro de un rango de
posiciones de memoria), desde un punto inicial de un segmento de datos, a otro.
Registro de estado
Existe un registro especial, el registro de estado (FLAGS), en el que 9 de los 18 bits actúan
como semáforos (indicadores del estado del procesador y del resultado de determinadas
operaciones). Por ejemplo, si después de una suma aritmética hay o no desbordamiento del
bit más significativo.
Cada bits individual puede estar "activo" (1) o "inactivo" (0), y tiene un identificador que
termina en F ("Flag").
|CF |Acarreo (͞Carry flag͟) |Indicador de arrastre del bit de mayor orden que puede
ocurrir en las operaciones |
|PF |Paridad (͞Parity flag͟) |Si esta activo indica un número par de bits activos. Esta
información es útil cuando el |
|ZF |Cero (͞zero flag͟) |Es activo si el resultado de la operación es cero o resultado de
comparación igual |
|SF |Signo (͞Sing flag͟) |Si esta activo indica que el resultado de operación o de
comparación son negativos |
|TF |Detención (͞Trap flag͟) |Si esta activo, el procesador genera automáticamente una
interrupción después de la |
| | |programa. |
| | |Este bit debe estar normalmente inactivo(a 0)
|
|IF |Interrupción (͞Interrupt |Esta bit controla el estado del sistema de interrupciones
|
| | |las deshabilita |
[pic]
TELEMATICA
DIEGO RODRIGUEZ
CLASES DE DIRECCIONES IP
CLASES DE DIRECCIONES IP
ñ Los números de la izquierda indican la red y se les denomina netID (identificador de red).
ñ Los números de la derecha indican los equipos dentro de esta red y se les denomina host-
ID (identificador de host).
Las direcciones IP fueron organizados en clases, hubo cinco clases de direcciones IP.
El bit más importante (el primer bit a la izquierda) está en cero, lo que significa que hay 2 7
(00000000 a 01111111) posibilidades de red, que son 128 posibilidades. Sin embargo, la red 0
(bits con valores 00000000) no existe y el número 127 está reservado para indicar su equipo.
Las redes disponibles de clase A son, por lo tanto, redes que van desde 1.0.0.0 a 126.0.0.0 (los
últimos bytes son ceros que indican que se trata seguramente de una red y no de equipos).
Los tres bytes de la izquierda representan los equipos de la red. Por lo tanto, la red puede
contener una cantidad de equipos igual a:
|Red |Equipos |
Clase B: En una dirección IP de clase B, los primeros dos bytes representan la red.
Los primeros dos bits son 1 y 0; esto significa que existen 214 (10 000000 00000000 a 10
111111 11111111) posibilidades de red, es decir, 16.384 redes posibles. Las redes disponibles
de la clase B son, por lo tanto, redes que van de 128.0.0.0 a 191.255.0.0.
Los dos bytes de la izquierda representan los equipos de la red. La red puede entonces
contener una cantidad de equipos equivalente a: Por lo tanto, la red puede contener una
cantidad de equipos igual a:
|Red |Ordenadores |
Clase C: En una dirección IP de clase C, los primeros tres bytes representan la red. Los primeros
tres bits son 1,1 y 0; esto significa que hay 221 posibilidades de red, es decir, 2.097.152. Las
redes disponibles de la clases C son, por lo tanto, redes que van desde 192.0.0.0 a
223.255.255.0.
El byte de la derecha representa los equipos de la red, por lo que la red puede contener:
ñ La dirección 0.0.0.0 es utilizada por las máquinas cuando están arrancando o no se les ha
asignado dirección.
ñ La dirección que tiene su parte de host a cero sirve para definir la red en la que se ubica.
Se denomina dirección de red.
ñ La dirección que tiene su parte de host a unos sirve para comunicar con todos los hosts
de la red en la que se ubica. Se denomina dirección de broadcast.
Direccionamiento IP
CLASES DE DIRECCIONES IP
DIRECCIONES IP PRIVADAS
Las direcciones del nivel de red en Internet pueden representarse de manera simbólica o
numérica. Una dirección simbólica es por ejemplo www. pntic.mec.es Una dirección numérica
se representa por cuatro campos separados por puntos, como 193.144.238.1, los cuales no
pueden superar el valor 255 (11111111 en binario). La correspondencia entre direcciones
simbólicas y numéricas las realiza el DNS (Domain Name System).
Para poder identificar una máquina en Internet cada una de ellas tiene una dirección IP
(Internet Protocol) la cual es asignada por InterNIC (Internet Network Information Center).
Las direcciones numéricas son las que entiende la máquina y se representan por 32 bits con 4
campos de 8 bits cada uno, aunque normalmente se pasan de binario a decimal. Por ejemplo
139.3.2.8 es en binario:
|139 |3 |2 |8 |
CLASES DE DIRECCIONES IP
Una parte de los bits representa la red y el resto la máquina (host). En este caso como veremos
los dos primeros campos representan la red 139.3 (16 bits) y 2.8 (16 bits) al host. Los paquetes
de datos que maneja Internet a nivel de red se llaman datagramas. Estos llevan tanto la
dirección de la máquina transmisora como la receptora. Existen cinco clases de direcciones IP
según la manera de repartir los bits entre la dirección de red y el número de host.
Clase A
|0 |1 |8 16 24 |
| | |31 |
Clase B
|0 |1 | 8 |16 24 31 |
Clase C
|0 |1 | | 8 16 |24 31 |
Clase D
|1 |1 |1 |0 |DIRECCIONES MULTICAST |
|0 |1 | | | 8 16 24 31 |
Clase E
|1 |1 |1 |1 |RESERVADAS |
|0 |1 | | | 8 16 24 31 |
En las clases A, B, y C las direcciones con la parte de número de host con todos los bits puestos
a ͚0͛ indican la red por lo que no se pueden asignar a ningún host; igualmente tan poco se
pueden asignar a un host las direcciones con el número de host con todos los bits puestos a ͚1͛
porque se dejan para los paquetes broadcast dirigidos a todas las máquinas de la red. Por
ejemplo en la red anterior que es clase B la red es 139.3.0.0 y la dirección broadcast
139.3.255.255.
ͻ Las direcciones de Clase A usan 7 bits para el número de red dando un total de 126 (128-2)
posibles redes de este tipo ya que la dirección 0.0.0.0 se utiliza para reconocer la dirección de
red propia y la red 127 es la del lazo interno de la máquina. Los restantes 24 bits son para el
número de host ʹquitando las que son todos los bits a 0 ó a 1 ʹcon lo cual tenemos hasta 224-
2=16.777.216-2=16.777.214 direccionesʹ. Son las redes 1.0.0.0 a 126.0.0.0
ͻ Las direcciones de Clase B utilizan 14 bits para la dirección de red (16.382 posibles redes de
este tipo) y 16 bits para el host (hasta 65.534 máquinas). Son las redes 128.0.0.0 a 191.255.0.0
ͻ Las direcciones de clase C tienen 21 bits para la red (2.097.150 redes) y 8 bits para el host
(254 máquinas). Son las redes 192.0.0.0 a 223.255.255.0
ͻ Las direcciones de clase D están reservadas para multicasting que son usadas por
direcciones de host en áreas limitadas.
La clase que se elija para una red dada dependerá del número de máquinas que tenga y las
que se prevean en el futuro. Como vimos antes el número de red es asignado por el NIC o por
el organismo de cada país en quien él delegue. El número de host lo asignará el administrador
que controla la red.
Puede darse el caso de que una red crezca en un número de máquinas significativo o que se
quiera instalar una nueva red además de la que ya existía.
Para conseguir mayor funcionalidad podemos dividir nuestra red en subredes dividiendo en
dos partes el número de host, una para identificar la subred, y la otra parte para identificar la
máquina (subnetting). Esto lo decidirá el responsable de la red sin que intervenga el NIC.
Podemos tener asignada una red ʹnormalmente de las clases B ó Cʹ y dividirla en dos o más
subredes según nuestras necesidades comunicados por routers.
Clase B
|0 |1 | 8 |16 | 24 31 |
Clase C
|0 |1 | | 8 16 |24 | 31 |
El conjunto formado por la subred y el número de host se conoce como dirección local o parte
local. Un host remoto verá la dirección local como el número de host.
|255 |255 |0 |0 |
Si queremos dividirla en subredes tomaremos los 16 bits de la parte local y pondremos a "1" la
parte que queremos represente a las subredes. Por ejemplo si queremos 8 subredes
necesitaremos en binario 3 bits para referenciarlas. La máscara que necesitamos será:
11111111.11111111.11100000.00000000 es decir 255.255.224.0 en decimal. Al emplear 13
bits para el host podríamos tener hasta 213-2=8190 máquinas en cada subred.
Lo normal a la hora de añadir "unos" a la máscara inicial para definir las subredes es hacerlo de
manera contigua para ver los campos claramente.
Si tenemos una red clase C cuya máscara sin subredes es 255.255.255.0 y queremos dividirla
en 4 subredes solo necesitamos 2 bits para definirlas:
Hay dos formas de dividir una red en subredes: longitud estática y longitud variable. Se pueden
utilizar según el protocolo de encaminamiento. El encaminamiento IP nativo solo soporta
longitud estática al emplear el protocolo RIP. Con el protocolo RIP2 se consigue utilizar
longitud variable.
La longitud estática implica que todas las subredes deben tener la misma máscara lo que
obligará a poner la que necesite la que tenga más ordenadores. La longitud variable permite
que no haya que variar las direcciones de red caso de cambios en una de sus subredes. Una
subred que necesita dividirse en otras dos puede hacerlo a añadiendo un bit a su máscara sin
afectar al resto. No todos los routers y host soportan la longitud variable de máscaras. Si un
host no soporta este método deberá encaminarse hacia un router que si lo soporte.
Supongamos que tenemos una red clase B, 140.155, y sabemos que no tendremos más de 256
subredes y no más de 254 hosts, podemos dividir la dirección local con 8 bits para las redes y
otros 8 para el número de hosts con una máscara del tipo 255.255.255.0 ʹes decir que en
binario sería 11111111.11111111.11111111.00000000ʹ.
Si tenemos una red clase C con muchas subredes y con pocos hosts podemos poner una
máscara 255.255.255.224 ʹrecordando que 224 es 11100000 en base 2ʹ es decir que hemos
dividido la dirección local en 3 bits para redes y 5 para hosts. O sea 23=8 subredes y 25-2=30
hosts.
00000000)2 = 0)10
00100000)2 = 32)10
01000000)2 = 64)10
01100000)2 = 96)10
10000000)2 = 128)10
10100000)2 = 160)10
11000000)2 = 192)10
11100000)2 = 224)10
Direcciones Broadcast
ͻ Direcciones de broadcast de red: En una red sin subredes poniendo a "1" los bits del
campo de número de host
ͻ Direcciones de broadcast de subred: Poniendo a "1" solo la parte del número de host de la
dirección local.
Multicasting
Para tener más flexibilidad que la proporcionada por el método broadcast que se dirige a
todos los miembros de una subred o de una red, existe el método multicast, el cual nos
permite dirigirnos a grupos de hosts dentro de la red.
El datagrama IP para multicast como vimos antes es de clase D cuyos cuatro primeros bits son
1110 ʹel primer octeto va de 11100000 a 11101111ʹ luego el rango de direcciones será de
224.0.0.0 a 239.255.255.255.
Grupos transitorios: Son los grupos que no son permanentes y se van creando según las
necesidades.
DIRECCIONES IP PRIVADAS
Las redes privadas de organizaciones que no están directamente conectadas a Internet ʹesto
es, las redes que se conectan por medio de un proxy o un router a una única línea con una sola
dirección IP dada por un proveedor de serviciosʹ tienen asignado unos rangos de direcciones
IP para su funcionamiento interno. Estos son:
Estas direcciones IP no son utilizadas por los routers para su comunicación con Internet, y se
utilizan solo dentro de la organización. Estas redes (Intranet) tienen la ventaja de ser mucho
menos accesibles a ataques desde el exterior.
REDES
Las redes constan de dos o más computadoras conectadas entre sí y permiten compartir
recursos e información. La información por compartir suele consistir en archivos y datos. Los
recursos son los dispositivos o las áreas de almacenamiento de datos de una computadora,
compartida por otra computadora mediante la red. La más simple de las redes conecta dos
computadoras, permitiéndoles compartir archivos e impresos.
Una red mucho más compleja conecta todas las computadoras de una empresao compañía en
el mundo. Para compartir impresoras basta con un conmutador, pero si se desea compartir
eficientemente archivos y ejecutar aplicaciones de red, hace falta tarjetas de interfaz de red
(NIC, NetWare Interfaces Cards) y cables para conectar los sistemas. Aunque se puede utilizar
diversos sistemas de interconexión vía los puertos series y paralelos, estos sistemas baratos no
ofrecen la velocidad e integridad que necesita un sistema operativo de red seguro y con altas
prestaciones que permita manejar muchos usuarios y recursos
Redes de Área Local (LAN)
La red local o LAN (Local Area Network) es un sistema de comunicaciones de alta velocidad que
conecta microcomputadoras o PC y/o periféricos que se encuentran cercanos, por lo general
dentro del mismo edificio. Una LAN consta de hardware y software de red y sirve para
conectar las que están aisladas. Una LAN da la posibilidad de que los PC compartan entre ellos
programas, información y recursos, como unidades de disco, directorios e impresoras y de esta
manera esta a disposición la información de cada puesto de trabajo los recursos existentes en
otras computadoras.
Características de las LAN's: El radio que abarca es de pocos kilómetros, Por ejemplo: edificios,
un campus universitario, un complejo industrial, etc. Utilizan un medio privado de
comunicación. La velocidad de transmisión es de varios millones de bps. Las velocidades más
habituales van desde 1 hasta 16 Mbits, aunque se está elaborando un estándar para una red
que alcanzará los 100 Mbps. Pueden atender a cientos de dispositivos muy distintos entre sí
(impresoras, ordenadores, discos, teléfonos, módems, etc.).
Es un sistema de comunicación de alta velocidad que conecta PC's, entre sí para intercambiar
información, similar a la LAN; aunque estos no están limitados geográficamente en tamaño. La
WAN suele necesitar un hardware especial, así como líneas telefónicas proporcionadas por
una compañía telefónica.
Topología de redes.
Se llama topología de una Red al patrón de conexión entre sus nodos, es decir, a la forma en
que están interconectados los distintos nodos que la forman. Los Criterios a la hora de elegir
una topología, en general, buscan que eviten el coste del encaminamiento (necesidad de elegir
los caminos más simples entre el nodo y los demás), dejando en segundo plano factores como
la renta mínima, el coste mínimo, etc. Otro criterio determinante es la tolerancia a fallos o
facilidad de localización de éstos. También tenemos que tener en cuenta la facilidad de
instalación y reconfiguración de la Red.
* Topología en bus
Una Red en forma de Bus o Canal de difusión es un camino de comunicación bidireccional con
puntos de terminación bien definidos. Cuando una estación trasmite, la señal se propaga a
ambos lados del emisor hacia todas las estaciones conectadas al Bus hasta llegar a las
terminaciones del mismo. Así, cuando una estación trasmite su mensaje alcanza a todas las
estaciones, por esto el Bus recibe el nombre de canal de difusión.
* Topología en anillo
Esta se caracteriza por un camino unidireccional cerrado que conecta todos los nodos.
Dependiendo del control de acceso al medio, se dan nombres distintos a esta topología: Bucle;
se utiliza para designar aquellos anillos en los que el control de acceso está centralizado (una
de las estaciones se encarga de controlar el acceso a la red). Anillo; se utiliza cuando el control
de acceso está distribuido por toda la red. Como las características de uno y otro tipo de la red
son prácticamente las mismas, se utiliza el término anillo para las dos.
* Topología estrella
La topología en estrella se caracteriza por tener todos sus nodos conectados a un controlador
central. Todas las transacciones pasan a través del nodo central, siendo éste el encargado de
gestionar y controlar todas las comunicaciones. Por este motivo, el fallo de un nodo en
particular es fácil de detectar y no daña el resto de la red, pero un fallo en el nodo central
desactiva la red completa.
Para comunicarse con el resto de la red, cada computadora debe tener instalada una tarjeta
de interfaz de red (Network Interface Card, NIC). Se les llama también adaptadores de red o
sólo tarjetas de red. En la mayoría de los casos, la tarjeta se adapta en la ranura de expansión
de la computadora, aunque algunas son unidades externas que se conectan a ésta a través de
un puerto serial o paralelo. Las tarjetas internas casi siempre se utilizan para las PC's, PS/2 y
estaciones de trabajo como las SUN's. Las tarjetas de interfaz también pueden utilizarse en
mini computadoras y mainframes. A menudo se usan cajas externas para Mac's y para algunas
computadoras portátiles.
1.
3. Buffering
4. Formación de paquetes
6. Codificación y decodificación
7. Acceso al cable
8. Saludo
9. Transmisión y recepción.
11. Cada categoría especifica unas características eléctricas para el cable: atenuación,
capacidad de la línea e impedancia. Existen actualmente 8 categorías dentro del cable UTP:
12.
13. Categoría 1: Este tipo de cable esta especialmente diseñado para redes telefónicas, es el
típico cable empleado para teléfonos por las compañías telefónicas. Alcanzan como máximo
velocidades de hasta 4 Mbps.
15. Categoría 3:Es utilizado en redes de ordenadores de hasta 16 Mbps. de velocidad y con
un ancho de banda de hasta 16 Mhz.
16. Categoría 4: Esta definido para redes de ordenadores tipo anillo como Token Ring con un
ancho de banda de hasta 20 Mhz y con una velocidad de 20 Mbps.
18.
19. Categoría 5e: Es una categoría 5 mejorada. Minimiza la atenuación y las interferencias.
Esta categoría no tiene estandarizadas las normas aunque si esta diferenciada por los
diferentes organismos.
21. Categoría 7:No esta definida y mucho menos estandarizada. Se definirá para un ancho de
banda de 600 Mhz. El gran inconveniente de esta categoría es el tipo de conector seleccionado
que es un RJ-45 de 1 pines.
22. En esta tabla podemos ver para las diferentes categorías, teniendo en cuenta su ancho de
banda, cual sería las distancias máximas recomendadas sin sufrir atenuaciones que hagan
variar la señal:
* Fibra multimodal
En este tipo de fibra viajan varios rayos ópticos reflejándose a diferentes ángulos, los
diferentes rayos ópticos recorren diferentes distancias y se desfasan al viajar dentro de la fibra.
Por esta razón, la distancia a la que se puede trasmitir está limitada.
En este tipo de fibra óptica el núcleo está hecho de varias capas concéntricas de material
óptico con diferentes índices de refracción. En estas fibras el número de rayos ópticos
diferentes que viajan es menor y, por lo tanto, sufren menos el severo problema de las
multimodales.
* Fibra monomodal:
Esta fibra óptica es la de menor diámetro y solamente permite viajar al rayo óptico central. No
sufre del efecto de las otras dos pero es más difícil de construir y manipular. Es también más
costosa pero permite distancias de transmisión mayores.
Transmisión
* Voz
* Datos
* Imágen
* Vídeo
* Banda base es la señal de una sola transmisión en un canal, banda ancha significa que lleva
más de una señal y cada una de ellas se transmite en diferentes canales, hasta su número
máximo de canal.
* En los sistemas de transmisión, la banda base es generalmente utilizada para modular una
portadora. Durante el proceso de demodulación se reconstruye la señal banda base original.
Por ello, podemos decir que la banda base describe el estado de la señal antes de la
modulación y de la multiplexación y después de la demultiplexación y desmodulación.
Red de área metropolitana (MAN): una red que conecta las redes de un área (dos o más redes
locales juntas) pero que no se extiende más allá de los límites de la ciudad inmediata, o del
área metropolitana. Los enrutadores (routers) múltiples, los interruptores (switch) y los cubos
están conectados para crear una MAN.
La arquitectura SNA
Es un modelo que presenta similitudes con el modelo de referencia OSI. Se compone de las
siguientes capas:
Física: SNA no define protocolos específicos para su capa de control física. Se puede emplear
cualquier otro estándar para su implementación.
Control de Enlace de Datos -Data link control (DLC)-: Define varios protocolos incluidos el SDLC
(Synchronous Data Link Control) y el protocolo de comunicación Token Ring Network para LAN
entre iguales (peers).
Control de ruta -Path control-: Implementa mucha de las funciones de la capa de red OSI.
Control de transmisión ʹTransmission control-: Proporciona un servicio de conexión de punta a
punta confiable, así como servicios de cifrado y descifrado.
Control de Flujo de Datos ʹData flow control-: Administra el procesamiento de las peticiones y
respuestas, asigna el turno para la comunicación, y puede interrumpir el flujo de información
pedida.
Interfaz
Lo que permite que dos entidades distintas se comuniquen. Por ejemplo entre un un frances y
un español el interfaz seria el correspondiente diccionario bilingue. Entre dos equipos, A yB
cada uno con una salida para transmitir y una entrada para recibir, el interfaz seria el cable
cruzado que conectase transmisor A con receptor B y transmisor B con receptor A.
Protocolo
Conjunto de reglas de comunicación que dos entidades conocen y respetan para realizar
conjuntamente la función que tienen asignada. Un protocolo es por tanto un lenguaje, con su
sintaxis, su semántica y su adecuada temporización. La sintaxis entronca con el como, la
semántica con el qué (el significado), y la temporización con el cuando. Los hay monolíticos y
estructurados.
Protocolos monolíticos
Protocolos estructurados
Arquitectura de protocolos
Servicio
Conjunto de funciones que realiza un nivel de la jerarquía de la arquitectura de protocolos y
todos los inferiores, para ofrecer una funcionalidad al nivel inmediatamente superior que se
considera usuario del anterior.
Entidades gemelas:
Son entidades que se entienden. Siempre que en una arquitectura de protocolos tenemos una
entidad de un tipo, la entidad con la que está dialogando tiene que ser igual, nivel por nivel.
PDU:
Plano de usuario: Información que fluye desde la aplicación hasta el nivel físico (cables, aire͙).
Por el fluyen los datos del usuario.
Plano de señalización y control: Información para la utilización de los servicios de la red, entre
organos de la red. Se conoce como información de señalización. La genera y la destruye la
propia red.
RAIZ. Los cables comienzan en mencionado punto y cada uno presentan ranmificaciones. La
transmisión se propaga a través del medio y alcanza al resto de estaciones.
ESTRELLA.- Cada estación está directamente conectada a un nodo central generalmente a dos
enlaces de punto a punto, uno para transmisión y otro para recepción.El modo de
funcionamiento es de difusión; es decir cuando se transmite una trama de información por
parte de una estación se retransmite sobre todos los enlaces de salida del nodo central. Solo
se puede transmitir una estación en un tiempo determinado.También el nodo central funciona
como dispositivo de conmutación de tramas
El MAC es el mecanismo encargado del control de acceso de cada estación al medio. El MAC
puede realizarse de forma distribuida cuando todas las estaciones cooperan para determinar
cuál es y cuándo debe acceder a la red. También se puede realizar de forma centralizada
utilizando un controlador.
Esta capa es la encargada de transmitir tramas entre dos estaciones sin tener que pasar por
ningún nodo intermedio. Esta capa debe permitir el acceso múltiple. Esta capa debe identificar
todos los posibles accesos a ella, ya sean de una capa superior como estaciones destino u
otros.
- Servicios LLC: el LLC debe controlar el intercambio de datos entre dos usuarios, y para ello
puede establecer una conexión permanente, una conexión cuando se requiera el intercambio
de datos o una mezcla de ambas (sólo se establece conexión permanente cuando sea
necesaria).
- Protocolo LLC: hay varias formas de utilización de este protocolo que van desde envíos de
tramas con requerimiento de trama de confirmación hasta conexiones lógicas entre dos
estaciones previo intercambio de tramas de petición de conexión.
El método de asignación de canal descentralizado en este no hay una entidad central. Cada
máquina debe decidir por sí misma si transmite o no.
TOPOLOGIA EN BUS Y ARBOL
MEDIO MULTIPUNTO
LAN EN BUS
BALANCEO DE LA SEÑAL
LA SEÑAL DEBE SER LO SUFICIENTE FUERTE PARA CUMPLIR LOS REQUISITOS DE LOS
RECEPTORES EN CUALQUIER COMBINACION DE TRANSMISION
PAR TRENZADO
USADO EN ETHERNET
TOPOLOGIA EN ANILLO
LAN EN ANILLO
LOS PAQUETES SON ELIMINADOS POR EL REPETIDOR DESTINO O POR EL QUE LO ENVIO
MEDIO EN EL ANILLO
PAR TRENZADO, COAXIAL BANDA BASE, FIBRA OPTICA, NO USA CABLE COAXIAL BANDA ANCHA
TOPOLOGIA EN ESTRELLA
. Un circuito de conmutación estará compuesto por una serie de contactos que representarán
las variables lógicas de entrada y una o varias cargas que representarán las variables lógicas o
funciones de salida. Los contactos pueden ser normalmente abiertos (NA) o normalmente
cerrados (NC). Los primeros permanecerán abiertos mientras no se actúe sobre ellos (por
ejemplo al pulsar sobre interruptor, saturar un transistor, etc.). Los contactos NC funcionarán
justamente al contrario. Esto significa que si se actúa sobre un contacto NA se cerrará y si se
hace sobre uno NC se abrirá.
(TICS)
Características:
Tiempo Compartido
* Proceso por lotes: Cuando los trabajos se preparan antes de procesar y luego se
ingresan ordenadamente (por lotes) al ordenador, que los procesa con la prioridad que se le
indique.
* Proceso por lotes remoto: Cuando sufre un procedimiento idéntico al proceso por
lotes, pero con la variante que los datos son enviados usando redes de telecomunicaciones al
ordenador que se encargará de procesarlos.
* Un ordenador actúa en diálogo con sus equipos terminales en tiempo real, cuando
devuelve los resultados con suficiente rapidez como para afectar el funcionamiento o
interactuar con el medio que los produjo en tiempo diferido.
En Línea (on-line)
Interactivo
No Interactivo
* Fuera de línea (off-line): Cuando los datos que serán usados por el ordenador, se
reciben en una terminal local, siendo grabados primero en tarjetas perforadas, medios
magnéticos u otros equipos intermedios, para ser posteriormente ingresados al ordenador. Si
se trata de la salida de datos con destino a un usuario remoto, el proceso sería análogo. Los
datos que se han procesado en un ordenador se colocan en un soporte intermedio y a través
de un terminal periférico son enviados al terminal distante.
* En línea (on-line): Cuando los datos de entrada pasan desde su lugar de origen a
donde se utilizan en forma directa y, viceversa los datos procesados se envían desde el
ordenador al usuario directamente. Este proceso evita las etapas intermedias de perforación o
grabación, para su posterior procesamiento. Su uso es necesario en aquellas aplicaciones
donde se necesita una rápida reacción por parte del sistema informático.
* No interactivo: Cuando los datos enviados no son procesados en forma directa con el
objeto de dar una respuesta inmediata. Sin embargo, sí se puede confirmar la correcta
recepción de ellos.
SEÑAL DIGITAL
Una señal es digital cuando sus valores se representan con variables discretas en vez de
continuas. En el caso de la informática se utilizan ceros y unos (sistema binario).Por ejemplo,
las computadoras utilizan dos niveles de tensión eléctrica distintos representando el cero o el
uno, permitiendo así aplicar lógica y aritmética binaria.
Para obtener la secuencia que compone la señal digital a partir de los datos digitales se efectúa
un proceso denominado codificación. Existen multitud de métodos de codificación,
mencionaremos seguidamente los más usuales.
NRZ (No Return to Zero): Es el método que empleamos para representar la evolución de una
señal digital en un cronograma. Cada nivel lógico 0 y 1 toma un valor distinto de tensión.
NRZI (No Return to Zero Inverted): La señal no cambia si se transmite un uno, y se invierte si se
transmite un cero.
RZ (Return to Zero): Si el bit es uno, la primera mitad de la celda estará a uno. La señal vale
cero en cualquier otro caso.
Manchester: Los valores lógicos no se representan como niveles de la señal, sino como
transiciones en mitad de la celda de bit. Un flanco de bajada representa un cero y un flanco de
subida un uno.
Manchester diferencial: Manteniendo las transiciones realizadas en el método Manchester, en
este método introduce la codificación diferencial. Al comienzo del intervalo de bit, la señal se
invierte si se transmite un cero, y no cambia si se transmite un uno.
SEÑAL ANALÓGICA
Una señal analógica es un voltaje o corriente que varía suave y continuamente. Una onda
senoidal es una señal analógica de una sola frecuencia. Los voltajes de la voz y del video son
señales analógicas que varían de acuerdo con el sonido o variaciones de la luz que
corresponden a la información que se está transmitiendo.
Al proceso por el cual obtenemos una señal analógica a partir de unos datos digitales se le
denomina modulación. Esta señal la transmitimos y el receptor debe realizar el proceso
contrario, denominado demodulación para recuperar la información. El módem es el
encargado de realizar dicho proceso. Algunos esquemas simples de modulación son:
Transmisión Asíncrona:
Es aquella que se transmite o se recibe un carácter, bit por bit añadiéndole bits de inicio, y bits
que indican el término de un paquete de datos, para separar así los paquetes que se van
enviando/recibiendo para sincronizar el receptor con el transmisor. El bit de inicio le indica al
dispositivo receptor que sigue un carácter de datos; similarmente el bit de término indica que
el caracter o paquete ha sido completado.
Transmisión Síncrona:
Este tipo de transmisión el envío de un grupo de caracteres en un flujo continúo de bits. Para
lograr la sincronización de ambos dispositivos (receptor y transmisor) ambos dispositivos
proveen una señal de reloj que se usa para establecer la velocidad de transmisión de datos y
para habilitar los dispositivos conectados a los módems para identificar los caracteres
apropiados mientras estos son transmitidos o recibidos. Antes de iniciar la comunicación
ambos dispositivos deben de establecer una sincronización entre ellos. Para esto, antes de
enviar los datos se envían un grupo de caracteres especiales de sincronía. Una vez que se logra
la sincronía, se pueden empezar a transmitir datos. Se llama sincronización al proceso
mediante el que un emisor informa a un dispositivo receptor sobre los instantes en que van a
transmitirse las correspondientes señales.
MODOS DE TRANSMISION
Una transmisión dada en un canal de comunicaciones entre dos equipos puede ocurrir de
diferentes maneras. La transmisión está caracterizada por: la dirección de los intercambios, el
modo de transmisión, el número de bits enviados simultáneamente, la sincronización entre el
transmisor y el receptor
* Una conexión simple, es una conexión en la que los datos fluyen en una sola dirección,
desde el transmisor hacia el receptor. Este tipo de conexión es útil si los datos no necesitan
fluir en ambas direcciones (por ejemplo: desde el equipo hacia la impresora o desde el ratón
hacia el equipo.).
* Una conexión dúplex total es una conexión en la que los datos fluyen simultáneamente en
ambas direcciones. Así, cada extremo de la conexión puede transmitir y recibir al mismo
tiempo; esto significa que el ancho de banda se divide en dos para cada dirección de la
transmisión de datos si es que se está utilizando el mismo medio de transmisión para ambas
direcciones de la transmisión.
Conexión Paralela
Conexión en Serie
En una conexión en serie, los datos se transmiten de a un bit por vez a través del canal de
transmisión. Sin embargo, ya que muchos procesadores procesan los datos en paralelo, el
transmisor necesita transformar los datos paralelos entrantes en datos seriales y el receptor
necesita hacer lo contrario.
Banda Base: el término banda base se refiere a la banda de frecuencias producida por un
transductor , tal como un micrófono , un manipulador telegráfico u otro dispositivo generador
de señales, antes de sufrir modulación alguna.
Banda base es la señal de una sola transmisión en un canal, banda ancha significa que lleva
más de una señal y cada una de ellas se transmite en diferentes canales, hasta su número
máximo de canal.
Modulación: proceso mediante el cual se utiliza la señal de banda base para modificar algún
parámetro de una señal portadora de mayor frecuencia.
Ancho de Banda: es la cantidad de información o de datos que se puede enviar a través de una
conexión de red en un período de tiempo dado. El ancho de banda se indica generalmente en
bits por segundo (bps), kilobits por segundo (kbps), o megabits por segundo (mbps).
INTRODUCCION
Para que una información sea tratada es necesario transmitirla, y para que exista
transmisión de información son necesarios tres elementos:
El elemento humano
Actualmente se utiliza el término firmware para denominar cierta parte del software
que traen las computadoras pregrabadas desde su fabricación y que puede estar en memorias
de tipo ROM (memorias de solo lectura) o incorporado en su placas de circuitos.
INFORMATICA
RESEÑA HISTORICA
El sueño de Babbage, que para muchos de sus contemporáneos era ͞la locura de
Babbage͟, hubiera incluido una entrada por tarjetas perforadas, una unidad de memoria, o
almacén, , una unidad aritmética, o molino, la impresión automática de salida, el control
secuencial por programa y una exactitud de 20 cifras. En pocas palabras, Babbage había
diseñado un prototipo de computadora que estaba adelantada 100 años a su época.
Lady Augusta Ada Lovelace, hija de Lord Byron, el poeta, ayudó a Babbage. Ella era una
brillante matemática y corrigió algunos errores en el trabajo de Babbage e inventó formas
novedosas de enfocar el diseño de programas empleando tarjetas perforadas. Por estos
descubrimientos muchos la consideran la primera programadora de computadoras. Al morir
Babbage, el desarrollo de las computadoras se detuvo hasta 1937 ; las tarjetas perforadas
dominaron el mundo del proceso de datos. El norteamericano Hermann Hollerith (1860-1929)
construyó en 1885 las primeras maquinas que funcionaban con tarjetas perforadas y el
sistema empleado fue perfeccionado por su compatriota Legrand Powers y por el ingeniero
noruego Frederick Bull (1882-1925).
En 1937, Howard Aiken, profesor de Harvard, se fijo la meta de construir una maquina
calculadora automática que combinara la tecnología eléctrica y mecánica con las técnicas de
las tarjetas perforadas de Hollerith. Con la ayuda de estudiantes de posgrado e ingenieros de la
IBM, el proyecto se completó en 1944. El aparato terminado se denomino la computadora
digital MARK 1. Las operaciones internas se controlaban automáticamente con relevadores
electromagnéticos, y los contadores aritméticos eran mecánicos ; así la MARK 1 era una
computadora electromecánica. En muchos aspectos era el sueño de Babbage hecho realidad.
Esta maquina medieval actualmente se exhibe en la universidad de Harvard.
GENERACIONES DE COMPUTADORAS
TERCERA GENERACION : Abarca los años 60-70. Manejan chips ; permiten hacer operaciones
matemáticas y lógicas. Aparecen circuitos integrados, tarjetas impresas ; ocupa cientos de
miles de componentes. Se generaliza el uso de las computadoras. Microcomputadoras
PROCESO UNICO. Memoria RAM de 16 KB.
QUINTA GENERACION : Abarca los años 80-90 sus chips son mejorados y la tecnología se
vuelve escalable, es decir, que podemos aumentarle la capacidad de memoria, disco duro,
instalar un equipo multimedia, cambiar un monitor monocromático (blanco y negro) por uno
VGA (color); sin la necesidad de comprar otra computadora.
ORDENADOR
SOFTWARE : Parte intangible de un sistema de computación que viene a ser todos los
programas que permiten la comunicación entre el ordenador y el usuario.
TRADUCTOR : A fines de la década de los 40, cada programa tenia que estar escrito en lenguaje
maquina, el único lenguaje que una computadora puede entender directamente. Todos los
usuarios tenían que escribir programas compuestos de largas cadenas de ceros y unos para
especificar la dirección de información.
2. Un grupo de datos que contiene información de control, por ejemplo, qué clase de listados
se deben producir.
SISTEMA OPERATIVO DE APLICACIÓN PARTICULAR : Son los que están hechos para un fin
especifico ejemplo programas de contaduría, ingeniería, física, gráficos, etc.
SISTEMA OPERATIVO DE APLICACIÓN GENERAL : Son los que pueden realizar trabajos de
cualquier tipo como Word, excel, powerpoint, etc.
HARDWARE : Parte tangible en un sistema que vienen a ser los componentes, es decir, los
dispositivos de entrada y salida, el CPU o la unidad central de proceso.
d Dispositivos de entrada,
d Dispositivos salida
DISPOSITIVOS DE ENTRADA : Son los componentes físicos que permiten introducir información
a la computadora como son el teclado, Mouse, micrófono, scanner, CD rom.
[pic]
1. teclado alfanumérico
2. teclado numérico
3. teclado de funciones
5. teclado de direcciones
DISPOSITIVOS DE SALIDA : Son los componentes físicos que nos permiten recibir
información procesada ( monitor, impresora ).
IMPRESORA : Las impresoras son órganos de salida que escriben las informaciones
procedentes de la memoria central del ordenador o los resultados de un tratamiento. Hay que
distinguir, entre los diferentes modelos existentes, los que están provistos de rueda, barras o
cadenas.
Los primeros, considerados lentos, son capaces de imprimir 120 caracteres o signos,
correspondientes a las 120 ruedas que tienen. Cada una de éstas tiene 48 tipos (letras de
alfabeto, cifras, signos de puntuación, blancos, etc.) y todas adoptan en un momento dado la
disposición idónea para escribir de una sola vez la línea completa.
Los segundos, algo más rápidos, poseen un máximo de 144 caracteres o signos sujetos
a una varilla metálica que se mueve horizontalmente de modo rectilíneo y alterno. Un martillo,
accionado por un electroimán, presiona la barra contra el papel cuando el tipo seleccionado
pasa por delante de la zona de impresión.
Los terceros tienen un sistema análogo al interior, aunque son más rápidos, y están
provistos de una banda metálica circular que gira a velocidad constante.
Los órganos o circuitos de cálculo, que efectúan las operaciones aritméticas y lógicas propias
del tratamiento de la información, se encuentran situados en la memoria central y reciben el
nombre de sumadoras. Un ordenador lleva a cabo una sucesión de sumas o de restas para
obtener un producto o un cociente. Los circuitos suelen ir montados en serie o en paralelo. En
el primer caso se repiten las operaciones varias veces, tantas como cifras tiene el mayor de los
sumandos, mientras que en el segundo, con una simple operación, seconsigue el resultado.
Este último método proporciona, por tanto, mayor rapidez en los cálculos y un rendimiento
muy superior al citado anteriormente.
Los órganos de conmutación sirven para abrir o cerrar los circuitos lógicos de las
operaciones. En informática sólo existen dos posibilidades, claramente determinadas por la
disyuntiva « o » o por la copulativa « y » (A o B, A y B). Cada opción o caso puede, a su vez, ser
la combinación de otros varios. Hay tres tipos de órganos de conmutación : uno queinvierte
los datos de entrada, otro que ejecuta una acción únicamente en presencia de un fenómeno
F1, de otro F2 o de los dos, y un tercero que actúa si éstos se verifican de modo simultáneo.
Se divide en :
13. OPERADOR : Capta los operadores como son los signos :+,*,/,**,=,etc.
14. REGISTRO DE ESTADO : Capta el numero de acciones que puede realizar nuestra
computadora.
Existe también el bu general que realiza las funciones de los buses de control, dirección
y de datos. La ventaja de este tipo de bu es que es mas económico pero su desventaja es que
se tiene que realizar el mapeo de direcciones en memoria ya que puede que las direcciones de
la memoria sean las mismas direcciones que los periféricos y para evitar confusiones se
cancelan las direcciones en memoria que sean iguales a las de los componentes.
TRATAMIENTO DE LA INFORMACION
Los símbolos gráficos empleados en Europa son las 26 letras del alfabeto, diez guarismos
decimales, algunos signos de puntuación y una serie de símbolos matemáticos. Las palabras
están formadas por agrupaciones de letras, y las oraciones por conjuntos de palabras
organizadas según las reglas gramaticales. La yuxtaposición de cifras constituye los números,
que se rigen por leyes aritméticas.
Existen códigos que nos permiten a nosotros interactuar con la computadora como son
el código ASCII y el EBCDIC que son códigos que tienen los equivalentes de todas las letras,
números y signos en su valor binario para que la computadora lo ͞entienda͟.
Las unidades de información que tiene la computadora son :
Un dato es la expresión general que describe los objetos con los cuales opera una
computadora.
Los diferentes objetos de información con los que un programa trabaja se conocen
colectivamente como datos. Todos los datos tienen un tipo asociado con ellos.
Aun cuando los datos e instrucciones pueden tener la misma forma o expresión, se
hace una distinción funcional entre ellos, una instrucción comando a la computadora paraque
realice una operación mientras que los datos representan información. Las computadoras solo
procesan y manejan datos :
ENTRADA SALIDA DE
El tipo de un dato determina la naturaleza del conjunto de valores que puede tomar una
variable o constante. Otro concepto importante a tener en cuenta es la representación interna
de los números, o al menos el espacio de memoria ocupado por una variable de un tipo dado.
A) ESTATICOS
B) DINAMICOS
A) SIMPLES
B) ESTRUCTURADOS
Los tipos de datos simples o primitivos significan que no están compuestos de otras
estructuras de datos ; Los tipos de datos simples pueden ser organizados en diferentes
estructuras de datos : estáticos y dinámicos.
Las estructuras de datos estáticos son aquellas en las que el tamaño ocupado en
memoria se define antes que el programa se ejecute y no puede modificarse dicho tamaño
durante la ejecución del programa. (El tamaño ocupado en memoria es fijo).
Una estructura de datos es una colección de datos, donde cada dato puede tomar
diferente tipo de dato.
Una característica importante que diferencia a los tipos de datos es la siguiente : los
tipos de datos simples tienen como característica común que un identificador (nombre) puede
representar a múltiples datos individuales, pudiendo cada uno de estos ser referenciados
independientemente.
b) LOGICOS
c) CARÁCTER
1) 5 2) 2456 3) 48763
DATOS LOGICOS : El tipo lógico también se le denomina booleano, este tipo de dato solo
puede tomar uno de dos valores : cierto o verdadero (true) y falso (false). Este tipo se emplea
para representar las alternativas (si/no) a determinadas condiciones. Ocupa un byte en
memoria.
TIPOS DE REDES
REDES : Define el intercambio de información dentro de una red de teleproceso. Se ocupa del
agrupamiento de tramas en paquetes, del direccionamiento y de la detección y corrección de
errores.
LAN : Son aquellas que están establecidas en un área determinada. Pueden tener de L
a N usuarios. A cada terminal que atienda un usuario va a ser un nodo. Tiene que tener cuando
menos un servidor, un nodo, conectores necesarios, tarjetas de red necesarios, línea de
comunicación, sistema operativo de red, un DOS, software de aplicación para red y protocolos.
(Los anteriores son los elementos básicos para una red).
Integridad: Que el paquete de datos que estoy mandando por la línea debe ser igual
cuando llegue.
TOPOLOGIA DE REDES
DE ANILLO : Es una variante de la de bus, solo que para evitar el tapón BNC y las caídas
de red, la última parte se conecta a la terminal. La forma más común de instalación es con
cable coaxial.
SIMPLEX : la transmision de datos se realiza en un unico sentido, desde una estacion emisora a
una estacion receptora, que generalmente corresponde a una terminal como origen y una
computadora central como destino, o bien una computadora como origen y una impresora o
unidad de visualizacion como destino. Este modo de transmision es el menos utilizado.
CABLES DE CUADRETES: Similares a los anteriores, pero utilizando cuatro hilos conductores, de
dos tipos diferentes según el trenzamiento.
CABLES COAXIALES: Formados por un hilo conductor central y otro cilíndrico exterior (trenzado
de hilos o lámina de aluminio). El cable está recubierto de material aislante, ocupando también
el espacio entre el cilindro conductor y el hilo central.
Clasificación:
Todas las redes WAN requieren un emisor receptor, un decoder y un medio. Los
medios para conectar un WAN son microondas, vía satélite y fibra óptica.
CONCLUSIONES
Resulta necesaria, por consiguiente, una legislación destinada a poner coto a los
abusos que podrían cometer el Estado o las empresas en detrimento de las personas. Dichas
leyes deberían prever una serie de medidas encaminadas a controlar y a limitar el contenido
de los ficheros, así como a reglamentar el acceso a los mismos. La informática, al conducir a
una mayor automatización, suscita cierta animadversión por creerse que puede traer consigo
la supresión de determinados puestos de trabajo. Este inconveniente, originado por el
principio económico de buscar siempre la mayor rentabilidad, desaparece, sin embargo,
cuando los gobiernos tienen programas de reconversión para los empleados perjudicados.
Cabe recordar además que, si bien esta tecnología suprime las tareas subalternas, por
otra parte requiere la participación de un personal de muy alto nivel.
www.google.com.ve/buscadores
www.rincondelvago.com/buscadores
www.monografias.com
047O0482
INGENIERIA ELECTRONICA
0442281128562
8100173
russel_35@Hotmail.com
ASESOR INTERNO
ASESOR EXTERNO
ÍNDICE
I. INTRODUCCION. 7
V. JUSTIFICACIÓN 10
CAPITULO I ANTECEDENTES 11
1.1. INFORMACION 12
1.2. EDUCACION 13
1.3. CAPACITACION 13
1.4. CULTURA 14
1.5. ENTRETENIMIENTO 15
1.6. MISION 17
1.7. VISION 17
2.2 GPS 25
2.2.1 FUNCIONAMIENTO 26
2.2.2 TRIANGULACIÓN 27
2.5.1 DEFINICION. 36
2.5.8.2 VELOCIDAD 55
2.5.8.3 CONECTORES 56
3.2.1.1 MICROCONTROLADOR 66
4.1 PRUEBAS 84
CONCLUSIONES. 89
ANEXOS 91
BIBLIOGRAFIA. 97
INDICE DE IMÁGENES
Imagen 23.- Transmisión asíncrona con velocidad menor que la máxima posible49
INDICE DE TABLAS
INTRODUCCION.
En la actualidad la electrónica avanza cada día a grandes pasos en muchas de las áreas en
donde el ser humano tiene contacto, como por ejemplo en la casa para hacer más
reconfortante la vida del ser humano, en las industrias, donde se requieren mayor seguridad, y
para la automatización de maquinaria etc.
Para esto, se realizo un prototipo de un dispositivo electrónico que a lo largo de este escrito se
le llamara Master, en el cual será capaz de adquirir automáticamente la hora de la
computadora del usuario, para a si después poder mandarla hacia deferentes dispositivos
electrónicos que los llamaremos Slave y mantener un estado de sincronía entre ambos y a su
vez poder mantener un error de +/- 1% diario, en el cual este error se corregirá al termino de
cada día.
Todo esto se realizo bajo un protocolo de comunicación serial RS-232, en donde este protocolo
los datos se transmitirán en una sola línea, por lo que hace que sea mucho menos costoso y
contara con menor disposición a errores.
La realización del proyecto surge de la necesidad de tener sincronizados más de dos sistemas
físicamente distantes, para que las operaciones que realicen tales sistemas ocurran en
instantes de tiempo conocidos y en tiempos con la exactitud requerida por la empresa de
Radiotelevisión de Veracruz (RTV). Para esta empresa es de suma importancia efectuar sus
labores de transferencia de información de tal manera que todos los sistemas de
comunicación mantengan una sincronía exacta.
A la fecha, cada foro en RTV es una isla respecto a los otros foros. En cada foro se tiene un
horario que puede llegar a diferir significativamente del resto de los foros. Como en conjunto,
se requiere coordinar las actividades de estos foros, es una necesidad que todos ellos
compartan el mismo horario, que la hora de uno a otro foro no sea distinta. Pues de seguir
esta situación, se continuará con los problemas de coordinación existentes.
Y esta supervisión es aún más difícil cuando se trata de que revisar foros distantes entre sí por
más de 90 metros. Por otro lado, continua el factor humano que es una fuente potencial de
errores, al ser personal de la empresa el encargado de ajustar, a su entender, los relojes de
cada uno de los foros.
OBJETIVO GENERAL
Diseñar e instrumentar un dispositivo electrónico llamado MASTER capaz de comunicarse en
una red con otros dispositivos electrónicos conocidos como SLAVES, y mantener con estos
últimos una sincronización de sus relojes con un retraso no mayor a los 100 mS.
OBJETIVOS ESPECÍFICOS
Diseñar e instrumentar el dispositivo MASTER, que sea capaz de mantener y mostrar la hora
actual con error de menos del 1% diario.
Rediseñar el MASTER para que sea posible reconfigurar su hora de inicio a través del uso de
botones.
Lograr que la transmisión de los datos generados por el dispositivo Master sean recibidos por
los dispositivos Slaves utilizando un protocolo de comunicación serial.
JUSTIFICACIÓN
Y es por esto que se diseñaran e implementara un dispositivo electrónico llamado Master, que
será el encargado de generar los pulsos sincronos. Además se diseñaran e implementaran
dispositivos electrónicos llamados Slaves para cada uno de los foros que serán sincronizados
por el Master.
CAPITULO I ANTECEDENTES
El 6 de enero de 1980, el Licenciado José López Portillo inauguró oficialmente las instalaciones
del primer canal cultural estatal, no sólo de México sino de América Latina, en el Estado de
Veracruz, con las siglas XHGV y en la frecuencia de Radiotelevisión de Veracruz, inicia sus
operaciones tratando de ser una alternativa de comunicación para los veracruzanos.
ͻ Información
ͻ Educación
ͻ Capacitación
ͻ Cultura
ͻ Entretenimiento
1 INFORMACION
Dar a conocer a la población lo que acontece en la entidad, es tarea fundamental del equipo
de comunicadores que laboran en los puntos más apartados del territorio, para llevar a los
hogares veracruzanos la información de los sucesos que marcan nuestra historia.
Con la transmisión de todos los eventos de interés general, el televidente participa de los
aspectos sociales, económicos y políticos que conforman la vida de nuestro estado.
Para llevar a cabo esta tarea la Subdirección de noticias y programas informativos, cuenta
con recursos acordes a la nueva tecnología en comunicación como son: Telex, señales vía
satélite, cámaras portátiles, cabinas de grabación y edición y videoteca propia.
2 EDUCACION
En la renglón educativo, Radiotelevisión de Veracruz ha sido precursor en nuestro país con la
creación de un sistema para producción y transmisión de teleclases de nivel bachillerato
(TEBA).
[pic]
Este sistema fundado en 1980 brinda servicios a más de 5,000 alumnos que cursan sus
estudios en los 78 centros en activo. De 1982 a la fecha han egresado 9 generaciones con un
total de 12,000 bachilleres.
3 CAPACITACION
El estado de Veracruz se destaca por poseer, además de su estratégica posición frente al litoral
del Golfo de México, un vasto potencial en recursos renovables como la pesca, la agricultura y
la silvicultura.
Por tal motivo resulta necesaria la realización y transmisión de programas específicos que
apoyen las metas y acciones que han contemplado el Gobierno del Estado.
[pic]
4 CULTURA
Veracruz es un estado con una incalculable herencia histórica, cultura y política que todos sus
habitantes están obligados a conocer.
[pic]
Las expresiones artísticas en sus diversas facetas, son captadas y transmitidas a un gran
número de veracruzanos.
Esta tarea de difundir la cultura es uno de los principales objetivos de la televisora estatal.
5 ENTRETENIMIENTO
La diversión forma parte importante de las emisiones, de esta forma, se penetra en el gusto
del televidente. Los programas de entretenimiento ayudan a conservar el equilibrio de la barra
de programación y atraen de la atención del público.
[pic]
Por su parte la Dirección General cuenta con cuatro áreas específicas que conforman el
conjunto operativo de la institución.
Su cuenta con una transmisión de 100 horas a la semana, de las cuales 76 corresponden a
la producción local y 24 a producciones externas.
|Películas |18:30 |
|Entretenimiento |05:00 |
|Culturales |07:00 |
|Series |04:00 |
|Periodísticos |01:30 |
|Agropecuarios |01:00 |
|Deportivos |08:00 |
|Musicales |06:30 |
6 MISION
7 VISION
El estándar de escala de tiempo usado por muchos países es el UTC (Coordinated Universal
Time), que esta basado en la rotación de la tierra alrededor de su eje, y el calendario
Gregoriano, que esta basado en la rotación de la tierra alrededor del sol. La escala de tiempo
UTC esta en concordancia al TAI (International Atomic Time) insertando saltos de segundos en
intervalos de 18 meses aproximadamente. La hora UTC esta divulgada de diferentes maneras,
incluyendo sistemas de navegación por radio y satélite, módems, relojes portátiles, etc.
Por tanto podemos decir que el NTP sirve para sincronizar relojes de hosts y routers en
Internet. Este protocolo se estableció en los años 80 y era para Unix y después salió uno similar
SNTP (Short Network Time Protocol) para Windows, cuyo objetivo era poder sincronizar los
relojes de 2 computadores. La arquitectura, protocolo y algoritmos de NTP han ido
evolucionando durante los últimos 20 años hasta llegar al última versión NTP4 que es la
utilizada actualmente.
En las primeras versiones de NTP se podía establecer una precisión de milisegundos, pero
actualmente los PC, módems, redes, estaciones de trabajo, etc. son más rápidas por lo que es
necesaria una mayor precisión. Por ello en la ultima versión de NTP se proporcionan
precisiones de décimas de milisegundos en WANS (redes extensas), y milisegundos en LANS
(redes locales) y microsegundos usando como fuente de precisión de tiempo un oscilador de
cesio o un receptor GPS.
El protocolo de sincronización determina la diferencia entre la hora del reloj del servidor en
relación a la hora del cliente. Bajo petición, el servidor envía un mensaje incluyendo el valor de
la hora en ese momento (timestamp), y el cliente almacena esto en su timestamp. Para mayor
precisión, el cliente necesita medir el retraso de la propagación desde el servidor al cliente
para determinar su offset relativo al servidor. Pero como no es posible determinar el retraso
de un camino, a menos que el offset actual sea conocido, el protocolo mide el retraso total en
dar toda la vuelta y asume que los tiempos de propagación son estáticamente iguales en
cualquier dirección. En general esto es una aproximación útil, sin embargo en Internet hoy en
día, las rutas en la red y los retrasos asociados pueden diferir significativamente debido al
servicio individual de los proveedores.
1 ENCAPSULADO NTP.
Stratum1: En este stratum están los servidores primarios que se sincronizan con hora nacional
a través de radio, satélite, y módem.
Stratum2: Aquí aparecen servidores secundarios y clientes se sincronizan con los servidores
primarios a través de la subred jerárquica.
[pic]
2 CONFIGURACIONES NTP.
El protocolo NTP puede trabajar en uno o mas modos de trabajo, uno de ellos es el modo
cliente/servidor, también llamado maestro/esclavo. En este modo, un cliente se sincroniza con
un servidor igual que en el modo RPC convencional.
NTP también soporta un modo simétrico, el cual permite a cada uno de los dos servidores
sincronizarse con otro, para proporcionarse copias de seguridad mutuamente.
NTP también soporta el modo broadcast por el cual muchos clientes pueden sincronizarse con
uno o varios servidores, reduciendo el tráfico en la red cuando están involucrados un gran
número de clientes.
En NTP, el multicast IP también puede ser usado cuando la subred se abarca múltiples redes de
trabajo.
La configuración puede ser un serio problema en grandes subredes. Varios esquemas están en
bases de datos públicas y servicios de directorios en red que son usados para descubrir
servidores. NTP usa el modo broadcast para soportar grandes cantidades de clientes pero para
los clientes que solo escuchan es difícil calibrar el retraso y la precisión puede sufrir. En NTP,
los clientes determinan el retraso a la vez que buscan un servidor en modo cliente/servidor y
luego cambian a modo solo escucha. Además, los clientes NTP pueden hacer un broadcast de
un mensaje especial para solicitar respuestas de servidores cercanos y continuar en modo
cliente/servidor con los que le respondan.
[pic]
Con esto lo que podemos ver es que los servidores de un cierto nivel no solo se comunican con
un servidor de capa superior sino también con servidores de su misma capa.
3 ESQUEMA DE SINCRONIZACIÓN
Otras computadoras, que funcionan como servidores Stratum 2, utilizan un software similar
(usualmente el mismo), y consultan automáticamente al servidor primario para sincronizar su
reloj. A su vez, estos pueden sincronizar a otros servidores, que en este caso serán Stratum 3, y
así podría seguirse hasta 16 niveles. La arquitectura también soporta que un cliente haga sus
consultas a mas de un servidor y puede haber comunicaciones entre servidores de un mismo
stratum.
Cuanto mas alejado este una computadora del reloj de referencia, o sea, cuanto mas alto sea
su Stratum, menos precisa será la sincronización. Sin embargo, cualquier Stratum siempre será
suficiente para que el reloj no se aleje más de unos milisegundos de la hora real.
Hasta ahora definimos que una maquina, que llamaremos cliente, puede sincronizarse con
otra o con alguna referencia externa, y también puede comportarse como servidor, y utilizarse
para sincronizar otras. Siempre que haya una asociación entre dos maquinas, donde una se
comporte como cliente, y otra como servidor, al cliente le corresponderá el Stratum
inmediatamente superior al del servidor. Hay otra posibilidad, donde dos o mas maquinas se
configuran para comportarse entre si como clientes o servidores, según quien este mas cerca
de un reloj de referencia, o quien sea mas confiable de acuerdo con el algoritmo que rige la
sincronización por NTP. En este tipo de asociaciones, los servidores se llaman Peers.
Para utilizar NTP en una organización, recomendamos instalar un servidor que se sincronice
con varias fuentes externas. Este servidor será la única referencia horaria en la organización y
todos los equipos estarán sincronizados con el. Opcionalmente, podría instalarsecomo fuente
confiable un receptor GPS.
El servidor NTP instalado servirá para que todos los equipos de la organización lo utilicen para
ajustar sus relojes. Este ajuste será de gran importancia ya que permitirá, entre otras, la
correlación de eventos entre diferentes equipos.
La elección del equipo y el segmento de red donde se instale el servidor NTP quedan a criterio
de la administración de la red. Generalmente, el lugar mas adecuado es la DMZ, o el lugar
donde se encuentren los servidores que tienen contacto con el exterior. Sin embargo, como el
protocolo NTP utiliza paquetes UDP para sincronizarse, y el cliente es quien envía un paquete
para que el servidor responda, se podrá situar el servidor NTP en cualquier punto de la red. Los
clientes internos de la red se podrán sincronizar directamente con este servidor. En el caso en
que la organización posea gran cantidad de maquinas, o este distribuida en varios sitios
remotos, será conveniente la instalación de varios servidores, para que cada uno sirva de
sincronizador a un área especifica de cobertura.
[pic]
2 GPS
El Global Positioning System (GPS) o Sistema de Posicionamiento Global (más conocido con las
siglas GPS, aunque su nombre correcto es NAVSTAR-GPS) es un Sistema Global de Navegación
por Satélite (GNSS) que permite determinar en todo el mundo la posición de un objeto, una
persona, un vehículo o una nave, con una precisión hasta de centímetros, usando GPS
diferencial, aunque lo habitual son unos pocos metros. Aunque su invención se atribuye a los
gobiernos francés y belga, el sistema fue desarrollado e instalado, y actualmente es operado,
por el Departamento de Defensa de los Estados Unidos.
El GPS funciona mediante una red de 27 satélites (24 operativos y 3 de respaldo) en órbita
sobre el globo, a 20.200 km, con trayectorias sincronizadas para cubrir toda la superficie de la
Tierra. Cuando se desea determinar la posición, el receptor que se utiliza para ello localiza
automáticamente como mínimo tres satélites de la red, de los que recibe unas señales
indicando la posición y el reloj de cada uno de ellos. Con base en estas señales, el aparato
sincroniza el reloj del GPS y calcula el retraso de las señales; es decir, la distancia al satélite.
Por "triangulación" calcula la posición en que éste se encuentra. La triangulación en el caso del
GPS, consiste en averiguar el ángulo respecto de puntos conocidos, se basa en determinar la
distancia de cada satélite respecto al punto de medición. Conocidas las distancias, se
determina fácilmente la propia posición relativa respecto a los tres satélites. Conociendo
además las coordenadas o posición de cada uno de ellos por la señal que emiten, se obtiene la
posición absoluta o coordenada reales del punto de medición. También seconsigue una
exactitud extrema en el reloj del GPS, similar a la de los relojes atómicos que llevan a bordo
cada uno de los satélites.
1 FUNCIONAMIENTO
[pic]
El servicio básico de GPS provee una exactitud de aproximadamente 100 metros un 95% de el
tiempo Para lograr esto, cada uno de los 24 satélites emite una señal a los receptores en
tierra. GPS determina la localización al computar la diferencia entre el tiempo en que una señal
es enviada y el tiempo en que es recibida. Los satélites GPS llevan consigo relojes atómicos que
proveen información precisa en cuanto al tiempo. Una "estampilla de tiempo" (Esto es, el
tiempo en que se envío el mensaje desde orbita) es incluida en los mensajes de GPS para que
los receptores sepan cuando se envío la señal. La señal también contiene datos que permiten a
los receptores saber la localización de los satélites y para hacer otros ajustes necesarios para
una mejor localización. El receptor usa la diferencia en tiempo entre la recepción de la señal y
su envío para computar la distancia (o rango) entre el receptor y el satélite. El receptor debe
de tomar en cuenta los retrasos por propagación o el retardo de la señal causada por la
ionosfera y la troposfera. Con la información de los rangos de tres satélites y la información de
la posición de un satélite cuando la señal fue enviada el receptor puede computar su propia
posición tridimensional. Un reloj atómico sincronizado al GPS es necesario para poder
computar los rangos de las tres señales. Sin embargo, al tomar esta medida de tiempo de un
cuarto satélite, el receptor se evita la necesidad de un reloj atómico. Así que el receptor utiliza
cuatro satélites para computar latitud, longitud, altura y tiempo.
2 TRIANGULACIÓN
Para ubicar la posición exacta donde nos encontramos situados, el receptor GPS tiene que
localizar por lo menos 3 satélites que le sirvan de puntos de referencia. En realidad eso no
constituye ningún problema porque normalmente siempre hay 8 satélites dentro del ͞campo
visual͟ de cualquier receptor GPS. Para determinar el lugar exacto de la órbita donde deben
encontrarse los satélites en un momento dado, el receptor tiene en su memoria un almanaque
electrónico que contiene esos datos.
Tanto los receptores GPS de mano, como los instalados en vehículos con antena exterior fija,
necesitan abarcar el campo visual de los satélites. Generalmente esos dispositivos no
funcionan bajo techo ni debajo de las copas de los árboles, por lo que para que trabajen con
precisión hay que situarlos en el exterior, preferiblemente donde no existan obstáculos que
impidan la visibilidad y reduzcan su capacidad de captar las señales que envían a la Tierra los
satélites.
[pic]
Primero: cuando el receptor detecta el primer satélite se genera una esfera virtual o
imaginaria, cuyo centro es el propio satélite. El radio de la esfera, es decir, la distancia que
existe desde su centro hasta la superficie, será la misma que separa al satélite del receptor.
Éste último asume entonces que se encuentra situado en un punto cualquiera de la superficie
de la esfera, que aún no puede precisar.
[pic]
Segundo: al calcular la distancia hasta un segundo satélite, se genera otra esfera virtual. La
esfera anteriormente creada se superpone a esta otra y se crea un anillo imaginario que pasa
por los dos puntos donde se interceptan ambas esferas. En ese instanteya el receptor
reconoce que sólo se puede encontrar situado en uno de ellos.
[pic]
Tercero: el receptor calcula la distancia a un tercer satélite y se genera una tercera esfera
virtual. Esa esfera se corta con un extremo del anillo anteriormente creado en un punto en el
espacio y con el otro extremo en la superficie de la Tierra. El receptor discrimina como
ubicación el punto situado en el espacio utilizando sus recursos matemáticos de
posicionamiento y toma como posición correcta el punto situado en la Tierra.
[pic]
Quinto: para detectar también la altura a la que se encuentra situado el receptor GPS sobre el
nivel del mar, tendrá que medir adicionalmente la distancia que lo separa de un cuarto satélite
y generar otra esfera virtual que permitirá determinar esa medición.
Si por cualquier motivo el receptor falla y no realiza las mediciones de distancias hasta los
satélites de forma correcta, las esferas no se interceptan y en ese caso no podrá determinar, ni
la posición, ni la altura.
Desde el mismo momento que el receptor GPS detecta una señal de radiofrecuencia
transmitida por un satélite desde su órbita, se genera una esfera virtual o imaginaria que
envuelve al satélite. El propio satélite actuará como centro de la esfera cuya superficie se
extenderá hasta el punto o lugar donde se encuentre situada la antena del receptor; por tanto,
el radio de la esfera será igual a la distancia que separa al satélite del receptor. A partir de ese
instante el receptor GPS medirá las distancias que lo separan como mínimo de dos satélites
más. Para ello tendrá que calcular el tiempo que demora cada señal en viajar desde los
satélites hasta el punto donde éste se encuentra situado y realizar los correspondientes
cálculos matemáticos.
Todas las señales de radiofrecuencias están formadas por ondas electromagnéticas que se
desplazan por el espacio de forma concéntrica a partir de la antena transmisora, de forma
similar a como lo hacen las ondas que se generan en la superficie del agua cuando tiramos una
piedra. Debido a esa propiedad las señales de radio se pueden captar desde cualquier punto
situado alrededor de una antena transmisora. Las ondas de radio viajan a la velocidad de la luz,
es decir, 300 mil kilómetros por segundo (186 mil millas por segundo) medida en el vacío, por
lo que es posible calcular la distancia existente entre un transmisor y un receptor si se conoce
el tiempo que demora la señal en viajar desde un punto hasta el otro.
Para medir el momento a partir del cual el satélite emite la señal y el receptor GPS la recibe, es
necesario que tanto el reloj del satélite como el del receptor estén perfectamente
sincronizados. El satélite utiliza un reloj atómico de cesio, extremadamente exacto, pero el
receptor GPS posee uno normal de cuarzo, no tan preciso. Para sincronizar con exactitud el
reloj del receptor GPS, el satélite emite cada cierto tiempo una señal digital o patrón de
control junto con la señal de radiofrecuencia. Esa señal de control llega siempre al receptor
GPS con más retraso que la señal normal de radiofrecuencia. El retraso entre ambas señales
será igual al tiempo que demora la señal de radiofrecuencia en viajar del satélite al receptor
GPS.
La distancia existente entre cada satélite y el receptor GPS la calcula el propio receptor
realizando diferentes operaciones matemáticas. Para hacer este cálculo el receptor GPS
multiplica el tiempo de retraso de la señal de control por el valor de la velocidad de la luz. Si la
señal ha viajado en línea recta, sin que la haya afectado ninguna interferencia por el camino, el
resultado matemático será la distancia exacta que separa al receptor del satélite.
Las ondas de radio que recorren la Tierra lógicamente no viajan por el vacío sino que se
desplazan a través de la masa gaseosa que compone la atmósfera; por tanto, su velocidad no
será exactamente igual a la de la luz, sino un poco más lenta. Existen también otros factores
que pueden influir también algo en el desplazamiento de la señal, como son las condiciones
atmosféricas locales, el ángulo existente entre el satélite y el receptor GPS, etc. Para corregir
los efectos de todas esas variables, el receptor se sirve de complejos modelos matemáticos
que guarda en su memoria. Los resultados de los cálculos los complementa después con la
información adicional que recibe también del satélite, lo que permite mostrar la posición con
mayor exactitud.
Ya hemos visto cómo funciona el GPS y cuál es su función principal: conocer nuestra posición.
Aunque conocer nuestra posición pueda parecer algo trivial, cada vez más se está convirtiendo
en un aspecto casi imprescindible en muchos campos, ya sean profesionales o lúdicos. A
grandes rasgos, podemos dividir los campos de aplicación en cinco.
Topografía: gracias a la precisión del sistema, los topógrafos cuentan con una herramienta
muy útil para la determinación de puntos de referencia, accidentes geográficos o
infraestructuras, entre otros, lo que permite disponer de información topográfica precisa, sin
errores y fácilmente actualizable.
Sincronización: dada la característica adicional de medición del tiempo de que disponen los
receptores GPS, podemos emplear este sistema para determinar momentos en los que
suceden o sucederán determinados eventos, sincronizarlos, unificar horarios...
3 HUSOS HORARIOS
Geográficamente los husos horarios son cada una de las veinticuatro áreas en que se divide la
Tierra y que siguen la misma definición de tiempo cronométrico. Se llaman así porque tienen
forma de huso de hilar o de gajo de naranja y están centrados en meridianos de una longitud
que es múltiplo de 15°. Anteriormente, la gente usaba el tiempo solar aparente, con lo que la
hora se diferenciaba ligeramente de una ciudad a otra si no se encontraban sobre un mismo
meridiano. El empleo de los husos horarios corrigió el problema parcialmente, al sincronizar
los relojes de una región al mismo tiempo solar medio.
Actualmente la definición de huso horario se basa en las fronteras de países y regiones, y sus
límites pueden ser bastante irregulares. En este sentido a veces se usa la frase zona horaria.
[pic]
Todos los husos horarios se definen en relación al Tiempo Universal Coordinado (UTC), el huso
horario centrado sobre el meridiano de Greenwich que, por tanto, contiene a Londres.
Puesto que la Tierra gira de Oeste a Este, al pasar de un huso horario a otro en dirección Este
hay que sumar una hora. Por el contrario, al pasar de Este a Oeste hay que restar una hora. El
meridiano de 180°, conocido como línea internacional de cambio de fecha, marca el cambio de
día.
Los países indicados con (N) o (S) utilizan horario de verano (hora para aprovechar la luz solar):
agregan una hora en verano. Los indicados con (N) pertenecen al hemisferio norte y, por lo
tanto, esa hora la agregan en marzo o abril. Los indicados con (S) pertenecen al hemisferio sur,
y agregan una hora en octubre o noviembre. La lista de territorios se ordena de norte a sur.
Los Usos horarios de México son regulados por el Centro Nacional de Metrología, entidad
gubernamental dependiente de la Secretaría de Economía. Según lo establecido por esta
dependencia, a México le corresponden 3 husos horarios al oeste del meridiano de Greenwich
o Tiempo Universal Coordinado, por lo que sus horas se restan al de éste; estos usos horarios
son: UTC -8, UTC -7 y UTC -6.
Para su vigencia en México, estos husos horarios reciben nombres particulares, que son:
Los límites de cada uno de ellos son fijados siguiendo las fronteras físicas entre los estados o
en algunos casos entre municipios de un estado, por lo que en el estricto sentido no siguen el
límite exacto de los husos horarios.
A diferencia de otros países con igual o mayor cantidad de horarios, México no tiene una
cultura de diferenciación de ellos, debido en gran parte a la centralización de la vida nacional
en la Ciudad de México, a la que le corresponde, junto con más de la mitad del país, el Tiempo
del Centro, siendo por ejemplo que las cadenas nacionales de televisión solo contemplen el
horario del centro al anunciar sus programaciones. Entre otras razones esto conlleva a que
solo tengan verdadera constancia de las diferencias de horario quienes viven en los dos husos
diferentes al del centro, mientras que la gran mayoría de la población que habita este horario
no está consciente de la existencia de otros
[pic]
4 TIEMPO SIDERAL
El tiempo sidéreo, también denominado tiempo sideral, es el tiempo medido por el
movimiento diurno aparente del equinoccio vernal, que se aproxima, aunque sin ser idéntico,
al movimiento de las estrellas. Se diferencia en la presesión del equinoccio vernal con respecto
a las estrellas.
De forma más precisa, el tiempo sidéreo se define como el ángulo horario del equinoccio
vernal. Cuando el equinoccio vernal culmina en el meridiano local, el tiempo sidéreo local es
00.00.
[pic]
5 COMUNICACIÓN SERIAL.
1 DEFINICION.
La comunicación serial es un protocolo muy común para comunicación entre dispositivos que
se incluye de manera estándar en prácticamente cualquier computadora. La mayoría de las
computadoras incluyen dos puertos seriales RS-232. La comunicación serial es también un
protocolo común utilizado por varios dispositivos para instrumentación. Además, la
comunicación serial puede ser utilizada para adquisición de datos si se usa en conjunto con un
dispositivo remoto de muestreo.
Típicamente, la comunicación serial se utiliza para transmitir datos en formato ASCII. Para
realizar la comunicación se utilizan 3 líneas de transmisión: (1) Tierra (o referencia), (2)
Transmitir, (3) Recibir. Las características más importantes de la comunicación serial son la
velocidad de transmisión, los bits de datos, los bits de parada, y la paridad. Para que dos
puertos se puedan comunicar, es necesario que las características sean iguales.
[pic]
2 MODOS DE TRANSMISIÓN
1 TRANSMISIÓN SIMPLEX
La transmisión simplex (sx) o unidireccional es aquella que ocurre en una dirección solamente,
deshabilitando al receptor de responder al transmisor. Normalmente la transmisión simplex no
se utiliza donde se requiere interacción humano-máquina. Ejemplos de transmisión simplex
son: La radiodifusión (broadcast) de TV y radio, etc.
[pic]
2 TRANSMISIÓN HALF-DUPLEX
La transmisión half-duplex (hdx) permite transmitir en ambas direcciones; sin embargo, la
transmisión puede ocurrir solamente en una dirección a la vez. Tanto transmisor y receptor
comparten una sola frecuencia. Un ejemplo típico de half-duplex es el radio de banda civil (CB)
donde el operador puede transmitir o recibir, pero no puede realizar ambas funciones
simultáneamente por el mismo canal. Cuando el operador ha completado la transmisión, la
otra parte debe ser avisada que puede empezar a transmitir.
[pic]
3 TRANSMISIÓN FULL-DUPLEX
[pic]
3 COMUNICACIÓN ASINCRONA
Cuando se opera en modo asíncrono no existe una línea de reloj común que establezca la
duración de un bit y el carácter puede ser enviado en cualquier momento. Esto conlleva que
cada dispositivo tiene su propio reloj y que previamente se ha acordado que ambos
dispositivos transmitirán datos a la misma velocidad.
El tiempo por bit en una línea en que se transfiere la información a 2400 bps es de unos 416
microsegundos (1 seg/2400). Una frecuencia de muestreo de 2400 veces por segundo nos
permitirá muestrear el principio o el final del bit. En ambos casos detectaremos el bit, sin
embargo, no es extraño que la señal cambie ligeramente, y permanezca la línea con una
duración un poco más larga o más corta de lo normal. Por todo ello, una frecuencia de
muestreo lenta no sería capaz de detectar el cambio de estado de la señal a su debido tiempo,
y esto daría lugar a que la estación terminal no recibiera los bits correctamente.
[pic]
Durante el intervalo de tiempo en que no son transferidos caracteres, el canal debe poseer
un "1" lógico. Al bit de parada se le asigna también un "1". Al bit de inicio del carácter a
transmitir se le asigna un "0". Por todo lo anterior, un cambio de nivel de "1" a "0" lógico le
indicará al receptor que un nuevo carácter será transmitido.
[pic]
a) Cuando no se envían datos por la línea, ésta se mantiene en estado alto (1).
b) Cuando se desea transmitir un carácter, se envía primero un bit de inicio que pone la línea a
estado bajo (0) durante el tiempo de un bit.
c) Durante la transmisión, si la línea está a nivel bajo, se envía un 0 y si está a nivel alto se envía
un 1.
d) A continuación se envían todos los bits del mensaje a transmitir con los intervalos que
marca el reloj de transmisión. Por convenio se transmiten entre 5 y 8 bits.
e) Se envía primero el bit menos significativo, siendo el más significativo el último en enviarse.
f) A continuación del último bit del mensaje se envía el bit (o los bits) del final que hace que la
línea se ponga a 1 por lo menos durante el tiempo mínimo de un bit. Estos bits pueden ser un
bit de paridad para detectar errores y el bit o bits de stop, que indican el fin de la transmisión
de un carácter.
Los datos codificados por esta regla, pueden ser recibidos siguiendo los pasos siguientes:
d) Leer un bit más de la línea y comprobar si es 1 para confirmar que no ha habido error en la
sincronización.
4 VELOCIDAD DE TRANSMISIÓN
En la transmisión asíncrona por cada caracter se envía al menos 1 bit de inicio y 1 bit de parada
así como opcionalmente 1 bit de paridad. Esta es la razón de que los baudios no se
correspondan con el número de bits de datos que son transmitidos.
[pic]
Imagen 22.- Formato básico de Transmisión asíncrona
Ejemplo:
1 bit inicio + 6 bits datos + 1 bit paridad + 2 bits parada =10 bits.
[pic]
Imagen 23.- Transmisión asíncrona con velocidad menor que la máxima posible
En la siguiente figura se muestra la mayor velocidad asíncrona posible con el bit de paridad.
[pic]
5 TRANSMISIÓN SINCRONA
Es un método más eficiente de comunicación en cuanto a velocidad de transmisión. Ello viene
dado porque no existe ningún tipo de información adicional entre los caracteres a ser
transmitidos.
[pic]
Los carácteres de sincronismo deben diferenciarse de los datos del usuario para permitir al
receptor detectar los caracteres "sync". Por ejemplo, el código ASCII utiliza el octeto
10010110.
Existen ocasiones en que son definidos dos caracteres de sincronismo, ello puede ser
necesario si, por cualquier motivo el carácter "sync" original se desvirtuara, el siguiente
permitirá la reinicialización del receptor. En segundo lugar, puede ocurrir que el equipo
receptor necesite un tiempo adicional para adaptarse a la señal entrante.
[pic]
Cuando se escriben o se envían datos, pueden producirse errores, entre otras cosas, por ruidos
inducidos en las líneas de transmisión de datos. Es por tanto necesario comprobar la
integridad de los datos transmitidos mediante algún método que permita determina si se ha
producido un error.
Transmisión asíncrona:
© Paridad.
© Sobre escritura.
Transmisión síncrona:
© Paridad.
© Sobre escritura.
Como un error en una transmisión serie solamente suele afectar a un bit, uno de los métodos
más comunes para detectar errores es el control de la paridad.
El control de paridad consiste en añadir un bit, denominado de paridad, a los datos que se
envían o escriben.
[pic]
1 PARIDAD PAR
El bit de paridad será cero, cuando el número de bit "unos" que contienen los datos a
transmitir sea un número par, y el bit de paridad será uno cuando los datos que se mandan
contienen un número impar de unos.
[pic]
La suma de los bits que son unos, contando datos y bit de paridad dará siempre como
resultado un número par de unos.
[pic]
[pic]
2 PARIDAD IMPAR
[pic]
Tabla 3.- Paridad impar
En el sistema de paridad impar, el número de unos (datos + paridad) siempre debe ser impar.
Ejemplo:
C3H tiene un número par de unos, por lo que el bit de paridad a insertar debe ser 1 para que
se cumpla que el número de unos (datos + paridad) siempre debe ser impar:
[pic]
43H tiene un número impar de unos, por lo que el bit de paridad a insertar debe ser 0 para
que se cumpla que el número de unos (datos + paridad) siempre debe ser impar:
[pic]
[pic]
[pic]
Como fue definida paridad impar, se detecta el error pues debería haber un número impar de
unos y hay cuatro. Como respuesta a la detección el sistema podría solicitar la transmisión de
este carácter nuevamente.
3 METODO CHECKSUM
Puede existir el caso en que, por ejemplo, se alteren dos bits en un caracter transmitido y si se
ha implementado la comprobación de paridad, el error no será detectado.
Ejemplo:
Indicar el último caracter a transmitir cuando se implementa el método de checksum. Los
datos a transmitir serán 40H, 35H y 0EH.
Se realiza la suma:
0111 1100
+ 1
-------------
8 INTERFAZ RS232
RS-232 (también conocido como Electronic Industries Alliance RS-232C) es una interfaz que
designa una norma para el intercambio serie de datos binarios entre un DTE (Equipo terminal
de datos) y un DCE (Data Communication Equipment, Equipo de Comunicación de datos),
aunque existen otras situaciones en las que también se utiliza la interfaz RS-232.
En particular, existen ocasiones en que interesa conectar otro tipo de equipamientos, como
pueden ser computadores. Evidentemente, en el caso de interconexión entre los mismos, se
requerirá la conexión de un DTE (Data Terminal Equipment) con otro DTE.
El RS-232 consiste en un conector tipo DB-25 (de 25 pines), aunque es normal encontrar la
versión de 9 pines (DB-9), más barato e incluso más extendido para cierto tipo de periféricos
(como el ratón serie del PC).
[pic]
En la siguiente tabla se muestran las señales RS-232 más comunes según los pines asignados:
[pic]
1 CONSTRUCCION FISICA
La interfaz RS-232 está diseñada para distancias cortas, de unos 15 metros o menos, y para
velocidades de comunicación bajas, de no más de 20 [Kb/s]. A pesar de ello, muchas veces se
utiliza a mayores velocidades con un resultado aceptable. La interfaz puede trabajar en
comunicación asíncrona o síncrona y tipos de canal simplex, half duplex o full duplex. En un
canal simplex los datos siempre viajarán en una dirección, por ejemplo desde DCE a DTE. En un
canal half duplex, los datos pueden viajar en una u otra dirección, pero sólo durante un
determinado periodo de tiempo; luego la línea debe ser conmutada antes que los datos
puedan viajar en la otra dirección. En un canal full duplex, los datos pueden viajar en ambos
sentidos simultáneamente. Las líneas de handshaking de la RS-232 se usan para resolver los
problemas asociados con este modo de operación, tal como en qué dirección los datos deben
viajar en un instante determinado.
Si un dispositivo de los que están conectados a una interfaz RS-232 procesa los datos a una
velocidad menor de la que los recibe deben de conectarse las líneas handshaking que permiten
realizar un control de flujo tal que al dispositivo más lento le de tiempo de procesar la
información. Las líneas de "hand shaking" que permiten hacer este control de flujo son las
líneas RTS y CTS. Los diseñadores del estándar no concibieron estas líneas para que funcionen
de este modo, pero dada su utilidad en cada interfaz posterior se incluye este modo de uso.
La interfaz RS232 resuelve tres aspectos en la comunicación que se establece entre el DTE,
Equipo Terminal de Datos, por ejemplo un PC y el DCE, Equipo para la comunicación de datos,
por ejemplo un ratón:
Características eléctricas de la señal: Se establece que la longitud máxima entre el DTE y el DCE
no debe ser superior a los 15 metros y la velocidad máxima de transmisión es de 20.000 bps.
Los niveles lógicos no son compatibles TTL, considerando:
Descripción funcional de las señales usadas: Las señales están básicamente divididas en dos
grupos:
Señales primarias, que son normalmente utilizadas para las transferencias de datos
La interfaz RS232 está definida tanto para la transmisión síncrona como para la asíncrona, pero
cuando se utiliza esta última, sólo un conjunto de terminales (de los 25), es utilizado.
2 VELOCIDAD
© 75
© 110
© 150
© 300
© 600
© 1200
© 2400
© 4800
© 9600
© 19200
3 CONECTORES
[pic]
[pic]
Ambos conectores son totalmente compatibles entre sí y existen adaptadores para pasar de un
conector a otro
4 DESCRIPCION DE TERMINALES.
Para ilustrar mejor el significado de cada terminal, consideremos a modo de ejemplo que el
DTE podría ser un PC y el DCE un ratón. Se considerará el terminal DB25. Más adelante, en
RS232 en el PC se volverá al tema de los conectores.
[pic]
© RXD (Receive Data, recepción de datos, entrada, pat. 3): Señales de datos transmitidos
desde el DCE al DTE.
© DTR (Data Terminal Ready, terminal de datos preparado, salida, pat. 20): Señal del DTE que
indica que está conectado, generalmente en "0" indica que el DTE está listo para transmitir o
recibir.
© DSR (Data Set Ready, dispositivo preparado, entrada, pat. 6): Señal del DCE que indica que el
dispositivo está en modo de transmisión de datos.
© RTS (Request To Send, petición de envío, salida, pat. 4): Señal del DTE al DCE, notifica al DCE
que el DTE dispone de datos para enviar. Se emplea en líneas semiduplex para controlar la
dirección de transmisión. Una transición de 1 a 0 avisa al DCE que tome las medidas necesarias
para prepararse para la transmisión.
© CTS (Clear To Send, preparado para transmitir, entrada, pat. 5): Señal del DCE al DTE
indicando que puede transmitirle datos.
© CD (Carrier Detect, detección de portadora, entrada, pat. 8): Señal del DCE que ha detectado
la señal portadora enviado por un modem remoto o que la línea telefónica está abierta.
© RI (Ring Indicator, timbre o indicador de llamada entrante, entrada, pat. 22): Señal del DCE
indicando que está recibiendo una llamada por un canal conmutado.
© SG (GND) (System Ground ó Signal Ground, masa de señal, pat. 7): Masa común para todos
las líneas.
© FG (GND) (Shield ó Protective Ground, tierra de protección, pat. 1): El conductor esta
eléctricamente conectado al equipo.
© El DTE pregunta al DCE si este está listo. El DTE activa la línea RTS. El DCE si está listo,
responde activando la línea CTS. Puestos de acuerdo ambos equipos, se puede entrar a
comunicar.
© Los datos son transferidos en ambos sentidos. El DTE envía información al DCE a través del
terminal TXD. El DCE envía información al DTE a través del terminal RXD.
Debido a todo esto surge la necesidad de realizar un dispositivo llamado MASTER que se capaz
de sincronizarse con otros dispositivos llamados SLAVE para mantener en perfecta sincronía
las actividades de cada uno de los foros cuando se requiera.
1 VISUAL BASIC
Una de las herramientas que se empleo para el desarrollo del prototipo es la utilización de
visual Basic, que es uno de los tantos lenguajes de programación existentes hoy en día. Visual
Basic Es un lenguaje de programación que se ha diseñado para facilitar el desarrollo de
aplicaciones en un entorno grafico (GUI-GRAPHICAL USER INTERFACE) Como Windows 98,
Windows NT o superior.
[pic]
[pic]
Imagen 38.- Diagrama de flujo del funcionamiento del programa en Visual Basic
Al ejecutarse como primera acción que debe de hacer el programa, es extraer la hora actual de
la computadora en donde se esta instalado, una vez hecho esto el programa tiende a guardar
la hora adquirida en diferentes variables.
Se ocuparon tres diferentes variables para que en cada una se almacenaran los datos
obtenidos de la hora exacta de la computadora como lo son, horas, minutos y segundos, para
que después pueda desplegarse en la pantalla de la computadora la hora actual del sistema tal
y como se muestra en la siguiente imagen.
[pic]
Una vez hecho el despliegue en pantalla de la hora actual del sistema, el programa
internamente hace por código programado, la revisión de si es esta la primera vez, o no en que
se ejecuta el programa, esto se realiza con motivo de que si es la primera vez
automáticamente empiece la transmisión de los datos obtenidos por el protocolo de
comunicación RS232 (comunicación serial), los datos serán enviados en el orden de:
En el caso de que el programa detecte que no ha sido la primera vez en la que se esta
ejecutando, entonces internamente el programa esperara a que sean las 24:00:00 hrs para que
empiece la transmisión de los datos hacia el dispositivo electrónico de la manera en que
fueron enviados por primera vez: Horas ( minutos ( segundos. Esto se realiza con el motivo de
que si en el transcurso del día se llegara a perder un segundo por motivo de la lejanía entre
dispositivos, el programa pueda sincronizar cada 24 hrs, para que no se llegue a perder algún
segundo, puesto que es de vital importancia mantener todos los dispositivos en sincronía y con
los mismos horarios.
El envío de los datos se realiza por el puerto serial de la computadora, mediante un cable con
conectores usb-serial para que de esta manera pueda haber comunicación entre la PC y el
dispositivo electrónico Master.
[pic]
Una vez realizado la parte donde se obtiene principalmente la hora, es necesario realizar el
dispositivo electrónico que sea capaz de recibir los datos mandados por la computadora y que
a su vez pueda actuar como un dispositivo Master ante los demás dispositivos electrónicos.
Para poder realizar esta parte del prototipo es necesario la utilización de varios materiales que
en conjunto, podrán recibir la información enviada por la computadora y también podrá enviar
los datos hacia los demás dispositivos. A continuación se explican las fases que se necesito
para el desarrollo y ademas de los componentes utilizados para la elaboración.
El Max232 es muy útil para comunicar la computadora con un microcontrolador, debido a que
la computadora maneja voltajes de 8 a -8v, por lo que no se puede conectar directamente a un
microcontrolador que manejan voltajes TTL (5v), entonces de esta manera el Max232 actúa
como un conversor de voltaje para poder interactuar entre una computadora y un
microcontrolador.
[pic]
Imagen 41.- Esquema de funcionamiento del circuito Max232
Los valores de los capacitores utilizados en el circuito electrónico son de 100 nF.
En la siguiente imagen se muestra la manera en la que quedo montado sobre una placa el
circuito integrado Max232 junto con los capacitores de 100 nf y el conector RS232 hembra.
[pic]
Con esto queda resuelto la parte de la comunicación entre la computadora y el dispositivo que
recibirá la información.
1. MICROCONTROLADOR.
Ya se ha visto la forma del como se envían los datos desde la computadora y del como
debemos de tener un circuito externo a la computadora para lograr establecer una
comunicación con dicho circuito, después de haber realizado todo esto tenemos que tener un
circuito integrado capaz de almacenar y trabajar información y para esto utilizamos el
microcontrolador.
Un microcontrolador es un circuito integrado o chip que incluye en su interior las tres unidades
funcionales de una computadora: CPU, Memoria y Unidades de E/S, es decir, se trata de un
computador completo en un solo circuito integrado.
[pic]
[pic]
[pic]
Como primera acción del microcontrolador debe ajustar internamente los puertos de entrada
y salida, a si como los registros que utilizan para el Timer/Counter, una vez realizado esta
operación el microcontrolador espera a que algún dato sea recibido, que en este caso los
datos serian las horas, minutos y segundos enviados por la computadora, cuando el
microcontrolador adquiere la información ejecuta por comandos de código un reloj y lo
despliega en pantalla, cuando en algún momento del programa recibe el refresh (que en este
ocurre cuando son las 24:00:00 hrs y que sirve para que no exista algún desajuste de tiempos
entre la computadora y el dispositivo) manda inmediatamente la información que le es
enviada de la computadora hacia los otros dispositivos, para que así de este modo todos los
relojes Slave se mantengan en sincronía. Si no se recibe el refresh el reloj se sigue ejecutando
normalmente y puede que en unos días exista un desajuste de segundos.
Algo muy importante dentro del prototipo es la generacion de 1 seg exacto ya que si en esto
existira un desajuste de reloj entre la computadora y el dispositivo Master.
Para esto se debe de contar con un cristal de 4 Mhz y dos capacitores de 33 pf como los que se
muestran en la siguiente imagen:
[pic]
Una vez que tenemos este material debemos de conectar el cristal en paralelo con las entradas
de XTAL1 Y XTAL2 que se encuentran ubicadas en el microcontrolador, a si como tambien se
deben de poner los capasitores conectados del XTAL1 a GND y XTAL2 a GND respectivamente
tal y como se muestra en la siguiente imagen:
[pic]
Una vez realizado este circuito se le debe de informar al microcontrolador que deberá de
trabajar con un reloj externo para que así los procesos los haga conforme a la velocidad del
cristal externo.
A continuación se muestra una imagen del como queda conectado el cristal junto con los dos
capacitores en el prototipo.
[pic]
2. VISUALIZACION EN UN LCD.
El lcd (Liquid Crystal Display) es una de las herramientas utilizadas para la realización del
prototipo ya que en el se pueden mostrar, tanto números como letras y es de gran
importancia, por que en algún momento debemos saber las operaciones que estamos
realizando con nuestro prototipo.
[pic]
En esta parte del prototipo se tuvo que implementar la conexión del lcd hacia el
microcontrolador para poder desplegar la hora que es adquirida desde la computadora, una
vez hecha esta operación sera facil ver que los dos relojes, tanto el de la computadora como el
realizado por el microcontrolador mantengan las mismas horas, minutos y los segundos para
asi poder comprobar que existe una sincronía entre estos dos.
En la siguiente imagen se muestra la conexión del lcd hacia el microcontrolador para que se
pueda desplegar la hora.
[pic]
La siguiente imagen muestra el como quedo conectado el lcd con el microcontrolador para
poder utilizarlo en el prototipo, con esto solo basta con alimentar con 5 V el circuito armado y
tener un programa cargado en el microcontrolador para que se pueda desplegar algo en el lcd.
[pic]
Una vez terminado todo lo descrito anteriormente solo queda el poder comprobar que el
circuito electronico Master funciona correctamente junto con la computadora para asi poder
dar por finalizado la recepcion de datos en el dispositivo electrónico Master.
En la siguiente imagen muestra todo el proceso que se lleva hasta el momento del prototipo.
[pic]
En resumen de toda esta fase la interfaz de Visual Basic sirve para poder obtener la hora actual
del sistema de una computadora, para asi después poder mandarla por el puerto serial de la Pc
por el convertidor de cable usb-serial la información y por este medio poder conectar la
computadora con nuestro circuito que contiene al Max232 el cual sirve para poder hacer la
conversión de volatejes que viene de la Pc a voltajes TTL y asi lograr comunicarse con el
microcontrolador, que con la información obtenida lo que hace internamente es generar un
reloj que este sincronizado con el de la computadora, para que finalmente se pueda desplegar
la hora en el lcd.
Las siguientes imágenes muestran todo el circuito armado y conectado con la computadora.
[pic]
2 ENVIÓ DE DATOS.
Otras de las principales acciones que debe de realizar el dispositivo master es la de que una
vez que reciba la hora proporcionada por la computadora sea capaza de transmitirla hacia los
demás dispositivos electrónicos para poder mantener entre todos una sincronía.
El envío de los datos en el microcontrolador se hace mediante el pin TXD y que a su vez debe
de estar programado para poder hacer el envío de datos através de ese pin.
[pic]
Los dispositivos Slaves tienen un lugar importante dentro del prototipo, por que son los
dispositivos que serán colocados dentro de cada uno de los foros donde se requiera saber la
hora que posee el dispositivo master, la elaboración de los slaves consta de algunas partes las
cuales serán explicadas a continuación.
1 RECEPCION DE DATOS.
Como es una comunicación serial entre los dos dispositivos el Slave tiene que esperar a que el
dispositivo master le envie la hora para asi poder guardarla en una variable.
En el microcontrolador la recepción debe habilitarse para que en cualquier momento pueda
recibirse un dato, el cual será alojado en el registro UDR. [pic]
[pic]
Este modo implica un esquema maestro-esclavos. Cada esclavo tendrá una dirección que lo
distinga de los demás. Pueden ser hasta 256 esclavos.
O ( DATOS
1 ( DIRECCIÓN
© Todos los esclavos deben habilitar el modo de multiprocesadores (MPCM = 1). Con ello
pueden recibir campos de dirección.
© El maestro envía una dirección, la cual es recibida por todos los esclavos.
© Cada esclavo debe leer su registro UDR para determinar si ha sido seleccionado. El que
resulte seleccionado debe limpiar su bit MPCM en el registro UCSRA.
© Cuando se concluye el diálogo, el esclavo seleccionado debe poner en alto su bit MPCM,
quedando junto con el resto de los esclavos, en espera de que el maestro solicite su atención.
Una vez que la comunicación entre microcontroladores Master/Slave es realizada y la
recepcion del dato es adquirida por el Slave solo queda el visualizar la hora en un display de 7
segmentos que son los que se utilizaron en el desarrollo del prototipo.
[pic]
El display está formado por un conjunto de 7 leds conectados en un punto común en su salida.
Cuando la salida es común en los ánodos, el display es llamado de ánodo común y por el
contrario, sí la salida es común en los cátodos, llamamos al display de cátodo común. En la
figura se muestran ambos tipos de dispositivos. En el display de cátodo común, una señal alta
encenderá el segmento excitado por la señal. La alimentación de cierta combinación de leds,
dará una imagen visual de un dígito de 0 a 9.
[pic]
Para lograr que exista una comunicación entre el microcontrolador y los display de 7
segmentos en necesario contar con un decodificador de BCD a 7 segmentos el cual requiere
de una entrada en código decimal binario BCD y siete salidas conectadas a cada segmento del
display. En la siguiente figura se representa en un diagrama de bloques el decodificador de
BCD a 7 segmentos con un display de cátodo común.
[pic]
En este caso el visualizador es un display de cátodo común, se obtiene una tabla cuyas
entradas en código BCD corresponden a A, B, C y D y unas salidas correspondientes a los leds
que se encenderán en cada caso para indicar el dígito decimal.
[pic]
Con todo esto solo queda el montar todo el Dispositivo Slave completo, tal y como lo son el
microcontrolador para la recepción de los datos enviados por el Master, el Decodificador BCD
para lograr la comunicación entre los displays, y los displays de 7 segmentos que son los que al
final mostraran al usuario la hora actual.
[pic]
4.1 PRUEBAS
Uno de los principales problemas con lo que se contó dentro la realización del prototipo, fue
de compatibilidad entre Microsoft Windows Vista con el IDE Visual Basic, ya que Windows
Vista maneja diferentes tipos de drivers y controladores a los que contaba Windows XP y
debido a esto Visual Basic funciona correctamente bajo XP.
Para ese caso en el que se utilizo de sistema operativo Windows vista se tuvo que optimizar y
mover algunos parámetros para que se pudiera instalar el IDE Visual Basic, y así poder realizar
el programa que funciona en conjunto con el dispositivo Master para poder asignar las horas a
los demás Slave´s.
El primer paso para comprobar que funciona correctamente, fue en dejar en ejecución el
programa hecho en Visual Basic durante un aproximado de 5 horas y notar que el reloj no se
desajuste con respecto a la hora de la computadora.
Una vez realizada esta prueba se hizo un programa en el cual serviría para comprobar la
comunicación del RS232 de los puertos de la computadora para el envío de información hacia
el dispositivo electrónico Master.
[pic]
Los errores mas comunes que se tuvo en las pruebas de comunicación se encuentran los
siguientes:
[pic]
[pic]
Para el microcontrolador se tuvo que agregar un cristal de 4 Mhz en paralelo con dos
capacitores de 33 pf, para así poder obtener la precisión de un segundo, debido a que
primeramente se utilizo el reloj interno del microcontrolador, que el cual funcionaba
correctamente pero al cabo de cada 2 minutos de ejecución adquiría una perdida de 1 seg, y
con esto al cabo del termino del día significaría una gran diferencia con respecto a cualquier
reloj tanto de computadora como los de pared.
Una vez ajustado el dispositivo master con sus correspondientes valores, se probó el
dispositivo completo, para comprobar el funcionamiento durante un aproximado de 2 hrs,
donde el cual se obtuvo un correcto funcionamiento del dispositivo.
3 PRUEBA DE ENVIO DE DATOS ENTRE MICROCONTROLADORES.
Algo muy importante que se debe de comprobar antes de proseguir con todo prototipo, es el
de verificar el correcto funcionamiento de cada uno de los microcontroladores que se utilicen
dentro del prototipo.
Esto se hace realizando un programa para los microcontroladores, donde los dos integrados
envíen y reciban información por los pines RXD y TXD que son los que se utilizan para una
comunicación serial entre estos integrados.
Para la realización del programa que envie datos por medio del pin TXD se tiene que hacer lo
siguiente: