////////////////////////////////////////////////////////////////////// // SOLUCIÓN INFORMÁTICA: // // -- CUYA VERSIÓN ES: // // -- DEL AUTOR: // // -- A FECHA: <21/07/2010> // // TIENE COMO LICENCIA: // // -- CUYA VERSIÓN ES: // // -- DEL AUTOR: // // -- A FECHA: <01/05/2010> // ////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// // - Versión completa de la licencia en: // http://kernel.tuentidad.es/licencia ////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// // EXTRACTO DE LA LICENCIA: // La "Licencia de Soluciones Informáticas eWa" (en adelante "LSeWa" o "LSW") es una licencia de software (en adelante, "Soluciones Informáticas") de código abierto robusta fuerte. // La "LSW" persigue garantizar la libertad como usuario y desarrollador de Soluciones Informáticas para compartir y modificar todas las versiones de la Solución Informática con la que se distribuya, asegurando que permanecerá como software libre para todos sus usuarios y desarrolladores potenciales. Todo el mundo puede distribuir sus Soluciones Informáticas originales con esta licencia, con la única condición de mantener, a partir de su inclusión, una versión compatible de la Licencia que incluya originalmente la Solución Informática. // Por ejemplo, si distribuye copias sin modificación de una Solución Informática, debe transmitir a los destinatarios exactamente lo mismo que recibió: el código fuente y la licencia (con ella los derechos y obligaciones) que usted recibió. Debe asegurarse que se recibe el código fuente, y se debe asegurar que estos términos y condiciones permanezcan sin alterar y unidos a ese código fuente. // Los desarrolladores que usan la LSW protegen de dos formas los derechos que, como desarrollador potencial de la Solución Informática con la que se distribuya, tienen: imponen derechos y obligaciones a la Solución Informática, y le ofrecen la posibilidad de copiar, distribuir y/o modificar manteniendo una versión válida de la LSW, y de esta forma, mantener los derechos y obligaciones que impone esta Licencia. // Para proteger a desarrolladores, usuarios y particularmente a sus autores, la LSW expone que, para beneficio de todos, las versiones modificadas y publicadas deberán estar identificadas como tales con su número de versión, o el nombre de la Solución Informática globalmente, para que cualquier problema no sea atribuido por error a los autores de versiones anteriores. De forma independiente, es obligatorio que la versión (o versiones) de la(s) que parte la modificación, aparezca(n). Para este control se pueden utilizar Soluciones Informáticas destinadas a llevar el control de versiones, aunque, en cualquier caso, estos datos tienen que ser fácilmente accesibles por cualquier usuario. ////////////////////////////////////////////////////////////////////// ////////////////////////////////// // COMETIDO: // ////////////////////////////////// // Esta Solución Informática está destinada a: // -- Ordenación de los almacenes de datos a revisar. // -- Localización de éstos almacenes de datos en el Sistema Informático. // -- Verificación de la disponibilidad de los almacenes de datos por iteración. // -- Comunicación del primer paquete del cada almacén de datos disponible. // --- Comprobación del primer paquete. // --- Desempaquetado del resto de paquetes si procede o revisión del siguiente almacén de datos. // -- Cesión del control al Sistema Operativo desempaquetado. ////////////////////////////////// // CÓDIGO FUENTE: // ////////////////////////////////// //////////////////// // cabecera #compilador ewa; // para que el compilador sea el eWa #lenguaje ewamblador; // para que se generen las estructuras del eWamblador #inicio 0x100; // para que comience desde la posición "0x100" // Los parámetros del GAE están en la dirección 0x00.FE.FF y ocupan 255 bits (hasta la 0x00.FF.FF) // se trata de los cuatro bits que distinguen los diferentes controladores. // -- Los controladores básicos están ubicados en 0x01.0?.00 siendo ? una cifra hexadecimal (cuatro bits) // Si se lee de cuatro en cuatro los parámetros, se tendrá la lista de dispositivos a leer. //////////////////// // estructuras #haz punteroParametrosGAE:WIT; // creamos una estructura WIT (puntero en memoria) #haz punteroControlador:WIT; // creamos una estructura WIT (puntero en memoria) #haz paquetesTiene:WIT; // creamos una estructura WIT (puntero en memoria) // -- guardará el número de paquetes a desempaquetar #haz mensaje:MENSAJE64; // creamos una estructura MENSAJE64 #haz paquete:PAQUETE56; // creamos una estructura PAQUETE56 #haz v0:BIT; // creamos una estructura BIT (bit en memoria) #haz v1:BIT; // creamos una estructura BIT (bit en memoria) #haz v2:BIT; // creamos una estructura BIT (bit en memoria) #haz v3:BIT; // creamos una estructura BIT (bit en memoria) //////////////////// // apuntado punteroParametrosGAE = 64x00FE00; // apuntamos a la dirección de inicio de la zona de parámetros punteroControlador = 64x010000; // apuntamos a la dirección de inicio del primer CUW //////////////////// // lectura iterativa de los parámetros while(){ // repetir siempre v0 = punteroParametrosGAE.dame(); // asignamos a "v" el valor que apunta el puntero a parámetrosGAE punteroParametrosGAE++; // incrementamos en una posición el puntero a parámetrosGAE v1 = punteroParametrosGAE.dame(); // asignamos a "v" el valor que apunta el puntero a parámetrosGAE punteroParametrosGAE++; // incrementamos en una posición el puntero a parámetrosGAE v2 = punteroParametrosGAE.dame(); // asignamos a "v" el valor que apunta el puntero a parámetrosGAE punteroParametrosGAE++; // incrementamos en una posición el puntero a parámetrosGAE v3 = punteroParametrosGAE.dame(); // asignamos a "v" el valor que apunta el puntero a parámetrosGAE punteroParametrosGAE++; // incrementamos en una posición el puntero a parámetrosGAE if( v0 == 0b0 && v1 == 0b0 && v3 == 0b0 && v4 == 0b0 ){ // ver si no se trata de v1 == v2 == v3 == v4 == 0 // en cuyo caso hay que finalizar la iteración parametrizada // -- esta cifra hexadecimal es la "0x0", que correspondería al CUW del VIDEO. // -- obviamente, este componente no tiene características para poder arrancar un SO. v0 = 0b0; v2 = 0b0; v3 = 0b1; v4 = 0b0; // DISCO DURO localizador(); v0 = 0b1; v2 = 0b0; v3 = 0b1; v4 = 0b0; // DISCO ÓPTICO localizador(); v0 = 0b0; v2 = 0b1; v3 = 0b1; v4 = 0b0; // DISCO SOLIDO localizador(); v0 = 0b0; v2 = 0b1; v3 = 0b1; v4 = 0b0; // DISCO FLEXIBLE localizador(); v0 = 0b0; v2 = 0b1; v3 = 0b0; v4 = 0b0; // RED (1) localizador(); v0 = 0b1; v2 = 0b1; v3 = 0b0; v4 = 0b0; // RED (2) localizador(); return false; // esto es igual que el "break", para salir del "while" } if( v0 == 0b1 && v1 == 0b0 && v3 == 0b0 && v4 == 0b0 ){ // ver si no se trata de v1 == 1 y v2 == v3 == v4 == 0 // en cuyo caso hay que finalizar el Arranque // -- esta cifra hexadecimal es la "0x1", que correspondería al CUW del SONIDO. // -- obviamente, este componente no tiene características para poder arrancar un SO. return false; // salimos del "while" } // En cualquier otro caso, vamos a localizar ese CUW localizador(); // return true; // esto es igual que el "continue", para comenzar de nuevo el "while" , pero no es necesario } //////////////////// // Finalizar pitando v0 = 0b1; // ponemos el valor 1 en el bit v0 punteroControlador = 64xFE; // lo apuntamos a la posición del Altavoz del Sistema punteroControlador.pon(v0); // asignamos el valor de v0 (1) al bit del Altavoz para que se suene punteroControlador = 64xFC; // lo apuntamos a la posición del Gestor del Sistema Eléctrico ("Apagado") while(){ punteroControlador.pon(v0); // asignamos el valor de v0 (1) al bit "Apagado" para que se apague el Sistema // el apagado se hace dentro de un bucle while para evitar que siga ejecutando código arbitrario } #crea # #VOID localizador(){ //////////////////// // Localización // En el puntero punteroControlador está apuntado el primer dispositivo de la zona de CUW punteroControlador[3b001][0] = v0; // asignamos el valor de "v0" a la componente 0 de la página 1 del puntero punteroControlador[3b001][1] = v1; // asignamos el valor de "v1" a la componente 1 de la página 1 del puntero punteroControlador[3b001][2] = v2; // asignamos el valor de "v2" a la componente 2 de la página 1 del puntero punteroControlador[3b001][3] = v3; // asignamos el valor de "v3" a la componente 3 de la página 1 del puntero // Ahora tenemos apuntado por punteroControlador el E0 del dispositivo deseado //////////////////// // Verificación punteroControlador[3b000][6] = 0b1; // asignamos el valor 1 a la componente 6 de la página 0 del puntero // -- los bits centrales en los CUW64 que se usan para arrancar los SO // -- están en la posición 0x01.0?.40; siendo 0x40 = 0b0100.0000 v1 = punteroControlador.dame(); // leemos el contenido del bit central. if( v1 == 0b1 ){ // si está encendido... punteroControlador[3b000][6] = 0b0; // volvemos a poner el valor 0 a // la componente 6 de la página 0 del puntero //////////////////// // Comunicación mensaje = 0xXXXXXXXXXXXXXXXXXX; // creamos el mensaje de solicitud del paquete 0 ponMensaje(punteroControlador, mensaje); // lo ponemos en el CUW // Esperamos a que lo responda paquete = recogePaquete(); // recogemos el paquete //////////////////// // Comprobación if( paquete == 0xAAAAAAAAAAAAAA ){ //////////////////// // Desempaquetado mensaje = 0xXXXXXXXXXXXXXXXXXX; // ponemos el mensaje de solicitud del paquete siguiente // se calcula el número de paquetes que hay que desempaquetar paquetesTiene = 64x0; // ponemos el número de paquetes a desempaquetar a 0 while(){ // se calcula el número de paquetes que hay que desempaquetar: // -- total de "1" desde el paquete 1 hasta un "0" ponMensaje(punteroControlador, mensaje); paquete = recogePaquete(); if( paquete == 0xFFFFFFFFFFFFFF ){ paquetesTiene += 56; return true; // "continue;" } return false; // "break;" } paquete.primero(); //hace que se apunte al primer bit del paquete (como un iterador) while(){ v0 = paquete.dame(); // pone en v0 el valor del bit apuntado del paquete paquete.avanza(); // y lo avanza una posición if( v0 == 0b0 ){ // si el bit es "0" se deja de contar return false; } // si no, se incrementa un paquete más a desempaquetar y se repite paquetesTiene++; return true; } // se van desempaquetando los paquetes a partir del actual while(){ // se repite hasta que no queden paquetes por desempaquetar if( paquetesTiene != 64x0 ){ ponMensaje(punteroControlador, mensaje); // se solicita el paquete siguiente al último pedido paquete = recogePaquete(); // se recoge el paquete solicitado copiaPaquete( punteroParametrosGAE, paquete); // se copia el paquete a memoria paquetesTiene--; // se decrementa en un paquete el número de paquetes a desempaquetar return true; } return false; } //////////////////// // Cesión punteroParametrosGAE = 64x1000000; // apuntamos el puntero a la posición de inicio del tercer sector PCa( punteroParametrosGAE ); // cedemos el flujo de ejecución al Sistema desempaquetado } } // si no, finaliza la función } #crea # #VOID recogePaquete(){ punteroControlador[3b000][6] = 0b1; // asignamos el valor 1 a la componente 6 de la página 0 del puntero punteroControlador[3b000][7] = 0b1; // asignamos el valor 1 a la componente 6 de la página 0 del puntero // -- el bit L0 en los CUW64 que se usan para arrancar los SO // -- está en la posición 0x01.0?.82; siendo 0x82 = 0b1000.0010 while(){ // recuperar el valor del bit L0 en v1 v1 = punteroControlador.dame(); if( v1 == 0b0 ){ // mientras sea igual a 0 return true; } return false; } // Una vez que el L0 se ponga a 1 paquete = sacaPaqueteL0( punteroControlador ); // Y volvemos a poner el puntero apuntando al L0 del CUW punteroControlador[3b000][6] = 0b0; // asignamos el valor 0 a la componente 6 de la página 0 del puntero punteroControlador[3b000][7] = 0b0; // asignamos el valor 0 a la componente 7 de la página 0 del puntero } ////////////////////////////////// // OBSERVACIONES: // ////////////////////////////////// ////////////////////////////////// // FIN // //////////////////////////////////