Manejo del dispositivo de entrada en gráficos por computadora

Un dispositivo a través del cual un usuario puede dar datos, información o señales de control a una computadora se conoce como dispositivo de entrada . Una unidad central de procesamiento (CPU) de computadora acepta y procesa datos para generar la salida. Por ejemplo, un lápiz óptico , un teclado, etc. son ejemplos de dispositivos de entrada controlados por eventos.

Manejo de dispositivos controlados por eventos: el manejo de dispositivos controlados por eventos se puede realizar de dos maneras :

1. Comience ingresando a un ciclo de sondeo , que verifica el estado del dispositivo hasta que se señala un evento. Cuando ocurre un evento, se sale del ciclo con los resultados del evento. En los lenguajes de alto nivel , la lectura de una entrada de terminal se maneja con frecuencia de esta manera. Un inconveniente de esta técnica es que la CPU suele estar inactiva mientras espera que suceda algo.
2. Permitir interrupciones, que son transmitidas por el dispositivo cuando ocurre un evento, es otra opción. Al usar el mecanismo de interrupción, el procesador es libre de realizar otras operaciones mientras espera que ocurra un evento.

Algoritmos de manejo de dispositivos de entrada: el sistema sirve como interfaz entre los programas de usuario dependientes del dispositivo y el dispositivo disponible. El interior de los procedimientos de la interfaz variará según el dispositivo, mientras que el exterior que ven los usuarios permanecerá constante. Esto es fantástico para los usuarios, pero es un desafío para nosotros porque simplemente no podemos proporcionar un algoritmo.
Considere los diversos tipos de procedimientos que se pueden usar para manejar dispositivos de entrada. Consideremos las clases de dispositivos.

1. Botón
   : cuando se presiona, un botón es un dispositivo controlado por eventos que envía una interrupción. Solo transmite el hecho de que ha sido presionado como información.
2. Pick-
    Se tipifica con pluma. Es un dispositivo controlado por eventos que selecciona una parte de la pantalla.
3. Teclado-
   Para la simulación de teclado, la forma interna de las rutinas es posteriormente alterada de la del caso general. Esto se debe a los 2 factores. Primero, la entrada del teclado a través del lenguaje de alto nivel parece estar muestreada, en lugar del mecanismo controlado por eventos.
4. Localizador
   : un localizador es un dispositivo muestreado que devuelve las coordenadas de alguna posición.
5. Valuador
   : un valuador es un dispositivo muestreado y muy similar al localizador, pero solo devuelve un valor. Puede ser una perilla doble o que puede ser configurada por el usuario.

Supongamos que cada dispositivo tiene los medios para habilitarlo o deshabilitarlo y simplificaremos este procedimiento al generar un indicador para cada clase, en lugar de habilitar y deshabilitar dispositivos individuales. Las banderas (activadas o desactivadas) definen si una clase específica está habilitada o no. Para facilitar la especificación de las clases, asígneles nombres numéricos.

1. Rutina para habilitar la clase Button:

BEGIN
    If Class = 1 Then
    BEGIN
        // Perform all the operations needed to permit 
        // input from the button devices
        Button <-- True
    END;
    If Class = 2 Then
    BEGIN
        // Perform all the operations needed to permit 
        // input from the pick devices
        Pick <-- True
    END;
    If Class = 3 Then
    BEGIN
        // Perform all the operations needed to permit 
        // input from the keyboard
        Keyboard <-- True
    END;
    If Class = 4 Then
    BEGIN
        // Perform all the operations needed to permit 
        // input from the Loactor devices
        Loactor <-- True
    END;
    If Class = 5 Then
    BEGIN
        // Perform all the operations needed to permit 
        // input from the valuator devices
        Valuator <-- True
    END;
    AND so on
    .
    .
    .
    RETURN;
END;

2. Rutina para deshabilitar la clase Botón:

