Permalink
Switch branches/tags
Nothing to show
Find file Copy path
Fetching contributors…
Cannot retrieve contributors at this time
executable file 1008 lines (797 sloc) 24.4 KB
{
Copyright (C) 2007 Julián Perelli y Maximiliano Padulo
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
Software written by Julian Perelli ages ago!
}
Program Proyecto_CT;
uses crt, dos;
const
cf = White; {color del fondo}
cl = Black; {color de la letra}
cfs = Blue ; {color del fondo seleccionado}
cls = Yellow; {color de la letra seleccionada}
CANT_TOTAL = 1000;{cantidad de sectores maxima}
var
nom: array[1..5] of string; {textos a imprimir de las opciones}
i: integer; {repeticion para manejar el array anterior}
opc: integer; {opcion seleccionada al momento}
a: char; {valor ASCII de la tecla presionada}
CANT_OPC: integer; {cantidad de opciones a desplegar}
SEC: array [0..CANT_TOTAL] of integer; {GLOBAL!! guarda los sectores a visitar}
C_SEC: integer; {GLOBAL!! guarda cuantos sectores se visitan}
{valores globales son como constantes que seran inicializados desde afuera}
VALOR_MAX: integer; {valor maximo de "simulacion" de sector}
DISCO, DIRRAM, SECTORES: String; {BORRAME}
BYTES_MAX: longint;
VER_DEBUG: boolean;
MAX_CILINDRO: integer;
{-----------------------------------
crea la secuencia manual
------------------------------------}
procedure Sec_man;
var
i:integer;
lee: integer;
begin
ClrScr;
WriteLn('Ingrese la cantidad de sectores que desea a ingresar');
WriteLn('(El maximo es ',CANT_TOTAL,'): ');
ReadLn(C_SEC);
while ( ( C_SEC > CANT_TOTAL ) or ( C_SEC < 1 ) )do
begin
WriteLn('ERROR de desborde, el numero debe estar en el rango [1,', CANT_TOTAL, ']');
Write('Ingrese nuevamente: ');
ReadLn(C_SEC);
end;
WriteLn;
WriteLn('Ingrese los numeros de bloque en forma secuencial');
WriteLn('(entre 1 y VALOR_MAX)');
for i := 1 to C_SEC do
begin
Write('Ingrese el ',i+1,'o numero de bloque (1-',VALOR_MAX,'): ');
ReadLn(Sec[i]);
while ( ( Sec[i] > VALOR_MAX ) or ( sec[i] < 1 ) )do
begin
Write('ERROR de desborde, ingrese nuevamente el ',i+1,'o numero de bloque (1-',VALOR_MAX,'): ');
ReadLn(Sec[i]);
end;
end;
WriteLn('Secuencia manual completada satisfactoriamente');
WriteLn; Write('Presione una tecla para volver al menu');
repeat until KeyPressed; ReadKey;
ClrScr;
end;
{-----------------------------------
crea la secuencia aleatoria
------------------------------------}
procedure Sec_ale;
var
i:integer;
begin
ClrScr;
Write('Ingrese la cantidad de sectores que desea generar');
WriteLn('(El maximo es ',CANT_TOTAL,'): ');
ReadLn(C_SEC);
while ( ( C_SEC > CANT_TOTAL ) or ( C_SEC < 1 ) )do
begin
WriteLn('ERROR de desborde, el numero debe estar en el rango [1,', CANT_TOTAL, ']');
Write('Ingrese nuevamente: ');
ReadLn(C_SEC);
end;
C_SEC := C_SEC-1;
WriteLn('Creando la secuencia aleatoria...');
for i:=0 to C_SEC do
SEC[i]:= Random(VALOR_MAX);
WriteLn('Secuencia aleatoria completada satisfactoriamente');
WriteLn; Write('Presione una tecla para volver al menu');
repeat until KeyPressed; ReadKey;
ClrScr;
end;
{-----------------------------------
muestra la secuencia en pantalla
------------------------------------}
procedure Ver_sec;
var
i:integer;
begin
ClrScr;
for i:=0 to C_SEC do
begin
Write(SEC[i],' ');
end;
WriteLn; Write('Presione una tecla para volver al menu');
repeat until KeyPressed; ReadKey;
ClrScr;
end;
{-----------------------------------
Submenu secuencia de bloques
------------------------------------}
procedure Secuencia;
var
nom: array[1..4] of string; {textos a imprimir de las opciones}
i: integer; {repeticion para manejar el array anterior}
opc: integer; {opcion seleccionada al momento}
a: char; {valor ASCII de la tecla presionada}
CANT_OPC: integer;
begin
ClrScr;
{INICIO SUBMENU SECUENCIA --------------------------------------------------}
CANT_OPC := 4; {cantidad de opciones a desplegar}
{opcion y color predeterminados y se les dan los nombres a las opciones}
opc := 1;
nom[1] := 'Ver secuencia a ejecutar';
nom[2] := 'Crear secuencia manualmente';
nom[3] := 'Crear secuencia aleatoria';
nom[4] := 'Volver al Menu Principal';
{MENU -->> bucle que espera teclas a ser presionadas para hacer algo}
a := chr(0);
while (a <> chr(27)) do {mientras tecla sea distinta de Escape}
begin
{se fija que tecla fue presionada}
case ord(a) of
{arriba}
80: if opc<CANT_OPC then opc:=opc+1 else opc:= 1;
{abajo}
72: if opc>1 then opc:=opc-1 else opc:= CANT_OPC;
{se fija en que opcion esta cuando se presiona enter y llama al proc}
13: case opc of
1: begin Ver_Sec end;
2: begin Sec_Man end;
3: begin Sec_Ale end;
4: begin ClrScr; exit; end;
end;
end;
{imprime todo el menu}
for i := 1 to CANT_OPC do
begin
{elige la opcion que debe marcarse con un distinto color de background}
if i=opc then
begin
TextColor(cls);
TextBackground(cfs);
end
else
begin
TextColor(cl);
TextBackground(cf);
end;
{posiciona e imprime las opciones en su lugar}
GotoXY(28,9+i);
write(nom[i]);
end;
{imprime el nombre del programa y eso arriba de la pantalla}
TextBackground(cfs);
TextColor(cls);
GotoXY(1,1); Write(' SECUENCIA DE BLOQUES ');
{imprime la ayuda de teclas al pie de la pantalla}
TextColor(cl);
TextBackground(cf);
GotoXY(2,24);
write(' presione abajo y arriba para moverse sobre el menu y enter para ejecutar ');
{espera a presionar una tecla}
a:=readkey;
end;
ClrScr;
{FIN SUBMENU SECUENCIA --------------------------------------------------}
end;
{////////////////////////////////////
funciones para la conversion
/////////////////////////////////////}
function IntToStr(num: integer): string ;
begin
case num of
0: IntToStr :='0';
1: IntToStr :='1';
2: IntToStr :='2';
3: IntToStr :='3';
4: IntToStr :='4';
5: IntToStr :='5';
6: IntToStr :='6';
7: IntToStr :='7';
8: IntToStr :='8';
9: IntToStr :='9';
10: IntToStr :='A';
11: IntToStr :='B';
12: IntToStr :='C';
13: IntToStr :='D';
14: IntToStr :='E';
15: IntToStr :='F';
end;
end;
function hex(num: longint): string;
begin
if (num div 16 < 16) then
hex := IntToStr(num div 16) + IntToStr(num mod 16)
else
hex:= hex(num div 16) + IntToStr(num mod 16);
end;
function StrToInt(S: String): Longint;
function CharToInt(C:Char): integer;
begin
case C of
'0': CharToInt := 0;
'1': CharToInt := 1;
'2': CharToInt := 2;
'3': CharToInt := 3;
'4': CharToInt := 4;
'5': CharToInt := 5;
'6': CharToInt := 6;
'7': CharToInt := 7;
'8': CharToInt := 8;
'9': CharToInt := 9;
end;
end;
function pot(base, exp: integer): longint;
var i:integer;
aux:longint;
begin
aux := 1;
for i := 0 to exp-1 do
begin
aux := aux * base;
end;
pot := aux;
end;
var i:integer;
aux:longint;
begin
aux:=0;
i:=1;
while i<=Length(S) do
begin
aux := aux + (pot(10,(Length(S)-i)))*CharToInt(S[i]);
inc(i);
end;
StrToInt := aux;
end;
function StrToBool(S: string): boolean;
begin
for i := 1 to Length(S) do
S[i] := UpCase(S[i]);
if S = 'TRUE' then StrToBool := true
else StrToBool := false;
end;
{--------------------------------------------------------------
*** ESTA ES LA PARTE MAS GROSA (LLAMADA A INTERRUPCION 13h) ***
--------------------------------------------------------------}
procedure SimulateSeekToCylinder2(Pos: word);
var
Reg: Registers;
Cilindro: Word;
Temp: Byte;
begin
{Saco el numero de cilindro por regla de tres}
Cilindro := Round( pos * MAX_CILINDRO / VALOR_MAX );
{ meto el numero de cilindro en los registros}
Reg.CX := Cilindro;
Temp:=Reg.CL;
Reg.CX:=(Reg.CX SHR 8) SHL 6; {Roto 8 para dejarlos en 0 al resto
dejando solo los 2 bits LSB del CH en
los 2 bits MSB del CL}
Reg.CH:=Temp;
Reg.AH := $0C; { $0C Numero de Servicio de la interrupcion$13: Seek to Cylinder}
Reg.DH := $01; {head number}
Reg.DL := $80; {drive number ($80:first/$81:second)}
Intr($13, Reg); {llamada}
if ( VER_DEBUG ) and ( ( Reg.Flags and $01 ) = $01 ) then
begin
WriteLn('Seek cilindro: [',Cilindro, '] POS LOGICA [',pos,'] La interrupcion fallo, volcando registros...');
WriteLn('AX =0x ', hex(Reg.AX));
WriteLn('BX =0x ', hex(Reg.BX));
WriteLn('CX =0x ', hex(Reg.CX));
WriteLn('DX =0x ', hex(Reg.DX));
WriteLn('BP =0x ', hex(Reg.BP));
WriteLn('SI =0x ', hex(Reg.SI));
WriteLn('DI =0x ', hex(Reg.DI));
WriteLn('DS =0x ', hex(Reg.DS));
WriteLn('ES =0x ', hex(Reg.ES));
WriteLn('FLAGS =0x ', hex(Reg.Flags));
WriteLn('Presione una tecla para continuar...');
WriteLn;
ReadKey;
end
else
WriteLn('Movimiento cilindro: [', Pos, '] exitoso');
WriteLn;
delay (700);
end;
procedure SimulateSeekToCylinder(pos: integer);
begin
end;
procedure ejecutarFIFO;
begin
ClrScr;
WriteLn('Comenzando la Ejecucion: Algoritmo FIFO');
WriteLn('---------------------------------------');
WriteLn(' Presione una tecla para continuar ',CANT_TOTAL);
ReadKey;
for i:=0 to C_SEC do
SimulateSeekToCylinder(SEC[i]);
WriteLn;
WriteLn('Fin de la Ejecucion: Algoritmo FIFO');
WriteLn('Presione una tecla para continuar ');
ReadKey;
ClrScr;
end;
Procedure ejecutarSSTF(cant:integer);
var
Vect: array[0..1000] of integer;
i, j, min, pos, bucle: integer;
begin
ClrScr;
WriteLn('Comenzando la Ejecucion: Algoritmo SSTF');
WriteLn('---------------------------------------');
WriteLn(' Presione una tecla para continuar ',CANT_TOTAL);
WriteLN(C_SEC);
ReadKey;
for i:=0 to 3 do
Vect[i]:=SEC[i];
SimulateSeekToCylinder(Vect[0]);
{
j:=0;
min:=VALOR_MAX;
pos:=1;
for bucle:=1 to C_SEC do
begin
for i:=1 to C_SEC do
begin
if ( (Vect[i] <> -1) and (i<>j) ) then
if abs(Vect[j]-Vect[i]) < min then
begin
min := abs(Vect[j]-Vect[i]);
pos := i;
end;
end;
Vect[j]:=-1; pone en -1 las ya visitadas
j:=pos;
SimulateSeekToCylinder(Vect[j]);
min := VALOR_MAX;
end;
}
ejecutarFIFO;
WriteLn;
WriteLn('Fin de la Ejecucion: Algoritmo SSTF');
WriteLn('Presione una tecla para continuar ');
end;
Procedure ejecutarSCAN;
var
V: array[0..CANT_TOTAL-1] of longint;
i, j, min, pos, bucle, aux: longint;
begin
ClrScr;
WriteLn('Comenzando la Ejecucion: Algoritmo SCAN');
WriteLn('---------------------------------------');
WriteLn(' Presione una tecla para continuar ');
ReadKey;
for i:=0 to CANT_TOTAL do
V[i]:=SEC[i];
SimulateSeekToCylinder(V[0]);
{ordeno}
for i:=1 to C_SEC do
begin
for j:=i to C_SEC do
begin
if V[j]<V[i] then
begin
aux:=V[j];
V[j]:=V[i];
V[i]:=aux;
end;
end;
end;
{busco la pos}
i:=1;
while V[i]<V[0] do
i:=i+1;
pos:=i;
{recorro pa'tras hasta el principio y despues pa'delante}
if pos <> 1 then
for i:=pos-1 downto 1 do
SimulateSeekToCylinder(V[i]);
SimulateSeekToCylinder(0);
for i:=pos to C_SEC do
SimulateSeekToCylinder(V[i]);
WriteLn;
WriteLn('Fin de la Ejecucion: Algoritmo SCAN');
WriteLn('Presione una tecla para continuar ');
ReadKey;
ClrScr;
end;
Procedure ejecutarCSCAN;
var
V: array[0..CANT_TOTAL-1] of longint;
i, j, min, pos, bucle, aux: longint;
begin
ClrScr;
WriteLn('Comenzando la Ejecucion: Algoritmo CSCAN');
WriteLn('----------------------------------------');
WriteLn(' Presione una tecla para continuar ');
ReadKey;
for i:=0 to CANT_TOTAL do
V[i]:=SEC[i];
SimulateSeekToCylinder(V[0]);
{ordeno}
for i:=1 to C_SEC do
begin
for j:=i to C_SEC do
begin
if V[j]<V[i] then
begin
aux:=V[j];
V[j]:=V[i];
V[i]:=aux;
end;
end;
end;
{busco la pos}
i:=1;
while V[i]<V[0] do
i:=i+1;
pos:=i;
{recorro pa'tras hasta el principio y despues pa'delante}
if pos <> 1 then
for i:=pos-1 downto 1 do
SimulateSeekToCylinder(V[i]);
SimulateSeekToCylinder(0);
for i:=C_SEC downto pos do
SimulateSeekToCylinder(V[i]);
WriteLn;
WriteLn('Fin de la Ejecucion: Algoritmo CSCAN');
WriteLn('Presione una tecla para continuar ');
ReadKey;
ClrScr;
end;
Procedure ejecutarLOOK;
var
V: array[0..CANT_TOTAL-1] of longint;
i, j, min, pos, bucle, aux: longint;
begin
ClrScr;
WriteLn('Comenzando la Ejecucion: Algoritmo LOOK');
WriteLn('---------------------------------------');
WriteLn(' Presione una tecla para continuar ');
ReadKey;
for i:=0 to CANT_TOTAL do
V[i]:=SEC[i];
SimulateSeekToCylinder(V[0]);
{ordeno}
for i:=1 to C_SEC do
begin
for j:=i to C_SEC do
begin
if V[j]<V[i] then
begin
aux:=V[j];
V[j]:=V[i];
V[i]:=aux;
end;
end;
end;
{busco la pos}
i:=1;
while V[i]<V[0] do
i:=i+1;
pos:=i;
{recorro pa'tras hasta el principio y despues pa'delante}
if pos <> 1 then
for i:=pos-1 downto 1 do
SimulateSeekToCylinder(V[i]);
for i:=pos to C_SEC do
SimulateSeekToCylinder(V[i]);
WriteLn;
WriteLn('Fin de la Ejecucion: Algoritmo LOOK');
WriteLn('Presione una tecla para continuar ');
ReadKey;
ClrScr;
end;
Procedure ejecutarCLOOK;
var
V: array[0..CANT_TOTAL-1] of longint;
i, j, min, pos, bucle, aux: longint;
begin
ClrScr;
WriteLn('Comenzando la Ejecucion: Algoritmo CLOOK');
WriteLn('----------------------------------------');
WriteLn(' Presione una tecla para continuar ');
ReadKey;
for i:=0 to CANT_TOTAL do
V[i]:=SEC[i];
SimulateSeekToCylinder(V[0]);
{ordeno}
for i:=1 to C_SEC do
begin
for j:=i to C_SEC do
begin
if V[j]<V[i] then
begin
aux:=V[j];
V[j]:=V[i];
V[i]:=aux;
end;
end;
end;
{busco la pos}
i:=1;
while V[i]<V[0] do
i:=i+1;
pos:=i;
{recorro pa'tras hasta el principio y despues pa'delante}
if pos <> 1 then
for i:=pos-1 downto 1 do
SimulateSeekToCylinder(V[i]);
for i:=C_SEC downto pos do
SimulateSeekToCylinder(V[i]);
WriteLn;
WriteLn('Fin de la Ejecucion: Algoritmo CLOOK');
WriteLn('Presione una tecla para continuar ');
ReadKey;
ClrScr;
end;
procedure Simular;
var
i, j, pos, bucle :integer;
min, aux: longint;
V: array[0..CANT_TOTAL-1] of longint;
nom: array[1..7] of string; {textos a imprimir de las opciones}
opc: integer; {opcion seleccionada al momento}
a: char; {valor ASCII de la tecla presionada}
CANT_OPC: integer;
begin
{ REGLA DE TRES SIMPLE
la utilizamos para hacer que los valores simulados en la secuencia
de "sectores virtuales" tomen valores que hagan que el brazo
se mueva por el disco entero, si no, el movimiento no se apreciaria
bytes_max ------------------------ VALOR_MAX
x (num de sector real) -------------- sec[i]
}
{ MENU DE EJECUCION DE ALGORITMOS ------------------------------------ }
ClrScr;
CANT_OPC := 7; {cantidad de opciones a desplegar}
{opcion y color predeterminados y se les dan los nombres a las opciones}
opc := 1;
nom[1] := 'Ejecutar Algoritmo FIFO';
nom[2] := 'Ejecutar Algoritmo SSTF';
nom[3] := 'Ejecutar Algoritmo SCAN';
nom[4] := 'Ejecutar Algoritmo C-SCAN';
nom[5] := 'Ejecutar Algoritmo LOOK';
nom[6] := 'Ejecutar Algoritmo C-LOOK';
nom[7] := 'Volver al Menu Principal';
{MENU -->> bucle que espera teclas a ser presionadas para hacer algo}
a := chr(0);
while (a <> chr(27)) do {mientras tecla sea distinta de Escape}
begin
{se fija que tecla fue presionada}
case ord(a) of
{arriba}
80: if opc<CANT_OPC then opc:=opc+1 else opc:= 1;
{abajo}
72: if opc>1 then opc:=opc-1 else opc:= CANT_OPC;
{se fija en que opcion esta cuando se presiona enter y llama al proc}
13: case opc of
1: EjecutarFIFO;
2: EjecutarSSTF(C_SEC);
3: EjecutarSCAN;
4: EjecutarCSCAN;
5: EjecutarLOOK;
6: EjecutarCLOOK;
7: begin ClrScr; exit; end;
end;
end;
{imprime todo el menu}
for i := 1 to CANT_OPC do
begin
{elige la opcion que debe marcarse con un distinto color de background}
if i=opc then
begin
TextColor(cls);
TextBackground(cfs);
end
else
begin
TextColor(cl);
TextBackground(cf);
end;
{posiciona e imprime las opciones en su lugar}
GotoXY(28,9+i);
write(nom[i]);
end;
{imprime el nombre del programa y eso arriba de la pantalla}
TextBackground(cfs);
TextColor(cls);
GotoXY(1,1); Write(' MENU DE EJECUCION DE ALGORITMOS ');
{imprime la ayuda de teclas al pie de la pantalla}
TextColor(cl);
TextBackground(cf);
GotoXY(2,24);
write(' presione abajo y arriba para moverse sobre el menu y enter para ejecutar ');
{espera a presionar una tecla}
a:=readkey;
end;
ClrScr;
{FIN MENU DE EJECUCION DE ALGORITMOS-----------------------------------}
end;
{ -------------------------
AYUDA
-------------------------}
procedure Ayuda;
begin
TextBackground(cf);
ClrScr;
TextColor(cls);
TextBackground(cfs);
Write(' Ingenieria en Sistemas de Informacion ');
Write(' Universidad Tecnologica Nacional ');
Write(' Facultad Regional La Plata ');
Write(' PROYECTO CT ');
WriteLn('');
TextColor(cl);
TextBackground(cf);
WriteLn(' Cr‚ditos:');
WriteLn(' - Trabajo en Hardware: Maximiliano Padulo (maxi.padulo@gmail.com)');
WriteLn('');
WriteLn(' - Trabajo en Software: Julian Perelli (julianperelli@hotmail.com)');
WriteLn('');
WriteLn('');
WriteLn(' úúúúúúúúúúúúúúúúúúúúúúúADVERTENCIA!úúúúúúúúúúúúúúúúúúúúúúú');
WriteLn(' este programa puede causarle da¤os a su computadora');
WriteLn(' no nos responsabilizamos por la ocurrencia de los mismos');
WriteLn('');
WriteLn(' El programa simula los algoritmos de busqueda en un disco rigido');
WriteLn(' que fue construido para poder observar los movimientos');
WriteLn(' del brazo del mismo');
WriteLn('');
WriteLn(' Este software es gratuito. El feedback es el mejor agradecimiento.');
WriteLn(' Cualquier consulta (o queja), no dude en comunicarse via mail');
WriteLn('');
WriteLn; Write('Presione una tecla para volver al menu');
repeat until KeyPressed; ReadKey;
ClrScr;
end;
procedure Configurar;
var
Resp: char;
begin
ClrScr;
Write('Ingrese el numero maximo de sectores simulados: ');
ReadLn(VALOR_MAX);
WriteLn;
WriteLn('Desea ver los codigos de depuracion (S/N): ');
ReadLn(Resp);
if UpCase(Resp) = 'S'
then VER_DEBUG := True
else VER_DEBUG := False;
WriteLn;
WriteLn('Valores seteados, presione una tecla para volver al menu');
ReadKey;
ClrScr;
end;
{---------------------------------------
PROCEDIMIENTO
ARRANQUE
---------------------------------------}
function CantCilindros: word;
var
Registro: Registers; Temp:Byte;
begin
WriteLn;
Registro.AH := $08;
Registro.DL := $80; {drive number}
WriteLn('Determinando tama¤o maximo de cilindros...');
Intr($13, Registro);
Temp:=Registro.CH;
Registro.CH:=Registro.CL SHR 6;
Registro.CL:=Temp;
if VER_DEBUG then
begin
if ( Registro.Flags and $01 = $01 ) then
WriteLn('Error en Interrupcion 0x13 Subrutina 0x08')
else
begin
WriteLn('Tama¤o maximo de cilindros detectado');
Writeln('[',Registro.CX, '] cilindros en total');
end;
readkey;
end;
CantCilindros := Registro.CX;
end;
{---------------------------------------
PROCEDIMIENTO
ARRANQUE
---------------------------------------}
procedure init;
var
linea, vari, valor: string;
begin
ClrScr;
WriteLn('Inicializando...');
Randomize;
C_SEC := 0;
TextMode(CO80); {modo de 25 lineas}
{-------------------PARA ARCHIVO CONFIGURACION----------------------}
begin
WriteLn('Archivo de Configuraciones NO encontrado: cargando valores predeterminados');
VALOR_MAX := 200;
VER_DEBUG := true;
WriteLn; Write('Presione una tecla para continuar');
repeat until KeyPressed; ReadKey;
ClrScr;
end;
{-----------------------------FIN ARCHIVO CONFIG----------------------}
MAX_CILINDRO := CantCilindros;
end;
{***********************************************************************
PRINCIPAL
************************************************************************}
begin
init;
Ayuda;
{INICIO MENU PRINCIPAL --------------------------------------------------}
CANT_OPC:= 5; {cantidad de opciones a desplegar}
TextBackground(cf);
{opcion y color predeterminados y se les dan los nombres a las opciones}
opc := 1;
nom[1] := 'Iniciar Simulacion de disco';
nom[2] := 'Secuencia de bloques';
nom[3] := 'Configuracion';
nom[4] := 'Ayuda';
nom[5] := 'Salir';
{MENU -->> bucle que espera teclas a ser presionadas para hacer algo}
a := chr(0);
while (a <> chr(27)) do {mientras tecla sea distinta de Escape}
begin
{se fija que tecla fue presionada}
case ord(a) of
{arriba}
80: if opc<CANT_OPC then opc:=opc+1 else opc:= 1;
{abajo}
72: if opc>1 then opc:=opc-1 else opc:= CANT_OPC;
{se fija en que opcion esta cuando se presiona enter y llama al proc}
13: case opc of
1: begin Simular end;
2: begin Secuencia end;
3: begin Configurar end;
4: begin Ayuda end;
5: exit;
end;
end;
{imprime todo el menu}
for i := 1 to CANT_OPC do
begin
{elige la opcion que debe marcarse con un distinto color de background}
if i=opc then
begin
TextColor(cls);
TextBackground(cfs);
end
else
begin
TextColor(cl);
TextBackground(cf);
end;
{posiciona e imprime las opciones en su lugar}
GotoXY(28,9+i);
write(nom[i]);
end;
{imprime el nombre del programa y eso arriba de la pantalla}
TextBackground(cfs);
TextColor(cls);
GotoXY(1,1); Write('Proyecto CT UTN / FRLP por Maxi Padulo y Julian Perelli');
{imprime la ayuda de teclas al pie de la pantalla}
TextColor(cl);
TextBackground(cf);
GotoXY(2,24);
write(' presione abajo y arriba para moverse sobre el menu y enter para ejecutar ');
{espera a presionar una tecla}
a:=readkey;
end;
{FIN MENU PRINCIPAL ------------------------------------------------------}
end.