Por Eugene Mortimore

El periférico Console del Amiga siempre está trabajando para usted. Desde el momento en el que se arranca, este coopera automáticamente con el AmigaDOS, Intuition y otros periféricos para asegurar una correcta lectura y escritura de datos. Su mecanismo de lectura automática del teclado y escritura en la ventana se realiza a través de un set interno de reglas de comunicación. La asociación entre la ventana Intuition y el console-device es controlado mediante cadenas específicas que contienen códigos del estándar ANSI 3.64. Para controlar la asociación entre la ventana y el console-device desde el lenguaje C, deberá aprender primero como introducir dichas cadenas de control en este lenguaje.

Después de relacionar una ventana Intuition con el console-device (mire el programa siguiente), usted podrá controlar el texto mostrado en su ventana con una cadena de secuencia de bytes de control mediante el console-Device. Las rutinas internas del console-device están escritas para reconocer dichas cadenas, con las cuales su programa puede enviar y recibir datos al mismo tiempo.

Escribiendo

Para escribir, cada secuencia completa consite en un set de subsecuencias de bytes de control. Cada una de estas se encuentra precedida de un byte de control 'introductorio'. La secuencia completa finaliza con un byte 'nulo' (0x00). El ya usual libro de ayuda para Amiga 'ROM Kernel Reference Manual: Libraries and Devices' presenta un sumario con estas cadenas de control, intentando clarificar estas descripciones mediante unos cuantos ejemplos.

De hecho el manual le informa de que para desplazar la posición superior de la ventana la secuencia es:

   9B <offset> 79

Ahora, ¿cómo puede usted trasladar esta secuencia de control dentro de un programa escrito en C?. Podrá hacerlo enviando cadenas a la console-device en la forma de una serie de caracteres hexadecimales. Estas cadenas de control siempre comienzan con el byte introductorio 0x9B y puede contener uno o más bytes de control específicos que informarán al console-device de cual es el comando que se va a interpretar. Entre estos dos usted puede incluir bytes específicos de control de comandos. Asegúrese de que su cadena termine con el byte nulo 0x00. Por ejemplo para que el cursor de textos se ponga en off (invisible), deberá declarar y enviar la siguiente cadena formada por cinco bytes en hexadecimal (terminada con el byte nulo):

   {0x9B, 0x30, 0x20, 0x70, 0x00}

Esta cadena contiene tres bytes de control insertados entre el primero y el nulo, sin contener bytes de información. Advierte que cada carácter hexadecimal se encuentra precedido por el descriptor hexadecimal '0x0. Cada separación de coma significa que cada Byte es un código de control distinto para la consola, la última se trata del byte nulo.

Esta cadena, sin embargo, define precisamente cinco bytes que son enviados a la consola. Mediante la rutina interna de la consola, el primer byte (la secuencia introductoria de control) es 0x9B. Este informa a la consola que todos los bytes siguientes, hasta el próximo 0x9B, constituye una cadena de control. El byte nulo informa a la consola del final de la cadena de control.

Si usted posteriormente quiere volver el cursor visible, deberá enviar la siguiente cadena formada por cuatro bytes, acabando con el byte nulo:

   {0x9B, 0x20, 0x70, 0x00}

Esta cadena contiene dos bytes de control entre el byte introductorio y el byte nulo, pero de nuevo se incluyen dos bytes de código de control.

Para posicionar una ventana de texto que comience en la línea 55 de raster, envíe la siguiente cadena acabando con el byte nulo a la consola:

   {0x9B, 0x35, 0x35, 0x79, 0x00}

Advierta que cada 0x35 es el código hexadecimal del número decimal 5. (Mientras en esta cadena se informa sobre el posicionado de la ventana en la línea raster 55, usted puede cambiarla a la línea que desee). Como en las otras, esta cadena contiene dos comandos específicos (cada uno de los 0x35), así como otro comando de control (0x79) siguiendo al byte introductorio 0x9B.

Ahora, para complicar las dos acciones anteriores con una única cadena, envíe el siguiente mensaje:

   {0x9B, 0x35, 0x35, 0x7B, 0x9B, 0x20, 0x70, 0x00}

Observe que en esta cadena se encuentran dos código 0x9B, cada uno introduciendo una secuencia de control; de nuevo la cadena acaba con un byte nulo, para informar a la consola de cual es el final del mensaje.

Para realizar la operación de situar el cursor en el comienzo de la ventana, así como borrar la misma, envíe el siguiente mensaje:

   {0x9B, 0x48, 0x9B, 0x4A, 0x00}

Por último para que la console-device informe a su programa sobre dónde se encuentra posicionado el cursor, envíe la siguiente secuencia:

   {0x9B, 0x6E, 0x00}

Lectura de caracteres

La consola también crea y envía una cadena continua de bytes que mezclan todos los códigos de entrada con todos los bytes que controlan el manejo de la ventana. Su programa puede leer continuamente estos bytes en orden para reconocer cada una de las subsecuencias. Por ejemplo la cadena de escritura de la posición del cursor puede ser especialmente útil si está desarrollando un procesador de textos que localice continuamente la posición del cursor. Usted puede enviar esta cadena a la consola y chequear posteriormente la posición del cursor.