BEGIN
    If Class = 1 Then
    BEGIN
        // Perform all the operations needed to prohibit 
        // input from the button devices
        Button <-- False
    END;
    If Class = 2 Then
    BEGIN
        // Perform all the operations needed to prohibit 
        // input from the pick devices
        Pick <-- False
    END;
    If Class = 3 Then
    BEGIN
        // Perform all the operations needed to prohibit 
        // input from the keyboard
        Keyboard <-- False
    END;
    If Class = 4 Then
    BEGIN
        // Perform all the operations needed to prohibit 
        // input from the Loactor devices
        Loactor <-- False
    END;
    If Class = 5 Then
    BEGIN
        // Perform all the operations needed to prohibit 
        // input from the valuator devices
        Valuator <-- False
    END;
    And so on
    .
    .
    .
    RETURN;
END;

Para deshabilitar la rutina, se toma un número de clase como entrada y se realizan las operaciones necesarias para apagar lógicamente esta clase de dispositivo y cambiar el indicador de dispositivo adecuado a falso. De manera similar, la rutina de habilitación toma un número de clase, ejecuta las operaciones requeridas para encender los dispositivos de forma lógica y establece el indicador de dispositivo relevante en verdadero.

3. Rutina para deshabilitar todos los Dispositivos de Entrada:

BEGIN
    For Class = 1 to 5
        Do disable button(Class); 
        // calling routine 2 Above
    RETURN;
END;

Para el manejo de eventos: un dispositivo controlado por eventos genera una interrupción . El procesador detiene su trabajo actual cada vez que ocurre una interrupción. El procesador ejecuta la rutina de servicio de interrupción para el dispositivo que generó la interrupción. Después de reparar el dispositivo, el procesador reanuda su trabajo anterior.

Aquí, suponga una sola cola de eventos, pero puede haber varias colas. El significado de proporcionar un servicio (por CPU) es identificar el dispositivo que causa la interrupción y obtener datos de entrada de él. Después de obtener esta información, se almacena en la cola de eventos.
La cola funciona de una manera de primero en entrar, primero en salir . Cada elemento de la cola representa una acción de usuario o un evento. En la cola, la inserción se realiza en la parte trasera y la eliminación se realiza en la parte delantera.

1. Algoritmo para procesar la interrupción del dispositivo de entrada:

BEGIN
    Disable Physical Interrupt;
    Save Status Of CPU ;
    Identify Interrupt Causing Device;
    If the device is logically enabled, Then
    BEGIN
        If event from a string Input Devivce, Then
            BEGIN
                Get the input string;
                // Add string to the queue, Described in 
                // the next algorithm
                ADD_STRING_Q(STRING, DATA);
            END
        Else
            BEGIN 
                Get the data from the device;
                // Add string to the queue, Described in 
                // the next algorithm
                ADD_EVENT_Q(CLASS, NUMBER, DATA);
            END
    END
    Restore the status of processor;
    Renable the physical Interrupt;
    RETURN
END

2. Algoritmo para agregar eventos a la cola:
este algoritmo utiliza la función-

ADD_EVENT_Q(CLASS, NUMBER, DATA)

BEGIN
    If Qrear = Qsize, Then
        Qrear <- 1
    Else
        Qrear <- Qrear + 1;
    If Qfront = Qrear, Then
        Return error - " Event Queue - overflow"
    // Add class of the input device to the event 
    // queue class array at rear position
    EVENT_QC[Qrear] <- Class;
    // Add the number of the input device to the 
    // event queue number array at rear position
    EVENT_QN[Qrear] <- Number;
    // Add data from the input device to the event 
    // queue data array at rear position
    EVENT_QD[Qrear] <- Data;
    If QFront <- 0, Then
        QFront <- 1;
    RETURN ;
END;

En la cola de strings, cada string nueva se agrega a la array de strings. Al llegar al final de la array, vuelva a la posición frontal. Se utiliza la siguiente función:

ADD_STRING_Q(STRING, DATA)

BEGIN
    If SQrear = SQsize, Then
        SQrear <- 1
    Else
        SQrear <- SQrear + 1
    // Add String from the input device to the 
    // String queue data array at rear position
    STRING_Q[SQrear] <- String;
    Data <- SQrear
    RETURN;
END;

Si no ocurre ningún evento o no se genera ninguna interrupción y las colas permanecen vacías.