Sin embargo su programa necesita saber la posición del cursor para escribir, para ello debe enviar una cadena que contenga el código de control para posicionar el cursor en una columna y fila específica. Por ejemplo la cadena:

   {0x9B, 0x34, 0x30, 0x3B, 0x31, 0x32, 0x52}

Indica que el cursor se encuentra posicionado en la columna 40 (0x34, 0x30) y en la fila 12 (0x31, 0x32). El 0x3B representa el carácter ';', el cual se utiliza como separador de información.

Advierta de nuevo que cada dígito se encuentra representado por un valor en hexadecimal, reconociendo la consola de esta forma la información contenida en la cadena.

Escritura automática

Para ilustrar alguna de estas ideas, el listado 1 muestra un pequeño programa que lee los caracteres recibidos de la consola, escribiéndolos en una ventana aparte. Estudie este programa para comprender cómo funcionan los mecanismos de lectura y escritura de la consola, así de cómo definir los mismos para su correcto funcionamiento.

L I S T A D O 1. #include <exec/types.h> #include <exec/memori.h> #include <intuition/intuition.h> #include <stdio.h> char*ReadWord[] = {"a","b","c","d","e","f","g","h","i","j"}; char*SubWord[]={"address","byte","character","device","error","flag","gadget","handle","input","jack"}; char *WriteSting; char consolePrep[]={0x9B,0x35,0x35,0x79,0x9B,0x30,0x20,0x70,0x00}; struct IntuitionBase *IntuitionBase; struct Window *window1, *window2; struct MsgPort *msgPort1, *msgPort2; struct IOStdReq *readRequesterWindow1,*WdriteRequesterWindow1, *WriteRequesterWindow2; struct NewWindow newWindow1 = {10,10,200,100,0,1,CLOSEWINDOW,ACTIVATE,NULL,NULL,(UBYTE*)"Window1",NULL,5,5,-1,-1,WBENCHSCREEN}; struct NewWindow newWindow2 = {230,10,200,100,0,1,CLOSEWINDOW,NULL,NULL,NULL,(UBYTE*)"Window1",NULL,NULL,5,5,-1,1,WBWNCHSCREEN}; /* ************************************************************************************************** */ main() { char ConsoleRead(); void ConsoleWrite(); int i,j,openWindow2; IntuitionBase =(Struct IntuitionBase *) OpenLibrary("intuition.library",33L); Window1 = (struct Window *) OpenWindow(&newWindow1;); Window2 = (struct window *) OpenWindow(&newWindow2;); msgPort1=(struct MsgPort *) CreatePort("Window 1 console Device Message Port",0L); mggPort2=(struct MgsPort *) CreatePort("Window 2 console Device Message Port",0L); readRequesterWindow1=(struct IOStdReq *) CreateStdIO(msgPort1); writeRequesterWindow1=(struct IOStdReq *) CreateStdIO(msgPort1); writeRequesterWindow2=(struct IOStdReq *) CreateStdIO(msgPort2); readRequesterWindow1->io_Data = (APTR) window1; readRequesterWindow1->io_Length = (LONG) sizeof(*window1); openWindow1=OpenDevice("console.device",0L.ReadRequesterWindow1,0L); WriteRequesterWindow1->io_Device=ReadRequesterWindow1->io_Device; WriteRequesterWindow1->io_Unit=ReadRequesterWindow1->io_Unit; WriteRequesterWIndow2->io_Data=(APTR) window2; WriteRequesterWindow2->io_Length=(LONG) sizeof(*window2); openWindow2=OpenDevice("console.device",0L,writeRequesterWindow2,0L); ConsoleWrite(WriteRequesterWindow1,consolePrep); CosnoleWrite(WriteRequesterWindow2,consolePrep); writeString[1]='\0'; for(i=0;i<10;i++) { writeString[0]=ConsoleRead(readRequesterWindow1); consoleWrite(writeRequesterwindow1,writeString); for(j=0;j<10;j++) { if(strcmp(writestring,readWord[j]==0) { Consolewrite(writeRequesterWindow2," "); ConsoleWrite(writeRequesterWindow2,subWord[j]); } } } CloseWindow(Window1); CloseWindow(WIndow2); exit (0); } /* ************************************************************************************************** */ char ConsoleRead(ioStdReq) struct IOStdReq *ioStdReq; { char readChar; ioStdReq->io_Data = &readChar; ioStdReq->io_Length = 1; ioStdReq->io_Command=CMD_READ; (void) DoIO(ioStdReq); return readChar; } /* ************************************************************************************************** */ void ConsoleWrite (ioStdReaq, string) struct IOStdReq *ioStdReq; char *string; { ioStdReq->io_Data = (APTR) string; ioStdReq->io_Length = -1L; (void) DoIO(ioStdReq); }