home *** CD-ROM | disk | FTP | other *** search
/ Programmer 7500 / MAX_PROGRAMMERS.iso / PROGRAMS / UTILS / HAMRADIO / EABURN.ZIP / EABURN.PAS < prev   
Encoding:
Pascal/Delphi Source File  |  1988-08-29  |  31.4 KB  |  973 lines
  1. {*****************************************************************************}
  2. {                                                                             }
  3. {           Copywrite 1988 by PETER MELLO.                                    }
  4. {                                                                             }
  5. {           For more Information you may contact                              }
  6. {                                                                             }
  7. {           Peter Mello                                                       }
  8. {           Unisys Corp                                                       }
  9. {           2 Enterprize Dr.                                                  }
  10. {           Shelton, Conn 06484                                               }
  11. {                                                                             }
  12. {           or   'PETER MELLO'                                                }
  13. {                 on the Circuit Cellar Bulletin Board. (203) 871-1988        }
  14. {                                                                             }
  15. {                                                                             }
  16. {*****************************************************************************}
  17.  
  18. Program EEPROM_UTILITES;
  19. uses crt;
  20.  
  21.      {$UNDEF  DEBUG_CONVERT_TO_INT}     {  FOR THOSE PESKY PROBLEMS,  }
  22.      {$UNDEF  DEBUG_CONVERT_TO_HEX}
  23.      {$UNDEF  DEBUG_PROCESS_JEDEC}      {  MOST PROCEDURES HAVE DEBUG }
  24.      {$UNDEF  DEBUG_COMPARE_JEDEC}
  25.  
  26.      {$UNDEF  DEBUG_PPI_WRITE}          {  CODE BUILT IN.             }
  27.      {$UNDEF  DEBUG_PPI_ADDR_READ}
  28.      {$UNDEF  DEBUG_SET_ADDR}
  29.      {$UNDEF  DEBUG_READ_BUSY}
  30.      {$UNDEF  DEBUG_READ_EAROM_ADDR}
  31.  
  32.      {$UNDEF  DEBUG_NOT_BURNING}        { not a procedure             }
  33.      {$UNDEF  NO_ERROR_ABORT}           { not a procedure             }
  34.  
  35. CONST
  36.  
  37.      MAX_ROM_SIZE   = 2047;
  38.  
  39.      PRT_PORT1_DATA = $278;         { ADDRESSES OF THE PC PORTS }
  40.      PRT_PORT1_CNTL = $27A;         { FOR PRINTER PORT 1.       }
  41.      PRT_PORT1_STAT = $279;
  42.  
  43.      PRT_PORT2_DATA = $378;         { ADDRESSES OF THE PC PORTS }
  44.      PRT_PORT2_CNTL = $37A;         { FOR PRINTER PORT 2.       }
  45.      PRT_PORT2_STAT = $379;
  46.  
  47.                                     {*************************************}
  48.    PRT_PORT_DATA = PRT_PORT2_DATA;  {*   Change here to define printer   *}
  49.    PRT_PORT_CNTL = PRT_PORT2_CNTL;  {*   port 1 or 2.                    *}
  50.    PRT_PORT_STAT = PRT_PORT2_STAT;  {*************************************}
  51.  
  52. (*****************************************************************************)
  53. (*  Do not confuse the interface between the PC -> 8255 with the ports       *)
  54. (*  of the 8255. Entire program deals with writing to the 'PPI_PORTS',       *)
  55. (*  THIS IS THE INPUT/OUTPUT REGISTERS OF THE 8255. Getting data into and    *)
  56. (*  out of the 8255 is done transparently to the user/abuser by use of the   *)
  57. (*  'PPI_WRITE' and 'PPI_READ' procedures.                                   *)
  58. (*****************************************************************************)
  59.  
  60.           DATA_PORT = 'A';          { Here we define what the output ports }
  61.           ADDR_PORT = 'B';          { of the 8255 PPI will be used for.    }
  62.           CNTL_PORT = 'C';
  63.           MODE_PORT = 'D';
  64.  
  65.           BUSY_LINE = 128;          { Here we further define what the bit    }
  66.          WRITE_LINE =  64;          { assignment of port C (the control port)}
  67.           READ_LINE =  32;          { are to be used for.                    }
  68.         CHIP_ENABLE =  16; {N.C.}
  69.        NORMAL_STATE =  00;          { WRITE_LINE + READ_LINE;                }
  70.                                     { Lines are normally in the high or off  }
  71.                                     { state, which is +5v.                   }
  72.  
  73.       WRITE_BIT_ON  = 13;           { send these numbers to the 8255 mode    }
  74.       WRITE_BIT_OFF = 12;           { register to set the control lines to   }
  75.        READ_BIT_ON  = 11;           { the EAROM on and off. ON is the active }
  76.        READ_BIT_OFF = 10;           { state, which is low, 0v.               }
  77.  
  78. TYPE       STRING79    =  STRING[79];
  79.  
  80. VAR        INPUT_FILE_PARAM : STRING79;
  81.  
  82. PROCEDURE ERROR ( ERR_MSG :STRING79 );
  83. BEGIN
  84. WRITELN (ERR_MSG);
  85. {$IFDEF NO_ERROR_ABORT}
  86.  { -don't halt- }
  87. {$ELSE}
  88.  HALT
  89. {$ENDIF}
  90. END {PROCEDURE_ERROR};
  91.  
  92. PROCEDURE  PPI_WRITE (PORT_TYPE:CHAR; DATA:INTEGER);
  93. VAR PORT_ADDR : INTEGER;
  94. BEGIN
  95.   CASE PORT_TYPE OF                                       { 1 bit inverted   }
  96.   DATA_PORT : PORT_ADDR:=08;     { Bit 0 off, Bit 1 off  }{ 4=0 bit, 8=1 bit }
  97.   ADDR_PORT : PORT_ADDR:=12;     { Bit 0 on,  Bit 1 off  }
  98.   CNTL_PORT : PORT_ADDR:=00;     { Bit 0 off, Bit 1 on   }
  99.   MODE_PORT : PORT_ADDR:=04;     { Bit 0 on,  Bit 1 on   }{ control register }
  100.   ELSE  WRITELN('INVALID PORT ADDR');
  101.   END{CASE};
  102.  
  103.   PORT [PRT_PORT_CNTL] :=  PORT_ADDR;      { PUT 8255 PORT ADDR ON BUSS.   }
  104.   PORT [PRT_PORT_DATA] :=  DATA;           { PUT 8255 PORT DATA ON BUSS.   }
  105.   PORT [PRT_PORT_CNTL] :=  PORT_ADDR + 1;  { DROP WRITE LINE LOW.          }
  106.   {$IFDEF DEBUG_PPI_WRITE}
  107.   writeln('DATA ON BUS, writeln low, HIT RETURN TO CONTINUE.');READLN;
  108.   {$ENDIF}
  109.  
  110.   DELAY(1);                      { 1 msec delay. }
  111.   PORT [PRT_PORT_CNTL] := PORT_ADDR;      { RAISE WRITE LINE BACK HIGH. }
  112.   {$IFDEF DEBUG_PPI_WRITE}
  113.   writeln('writeln high, data writen=',data,'. HIT RETURN TO CONTINUE');READLN;
  114.   {$ENDIF}
  115.  
  116.   END {PROCEDURE_PPI_WRITE};
  117.  
  118.  
  119. PROCEDURE SET_ADDRESS ( HEX_ADDR:LONGINT );
  120. VAR
  121.      HIGH_ADDR
  122.     , LOW_ADDR : INTEGER;
  123. BEGIN
  124.   HIGH_ADDR := HEX_ADDR DIV 256;
  125.    LOW_ADDR := HEX_ADDR MOD 256;
  126. IF HIGH_ADDR > 7
  127. THEN ERROR('Current hardware only supports up to 11 address bits.')
  128. ELSE
  129. BEGIN
  130. {$IFDEF DEBUG_SET_ADDR}
  131.   WRITE  ('Address passed as >',HEX_ADDR,'<, converted to ');
  132.   WRITELN('HIGH_ADDR = >', HIGH_ADDR, '<,  LOW_ADDR = >', LOW_ADDR,'<' );
  133. {$ELSE}
  134.   PPI_WRITE (CNTL_PORT,HIGH_ADDR  );
  135.   PPI_WRITE (ADDR_PORT, LOW_ADDR);
  136. {$ENDIF}
  137. END;
  138. END{PROCEDURE_SET_ADDRESS};
  139.  
  140.  
  141. PROCEDURE  PPI_ADDR_READ ( HEX_ADDR : LONGINT;   VAR  DATA:INTEGER);
  142.  
  143.  (* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *)
  144. (* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *)
  145. (*  THIS IS THE INTERFACE SOFTWARE BETWEEN THE PC's PARALLEL PORT AND    *)
  146. (*  THE  8255 PPI CHIP. THERE ARE TWELVE LINES BETWEEN THEM, THE EIGHT   *)
  147. (*  DATA LINES, THE TWO MODE SELECT LINES, A /READ SELECT LINE AND A     *)
  148. (*  /WRITE SELECT LINE. DUE TO THE HARDWARE, WRITING A ONE ON ANY DATA   *)
  149. (*  LINE (AND ONE OF THE MODE SELECT LINES) WILL HAVE A HIGH (+5v)       *)
  150. (*  OUTPUT, WHILE WRITING A ONE TO ANY OF OTHER LINES WILL CAUSE THEM    *)
  151. (*  TO GO FROM THEIR NORMALLY HIGH (+5v) TO A LOW (+0v). GOT THAT ???    *)
  152. (*  WELL TO REALLY SCREW YOUR HEAD ON, THE DATA LINES AND  THE 'A0'      *)
  153. (*  MODE SELECT LINE HAVE 'POSITIVE' POLARITY WHILE THE THREE OTHER      *)
  154. (*  CONTROL LINES HAVE NEGITIVE 'POLARITY'.                              *)
  155. (* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *)
  156.  (* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *)
  157.  
  158. CONST   MODE_BIT  = 128;
  159.         PORT_A    = 08;            A_IN = 16;
  160.         PORT_B    = 12;      C_UPPER_IN = 8;
  161.         PORT_C    = 00;      C_LOWER_IN = 1;
  162.         PORT_MODE = 04;           WRITE = 1;
  163. BEGIN
  164.  { Set up mode register to set data port to read mode. }
  165.   PORT [PRT_PORT_CNTL] := PORT_MODE;       { PUT 8255 Mode Addr on BUSS.      }
  166.   PORT [PRT_PORT_DATA] := MODE_BIT + A_IN; { Mode bit and data port.          }
  167.   PORT [PRT_PORT_CNTL] := PORT_MODE+WRITE; { DROP WRITE LINE LOW.             }
  168.   DELAY(1);                                { 1 msec delay.                    }
  169.   PORT [PRT_PORT_CNTL] := PORT_MODE;       { RAISE WRITE LINE BACK HIGH.      }
  170.  
  171.   {$IFDEF DEBUG_PPI_ADDR_READ}
  172.   WRITELN ('PORT ''A'' SET TO READ MODE, HIT ENTER TO CONTINUE.');READLN;
  173.   {$ENDIF}
  174.  
  175.    SET_ADDRESS ( HEX_ADDR );
  176.  
  177.  { Set /READ line low  to EAROM.                                              }
  178.   PORT [PRT_PORT_CNTL] :=  PORT_MODE;      { PUT 8255 Mode Reg Addr on BUS    }
  179.   PORT [PRT_PORT_DATA] :=  READ_BIT_ON;    { Set read bit on via mode reg.    }
  180.   PORT [PRT_PORT_CNTL] :=  PORT_MODE+WRITE;{ DROP WRITE LINE LOW.             }
  181.   DELAY(1);                                { 1 msec delay.                    }
  182.   PORT [PRT_PORT_CNTL] :=  PORT_MODE;      { RAISE WRITE LINE BACK HIGH.      }
  183.  
  184.   {$IFDEF DEBUG_PPI_ADDR_READ}
  185.   WRITELN ('ADDRESS LATCHED, READ LINE LOW TO EAROM, HIT ENTER TO CONTINUE.');
  186.   READLN;
  187.   {$ENDIF}
  188.  
  189.   PORT [PRT_PORT_DATA] := 255;        { PUT ALL HIGH FOR PULLUPS FOR INPUT    }
  190.   PORT [PRT_PORT_CNTL] := 08;         { PUT 8255 PORT 'A' ADDR ON THE LINES.  }
  191.   {$IFDEF DEBUG_PPI_ADDR_READ}
  192.   WRITELN ('ALL HIGH ON PULLUPS, PORT SELECTED, HIT ENTER TO CONTINUE.');READLN;
  193.   {$ENDIF}
  194.  
  195.   PORT [PRT_PORT_CNTL] := 08 + 2;      { SELECT 'A' REG & DROP READ LINE LOW. }
  196.   DELAY (0);                           {         0.1 second delay.            }
  197.   {$IFDEF DEBUG_PPI_ADDR_READ}
  198.   WRITELN ('PORT SELECTED, READ LINE LOW, HIT ENTER TO CONTINUE.'); READLN;
  199.   {$ENDIF}
  200.  
  201.   DATA :=  PORT [PRT_PORT_DATA];     { READ THE 8255 PORT DATA FROM THE BUSS.}
  202.   PORT [PRT_PORT_CNTL] := 08;        { RAISE READ LINE BACK HIGH. }
  203.   {$IFDEF DEBUG_PPI_ADDR_READ}
  204.   WRITELN ('PORT READ COMPLETE INPUT = >',DATA,'<, HIT ENTER TO CONTINUE.');
  205.   READLN;
  206.   {$ENDIF}
  207.  
  208.   { Now that we are done we must set 'A' port read back to output.          }
  209.   PORT [PRT_PORT_CNTL] :=  04;             { PUT 8255 PORT ADDR ON BUSS.    }
  210.   PORT [PRT_PORT_DATA] :=  MODE_BIT;       { ALL 8255 PORTS TO OUTPUT MODE. }
  211.   PORT [PRT_PORT_CNTL] :=  04 + 1;         { DROP WRITE LINE LOW.           }
  212.   DELAY(1);                                { 1 msec delay.                  }
  213.   PORT [PRT_PORT_CNTL] :=  04;             { RAISE WRITE LINE BACK HIGH.    }
  214.  
  215.   {$IFDEF DEBUG_PPI_ADDR_READ}
  216.   WRITELN ('PORT ''A'' SET TO OUTPUT (MODE RESET), HIT ENTER TO CONTINUE.');READLN;
  217.   {$ENDIF}
  218.  
  219. END {PROCEDURE_PPI_ADDR_READ} ;
  220.  
  221.  
  222.  
  223. FUNCTION CONVERT_TO_INT ( IN_STRING :STRING79 ) : INTEGER;
  224.  
  225.  
  226. VAR
  227.             USER_INPUT : STRING79;
  228.                 DIGITS
  229.           ,STRING_CNTR
  230.                     ,X
  231.                   ,CNT : INTEGER;
  232.  
  233.                    SUM
  234.              ,POSITION : LONGINT;
  235.  
  236.                  DIGIT : CHAR;
  237.  
  238. BEGIN
  239.  
  240.  DIGITS := LENGTH ( IN_STRING );
  241.  
  242.  {$IFDEF DEBUG_CONVERT_TO_INT}
  243.     WRITELN;
  244.     WRITELN('                          FUNCTION CONVERT_TO_INT  ');
  245.     WRITELN('                          DIGITS PASSED AS >',DIGITS,'<');
  246.     WRITE  ('                          IN_STRING PASSED AS >');
  247.     WRITE( IN_STRING );
  248.     WRITELN('<');
  249.  {  WRITELN(' Hit enter to continue......'); READLN; }
  250.  {$ENDIF}
  251.  
  252.   SUM := 0;  CNT:=0;
  253.   FOR STRING_CNTR := (DIGITS) DOWNTO 1 DO
  254.   BEGIN
  255.     DIGIT := IN_STRING [STRING_CNTR];
  256.     POSITION := 1;
  257.     FOR X:= 1 TO CNT DO POSITION := POSITION * 16;
  258.  {$IFDEF DEBUG_CONVERT_TO_INT}
  259.     WRITELN ('DIGIT = >',DIGIT,'    POSITION = >',POSITION,'<');
  260.  {   WRITELN(' Hit enter to continue......'); READLN; }
  261.  {$ENDIF}
  262.     CASE DIGIT OF
  263.         '0' : SUM := SUM;
  264.         '1' : SUM := (  1*POSITION ) + SUM;
  265.         '2' : SUM := (  2*POSITION ) + SUM;
  266.         '3' : SUM := (  3*POSITION ) + SUM;
  267.         '4' : SUM := (  4*POSITION ) + SUM;
  268.         '5' : SUM := (  5*POSITION ) + SUM;
  269.         '6' : SUM := (  6*POSITION ) + SUM;
  270.         '7' : SUM := (  7*POSITION ) + SUM;
  271.         '8' : SUM := (  8*POSITION ) + SUM;
  272.         '9' : SUM := (  9*POSITION ) + SUM;
  273.     'A','a' : SUM := ( 10*POSITION ) + SUM;
  274.     'B','b' : SUM := ( 11*POSITION ) + SUM;
  275.     'C','c' : SUM := ( 12*POSITION ) + SUM;
  276.     'D','d' : SUM := ( 13*POSITION ) + SUM;
  277.     'E','e' : SUM := ( 14*POSITION ) + SUM;
  278.     'F','f' : SUM := ( 15*POSITION ) + SUM;
  279.     ELSE  WRITELN ('INVALID HEX CHAR IN CONVERT_TO_INT STRING.');
  280.     END{CASE};
  281.     CNT:=CNT + 1;
  282.  {$IFDEF DEBUG_CONVERT_TO_INT}
  283.       WRITELN('SUM = ',SUM);
  284.       WRITELN(' Hit enter to continue......'); READLN;
  285.  {$ENDIF}
  286.     END{FOR LOOP};
  287.     CONVERT_TO_INT := SUM;
  288.  
  289. (*
  290. { gets user input in hex then calls procedure 'convert_to_int' }
  291. { and converts to integer.                                     }
  292.   REPEAT
  293.   BEGIN
  294.     WRITELN('INPUT HEX NUMBER TO CONVERT.');
  295.     READLN ( USER_INPUT );
  296.     WRITELN(' INPUT READ AS >>',USER_INPUT,'<<');
  297.     WRITELN(' INPUT CONVERTED AS ',CONVERT_TO_INT( USER_INPUT ));
  298.     FOR X := 0 TO 79 DO WRITE('*');WRITELN;
  299.   END;
  300.   UNTIL  ( USER_INPUT[1] = 'Q' );
  301. *)
  302.   END {PROCEDURE_CONVERT_TO_INT};
  303.  
  304.  
  305. FUNCTION  CONVERT_TO_HEX ( INT_IN : LONGINT ) : STRING79 ;
  306. VAR
  307.     INTERMEDIATE_STRING_OUT
  308.                 ,STRING_OUT : STRING79;
  309.  
  310.                       HEX_X
  311.             ,DIGIT_POSITION
  312.                        ,CNT
  313.  
  314.                 ,INT_REMAIN
  315.                  ,INT_CARRY
  316.              ,DIGIT_DIVISOR
  317.               ,DIGIT_WEIGHT : LONGINT;
  318.  
  319. BEGIN
  320.  {$IFDEF DEBUG_CONVERT_TO_HEX}
  321.     WRITELN;
  322.     WRITELN('                          FUNCTION CONVERT_TO_HEX  ');
  323.     WRITELN('                          INTEGER PASSED AS >',INT_IN,'<');
  324.     WRITELN;
  325.  {$ENDIF}
  326. INTERMEDIATE_STRING_OUT := '';
  327. STRING_OUT := '';
  328. INT_CARRY := INT_IN;
  329.  
  330. DIGIT_DIVISOR := 1;
  331. DIGIT_POSITION := 1;
  332. REPEAT
  333. BEGIN
  334.   DIGIT_WEIGHT := 1;
  335.   FOR HEX_X:= 1 TO DIGIT_POSITION DO DIGIT_WEIGHT := DIGIT_WEIGHT * 16;
  336.   INT_REMAIN := INT_CARRY MOD DIGIT_WEIGHT;
  337.   INT_CARRY  := INT_CARRY - INT_REMAIN ;
  338.  
  339.   {$IFDEF DEBUG_CONVERT_TO_HEX}
  340.     WRITE   ('DIGIT_POSITION = >', DIGIT_POSITION );
  341.     WRITELN ('    DIGIT_WEIGHT = >', DIGIT_WEIGHT ,'<');
  342.     WRITE   ('INT_CARRY = >',INT_CARRY,'<');
  343.     WRITELN ('    INT_REMAIN = >', INT_REMAIN , '<');
  344.     WRITE   ('DIGIT_DIVISOR = >',DIGIT_DIVISOR,'<');
  345.     WRITELN ('    STRING_OUT = >',STRING_OUT ,'<' );
  346.     WRITELN;
  347.   { WRITELN(' Hit enter to continue......'); READLN; }
  348.   {$ENDIF}
  349.  
  350. CASE ( INT_REMAIN DIV DIGIT_DIVISOR ) OF
  351.  
  352.  0 : STRING_OUT := STRING_OUT + '0';
  353.  1 : STRING_OUT := STRING_OUT + '1';
  354.  2 : STRING_OUT := STRING_OUT + '2';
  355.  3 : STRING_OUT := STRING_OUT + '3';
  356.  4 : STRING_OUT := STRING_OUT + '4';
  357.  5 : STRING_OUT := STRING_OUT + '5';
  358.  6 : STRING_OUT := STRING_OUT + '6';
  359.  7 : STRING_OUT := STRING_OUT + '7';
  360.  8 : STRING_OUT := STRING_OUT + '8';
  361.  9 : STRING_OUT := STRING_OUT + '9';
  362. 10 : STRING_OUT := STRING_OUT + 'A';
  363. 11 : STRING_OUT := STRING_OUT + 'B';
  364. 12 : STRING_OUT := STRING_OUT + 'C';
  365. 13 : STRING_OUT := STRING_OUT + 'D';
  366. 14 : STRING_OUT := STRING_OUT + 'E';
  367. 15 : STRING_OUT := STRING_OUT + 'F';
  368. ELSE ERROR (' SOMETHING WRONG IN CONVERT_TO_HEX PROCEDURE..... ');
  369. END{CASE_INT_REMAIN};
  370.  
  371. DIGIT_DIVISOR := 1;
  372. FOR HEX_X:= 1 TO DIGIT_POSITION DO DIGIT_DIVISOR := DIGIT_DIVISOR * 16;
  373. INC(DIGIT_POSITION);
  374. END
  375. UNTIL ( INT_CARRY=0 );
  376.  
  377. {$IFDEF DEBUG_CONVERT_TO_HEX}
  378. WRITELN ('END OF DIGIT CONVERT, STRING_OUT = >',STRING_OUT,'<');
  379. WRITELN ('**** LENGTH OF CONVERTED STRING = ',LENGTH(STRING_OUT),' ****');
  380. {$ENDIF}
  381.  
  382. FOR CNT :=  LENGTH(STRING_OUT) DOWNTO 1 DO
  383. BEGIN
  384.  
  385. {$IFDEF  DEBUG_CONVERT_TO_HEX_OUTPUT}
  386.     WRITE   ('INTERMEDIATE_STRING_OUT = >', INTERMEDIATE_STRING_OUT ,'<');
  387.     WRITE   ('    CNT = >', CNT , '<');
  388.     WRITELN ('    STRING_OUT[CNT] = >',STRING_OUT[CNT],'<' );
  389.     WRITELN;
  390.   { WRITELN(' Hit enter to continue......'); READLN; }
  391. {$ENDIF}
  392.  
  393. INTERMEDIATE_STRING_OUT := INTERMEDIATE_STRING_OUT + STRING_OUT[CNT];
  394. END;
  395. CONVERT_TO_HEX := INTERMEDIATE_STRING_OUT;
  396. (*
  397. { Used for debugging convert_to_hex procedure. }
  398. REPEAT
  399. BEGIN
  400. WRITELN('INPUT INTEGER TO CONVERT TO HEX.');
  401. READLN ( IN_NUM );
  402. USER_INPUT := CONVERT_TO_HEX( IN_NUM );
  403. WRITELN ('NUMBER CONVERTED = >',USER_INPUT,'<.');
  404. END
  405. UNTIL IN_NUM = 12345;
  406. *)
  407. END{PROCEDURE_CONVERT_TO_HEX};
  408.  
  409.  
  410. PROCEDURE SET_WRITE_DATA ( HEX_DATA : INTEGER );
  411. BEGIN
  412. PPI_WRITE ( DATA_PORT,HEX_DATA );
  413. END {PROCEDURE_SET_DATA};
  414.  
  415.  
  416.  
  417. PROCEDURE LATCH_WRITE_DATA;
  418. BEGIN
  419.   PPI_WRITE ( MODE_PORT, WRITE_BIT_ON  );   {  SET BIT 6 ON.       }
  420.   DELAY (1);                                { WAIT FOR SETUP TIME. }
  421.   PPI_WRITE ( MODE_PORT, WRITE_BIT_OFF );   { TURN BIT 6 OFF.      }
  422. END {PROCEDURE_LATCH_WRITE_DATA};
  423.  
  424.  
  425.  
  426. PROCEDURE WAIT_FOR_NOT_BUSY;
  427. VAR  CONTROL_DATA : INTEGER;
  428. BEGIN
  429.   REPEAT
  430.   CONTROL_DATA := PORT [PRT_PORT_STAT];
  431.   {$IFDEF DEBUG_READ_BUSY}
  432.    WRITELN('STATUS REGISTER READ AS >',CONTROL_DATA,'< HIT ENTER TO CONTINUE');
  433.    READLN;
  434.   {$ENDIF}
  435.   UNTIL  (CONTROL_DATA >= 128)        {** BUSY BIT OFF = 128 OFF **};
  436. END {WAIT_FOR_NOT_BUSY};
  437.  
  438. PROCEDURE  WRITE_TO_EAROM(HEX_ADDR,HEX_DATA : INTEGER );
  439. BEGIN
  440. {$IFDEF DEBUG_NOT_BURNING}  { DON'T WANT TO WRITE TO PROGRAMMER HARDWARE }
  441. (*  WRITELN;
  442.     WRITE  (' EAROM ADDRESS >>',HEX_ADDR,'<<   ');
  443.     WRITELN(' EAROM DATA >>',HEX_DATA,'<<');
  444.     WRITELN('Press enter to continue.......');
  445.     READLN;
  446. *)
  447. {$ELSE}                     { ONLINE MODE, WRITE TO PROGRAMMER HARDWARE }
  448.   SET_ADDRESS( HEX_ADDR );
  449.   SET_WRITE_DATA   ( HEX_DATA );
  450.   WAIT_FOR_NOT_BUSY;              { JUST IN CASE ??? }
  451.   LATCH_WRITE_DATA;
  452.   WAIT_FOR_NOT_BUSY;
  453. {$ENDIF}
  454. END {PROCEDURE_WRITE_TO_EAROM};
  455.  
  456.  
  457. PROCEDURE FILL_EAROM;
  458. VAR    WRITE_DATA
  459.      ,VERIFY_DATA : INTEGER;
  460.              ADDR : LONGINT;
  461.          HEX_DATA : STRING79;
  462. BEGIN
  463. WRITELN('INPUT HEX DATA TO FILL EAROM WITH. ( TWO DIGITS MAX )');
  464. READLN(HEX_DATA);
  465. WRITE_DATA := CONVERT_TO_INT(HEX_DATA);
  466.  
  467. FOR ADDR := 0 TO MAX_ROM_SIZE DO
  468. BEGIN
  469.   WRITE_TO_EAROM ( ADDR, WRITE_DATA );
  470.   PPI_ADDR_READ  ( ADDR, VERIFY_DATA);
  471.   IF (VERIFY_DATA <> WRITE_DATA)
  472.   THEN ERROR('TRY AGAIN, BAD EAROM WRITE !!!!!!!!!');
  473. END;
  474. END;
  475.  
  476.  
  477. PROCEDURE  PROCESS_JEDEC_REC ( JEDEC_IN :STRING79 );
  478. VAR
  479.      HEX_STRING :STRING79 ;
  480.     LAST_RECORD : BOOLEAN;           { set on last record of jedec   }
  481.        BYTE_CNT
  482.        ,ERR_CNT
  483.       ,REC_TYPE
  484.     ,WRITE_DATA
  485.    ,VERIFY_DATA
  486.            ,CNT : INTEGER;
  487.      START_ADDR : LONGINT;
  488. BEGIN
  489. {$IFDEF DEBUG_PROCESS_JEDEC}
  490.   WRITELN('JEDEC RECORD PASSED TO PROCEDURE AS :');
  491.   WRITE('>>>');
  492.   WRITE( JEDEC_IN );
  493.   WRITELN('<<<');
  494. {$ENDIF}
  495.  
  496.   IF JEDEC_IN[1] <> ':' THEN
  497.   BEGIN
  498.     WRITELN(JEDEC_IN );
  499.     ERROR ('BAD JEDEC RECORD.');
  500.   END;
  501.  
  502.   HEX_STRING  := COPY ( JEDEC_IN, 2, 2);
  503.   BYTE_CNT := CONVERT_TO_INT(HEX_STRING);
  504. {$IFDEF DEBUG_PROCESS_JEDEC}
  505.    WRITELN('BYTE COUNT COMPUTED AS >>',BYTE_CNT,'<<');
  506. {$ENDIF}
  507.   IF BYTE_CNT > 24 THEN
  508.   BEGIN
  509.     WRITELN ('BYTE COUNT > 24. BYTE_CNT = >',BYTE_CNT,'<');
  510.     ERROR('BAD BYTE COUNT.');
  511.   END;
  512.  
  513.   HEX_STRING := COPY ( JEDEC_IN, 4, 4 );
  514.   START_ADDR := CONVERT_TO_INT(HEX_STRING);
  515. {$IFDEF DEBUG_PROCESS_JEDEC}
  516.     WRITE ('START_ADDR = >',START_ADDR,'<    STRING ADDRESS INPUT AS    >');
  517.     WRITE ( JEDEC_IN );
  518.     WRITELN('<');
  519. {$ENDIF}
  520.  
  521.   HEX_STRING := COPY ( JEDEC_IN, 8, 2 );
  522.   REC_TYPE := CONVERT_TO_INT ( HEX_STRING );
  523. {$IFDEF DEBUG_PROCESS_JEDEC}
  524.   WRITE  ('   REC_TYPE = >',REC_TYPE,'<    STRING INPUT TO CONVERT_TO_INT AS >');
  525.   WRITELN( JEDEC_IN[8], JEDEC_IN[9],'< ');
  526. {$ENDIF}
  527.   IF  (REC_TYPE = 0) OR (REC_TYPE = 1)
  528.   THEN { great }
  529.   ELSE ERROR(' RECORD TYPE OF JEDEC RECORD NOT EQUAL TO 0 OR 1.');
  530.   IF  REC_TYPE = 1
  531.     THEN  LAST_RECORD := TRUE
  532.     ELSE  LAST_RECORD := FALSE;
  533. {$IFDEF DEBUG_PROCESS_JEDEC}
  534.     IF LAST_RECORD THEN WRITELN('**********  LAST RECORD FOUND ************.');
  535. {$ENDIF}
  536.  
  537.   IF NOT LAST_RECORD THEN
  538.   BEGIN
  539.   FOR CNT := 0 TO (BYTE_CNT-1) DO
  540.   BEGIN
  541.     HEX_STRING := COPY ( JEDEC_IN, (10+(CNT*2)), 2 );
  542.     WRITE_DATA := CONVERT_TO_INT(HEX_STRING);
  543. {$IFDEF DEBUG_PROCESS_JEDEC}
  544.     WRITELN;
  545.     WRITE  (' EAROM ADDRESS >>',START_ADDR+CNT,'<<   ');
  546.     WRITELN(' EAROM DATA >>',WRITE_DATA,'<<');
  547.     WRITELN('Press enter to continue.......');
  548.     READLN;
  549. {$ELSE}
  550.     WRITE_TO_EAROM ( START_ADDR+CNT, WRITE_DATA );
  551.     PPI_ADDR_READ  ( START_ADDR+CNT, VERIFY_DATA);
  552.     IF (VERIFY_DATA <> WRITE_DATA)
  553.     THEN ERROR('TRY AGAIN, BAD EAROM WRITE !!!!!!!!!');
  554. {$ENDIF}
  555.   END;
  556.   {  * * * * * *  CHECK CHECKSUM  ( FIRST ? )* * * * * *  }
  557.   END;
  558.  END {PROCESS_JEDEC_REC};
  559.  
  560.  
  561. PROCEDURE BURN_EAROM ( FILE_IN : STRING79 );
  562. VAR
  563.     USER_INPUT : STRING79;
  564.           CODE : TEXT;              { internal name of code file.   }
  565.      IO_Result : INTEGER;
  566. BEGIN
  567. { reads input file, passes input record to 'PROCESS_JEDEC_REC' to test. }
  568. IF FILE_IN = ''
  569. THEN
  570. BEGIN
  571.   WRITELN('INPUT NAME OF FILE FOR CODE, INCLUDE PATH.');
  572.   READLN ( USER_INPUT );
  573. END
  574. ELSE
  575. BEGIN
  576.   USER_INPUT := FILE_IN;
  577. END;
  578.  
  579. ASSIGN ( CODE,USER_INPUT );
  580. {$I-}
  581. RESET(CODE);
  582. {$I+}
  583. IO_Result := IOResult;
  584. IF IO_Result <> 0
  585. then BEGIN
  586.        WRITELN ('File not found, try again. IOResult = ',IO_Result );
  587.        WRITELN ('PRESS ENTER TO restart program.');
  588.        READLN;
  589.        Exit;
  590.      END
  591. else
  592. REPEAT
  593. BEGIN
  594.   WRITELN('READING JEDEC INPUT RECORD ......');
  595.   READLN( CODE, USER_INPUT );
  596.   IF EOF(CODE)
  597.   THEN  WRITELN('**********  E O F   Code   Reached  *********')
  598.   ELSE
  599.   BEGIN
  600.     WRITELN('JEDEC RECORD READ IN AS');
  601.     WRITE('>>');
  602.     WRITE( USER_INPUT );
  603.     WRITELN('<<');
  604.     PROCESS_JEDEC_REC( USER_INPUT );
  605.   END;
  606. END{REPEAT};
  607. UNTIL  EOF(CODE);
  608. END {BURN_EAROM};
  609.  
  610.  
  611. {=============================================================================}
  612.  
  613. PROCEDURE COMPARE_JEDEC_REC ( JEDEC_IN :STRING79;  VAR ERROR_RETURN :BOOLEAN );
  614. VAR
  615.      HEX_STRING :STRING79 ;
  616.     LAST_RECORD : BOOLEAN;           { set on last record of jedec   }
  617.        BYTE_CNT
  618.        ,ERR_CNT
  619.       ,REC_TYPE
  620.     ,WRITE_DATA
  621.    ,VERIFY_DATA
  622.            ,CNT : INTEGER;
  623.      START_ADDR : LONGINT;
  624. BEGIN
  625.   ERROR_RETURN := FALSE;
  626.  
  627. {$IFDEF DEBUG_COMPARE_JEDEC}
  628.   WRITELN('JEDEC RECORD PASSED TO PROCEDURE AS :');
  629.   WRITE('>>>');
  630.   WRITE( JEDEC_IN );
  631.   WRITELN('<<<');
  632. {$ENDIF}
  633.  
  634.   IF JEDEC_IN[1] <> ':' THEN
  635.   BEGIN
  636.     WRITELN(JEDEC_IN );
  637.     ERROR ('BAD JEDEC RECORD.');
  638.   END;
  639.  
  640.   HEX_STRING  := COPY ( JEDEC_IN, 2, 2);
  641.   BYTE_CNT := CONVERT_TO_INT(HEX_STRING);
  642. {$IFDEF DEBUG_COMPARE_JEDEC}
  643.    WRITELN('BYTE COUNT COMPUTED AS >>',BYTE_CNT,'<<');
  644. {$ENDIF}
  645.   IF BYTE_CNT > 24 THEN       { Maximum per rec for Intel format }
  646.   BEGIN
  647.     WRITELN ('BYTE COUNT > 24. BYTE_CNT = >',BYTE_CNT,'<');
  648.     ERROR('BAD BYTE COUNT.');
  649.   END;
  650.  
  651.   HEX_STRING := COPY ( JEDEC_IN, 4, 4 );       { Extract starting addr }
  652.   START_ADDR := CONVERT_TO_INT(HEX_STRING);
  653. {$IFDEF DEBUG_COMPARE_JEDEC}
  654.     WRITE ('START_ADDR = >',START_ADDR,'<    STRING ADDRESS INPUT AS    >');
  655.     WRITE ( JEDEC_IN );
  656.     WRITELN('<');
  657. {$ENDIF}
  658.  
  659.   HEX_STRING := COPY ( JEDEC_IN, 8, 2 );
  660.   REC_TYPE := CONVERT_TO_INT ( HEX_STRING );
  661. {$IFDEF DEBUG_COMPARE_JEDEC}
  662.   WRITE  ('   REC_TYPE = >',REC_TYPE,'<    STRING INPUT TO CONVERT_TO_INT AS >');
  663.   WRITELN( JEDEC_IN[8], JEDEC_IN[9],'< ');
  664. {$ENDIF}
  665.   IF  (REC_TYPE = 0) OR (REC_TYPE = 1)
  666.   THEN { great }
  667.   ELSE ERROR(' RECORD TYPE OF JEDEC RECORD NOT EQUAL TO 0 OR 1.');
  668.   IF  REC_TYPE = 1
  669.     THEN  LAST_RECORD := TRUE
  670.     ELSE  LAST_RECORD := FALSE;
  671. {$IFDEF DEBUG_COMPARE_JEDEC}
  672.     IF LAST_RECORD THEN WRITELN('**********  LAST RECORD FOUND ************.');
  673. {$ENDIF}
  674.  
  675.   IF NOT LAST_RECORD THEN
  676.   BEGIN
  677.   FOR CNT := 0 TO (BYTE_CNT-1) DO
  678.   BEGIN
  679.     HEX_STRING := COPY ( JEDEC_IN, (10+(CNT*2)), 2 );
  680.     WRITE_DATA := CONVERT_TO_INT(HEX_STRING);
  681. {$IFDEF DEBUG_COMPARE_JEDEC}
  682.     WRITELN;
  683.     WRITE  (' EAROM ADDRESS >>',START_ADDR+CNT,'<<   ');
  684.     WRITELN(' EAROM DATA >>',WRITE_DATA,'<<');
  685.     WRITELN('Press enter to continue.......');
  686.     READLN;
  687. {$ELSE}
  688.     PPI_ADDR_READ  ( START_ADDR+CNT, VERIFY_DATA);
  689.     IF (VERIFY_DATA <> WRITE_DATA)
  690.     THEN BEGIN
  691.          ERROR_RETURN := TRUE;
  692.          WRITELN(' MISMATCH DETECTED, BAD EAROM COMPARE !!!!!!!!!');
  693.          WRITE  (' Decimal Address = >',START_ADDR+CNT,'<   ');
  694.          WRITE  (' Data read as >', VERIFY_DATA,'<   ');
  695.          WRITELN(' Data should be >',WRITE_DATA,'<   ');
  696.          WRITELN(' ENTER TO CONTINUE............    ');
  697.          READLN;
  698.          END;
  699. {$ENDIF}
  700.   END;
  701.   {  * * * * * *  CHECK CHECKSUM  ( FIRST ? )* * * * * *  }
  702.   END;
  703.  END {COMPARE_JEDEC_REC};
  704.  
  705.  
  706.  
  707.  
  708.  
  709. PROCEDURE COMPARE_EAROM ;
  710. VAR
  711.     USER_INPUT : STRING79;
  712.           CODE : TEXT;              { internal name of code file.   }
  713.      IO_Result : INTEGER;
  714. Error_returned
  715.  ,Error_Status : Boolean;
  716.  
  717. BEGIN
  718. Error_status := false;
  719. { reads input file, passes input record to 'COMPARE_JEDEC_REC' to test. }
  720.  
  721.   WRITELN('INPUT NAME OF FILE FOR CODE, INCLUDE PATH.');
  722.   READLN ( USER_INPUT );
  723.  
  724. ASSIGN ( CODE,USER_INPUT );
  725. {$I-}
  726. RESET(CODE);
  727. {$I+}
  728. IO_Result := IOResult;
  729. IF IO_Result <> 0
  730. then BEGIN
  731.        WRITELN ('File not found, try again. IOResult = ',IO_Result );
  732.        WRITELN ('PRESS ENTER TO restart program.');
  733.        READLN;
  734.        exit;
  735.      END
  736. else
  737. REPEAT
  738. BEGIN
  739.   WRITELN('READING JEDEC INPUT RECORD ......');
  740.   READLN( CODE, USER_INPUT );
  741.   IF EOF(CODE)
  742.   THEN  WRITELN('**********  E O F   Code   Reached  *********')
  743.   ELSE
  744.   BEGIN
  745.     WRITELN('JEDEC RECORD READ IN AS');
  746.     WRITE('>>');
  747.     WRITE( USER_INPUT );
  748.     WRITELN('<<');
  749.     COMPARE_JEDEC_REC( USER_INPUT, ERROR_RETURNED );
  750.     IF Error_Returned=True THEN Error_Status := True;
  751.   END;
  752. END{REPEAT};
  753. UNTIL  EOF(CODE);
  754.  
  755.     CLRSCR;
  756.     GotoXY(10,12);
  757. IF ( Error_Status = FALSE )
  758. THEN WRITELN('  N O    E R R O R S    O N    C O M P A R E .')
  759. ELSE WRITELN('    E R R O R S    O N   C O M P A R E , (You''ve got problems)');
  760.      WRITELN;
  761.     GotoXY(10,14);
  762.     WRITELN('  P R E S S   E N T E R   T O   C O N T I N U E .');
  763.     READLN;
  764. END {COMPARE_EAROM};
  765.  
  766.  
  767. {=============================================================================}
  768.  
  769. PROCEDURE READ_EAROM_BLOCK;
  770. LABEL  REENTER
  771.        ,D_MODE ;
  772. VAR
  773.    Display_Mode
  774.         ,CHOICE : CHAR;
  775.  
  776.     SINGLE_STEP : BOOLEAN;
  777.  
  778.       HEX_START
  779.        ,HEX_END
  780.  ,DISP_HEX_ADDR
  781.  ,DISP_HEX_DATA
  782.        ,LINE_IN : STRING79;
  783.  
  784.            DATA : INTEGER;
  785.  
  786.      ADDR_START
  787.       ,ADDR_END
  788.           ,ADDR
  789.      ,DISP_ADDR
  790.       ,LINE_CNT : LONGINT;
  791.  
  792. BEGIN
  793. REENTER :
  794.   CLRSCR;
  795.   GOTOXY(10,20); WRITELN(' Enter starting hex address to read EAROM.');
  796.   GOTOXY(30,30);
  797.   READLN( hex_start );
  798.  
  799.   GOTOXY(10,50); WRITELN(' Enter ending hex address to read EAROM.');
  800.   GOTOXY(30,60);
  801.   READLN( hex_end );
  802.  
  803. D_MODE:
  804.   GOTOXY(10,65); WRITELN(' Single Step or Display 16 Byte Blocks ?');
  805.   GOTOXY(10,67); Writeln(' Enter   S (single-step)   or   B (block-mode)');
  806.   GOTOXY(30,69);
  807.   READLN( Display_Mode );
  808.   IF   (  (DISPLAY_MODE='S')
  809.        or (DISPLAY_MODE='s') )
  810.   THEN SINGLE_STEP := TRUE
  811.   ELSE IF   ((DISPLAY_MODE='B')
  812.           or (DISPLAY_MODE='b'))
  813.        THEN SINGLE_STEP := FALSE
  814.        ELSE BEGIN
  815.              WRITELN(' Input an ''S'' or ''B'' only you idiot ....... ');
  816.              GOTO  D_MODE;
  817.             END;
  818.  
  819.   ADDR_START := CONVERT_TO_INT ( HEX_START );
  820.   ADDR_END   := CONVERT_TO_INT ( HEX_END );
  821.  
  822.   IF ADDR_START > ADDR_END
  823.   THEN BEGIN
  824.        WRITELN('ERROR, STARTING ADDRESS LARGER THAN ENDING ADDRESS.');
  825.        WRITELN('Enter an ''A'' to reenter addresses, Enter a ''Q'' to quit.');
  826.        READLN (CHOICE);
  827.        IF ((CHOICE = 'A') OR (CHOICE='a'))
  828.        THEN GOTO REENTER
  829.        ELSE EXIT {block};
  830.        END;
  831.  
  832.   IF (ADDR_END > MAX_ROM_SIZE)
  833.   THEN BEGIN
  834.        WRITELN('ERROR, ENDING ADDRESS LARGER THAN MAX ROM SIZE.');
  835.        WRITELN('Enter an ''A'' to reenter addresses, Enter a ''Q'' to quit.');
  836.        READLN (CHOICE);
  837.        IF ((CHOICE = 'A') OR (CHOICE='a'))
  838.        THEN GOTO REENTER
  839.        ELSE EXIT {block};
  840.        END;
  841.  
  842. CLRSCR;
  843. LINE_CNT := 0;
  844. GOTOXY(0,2);
  845.  
  846. FOR ADDR := ADDR_START TO ADDR_END DO
  847. BEGIN
  848.   PPI_ADDR_READ (ADDR,DATA);
  849.   DISP_HEX_ADDR := CONVERT_TO_HEX(ADDR);
  850.   DELETE ( DISP_HEX_ADDR,0,1 );
  851.   WRITE   (' ADDRESS = >', ADDR ,'<  DATA = >', DATA ,'<    HEX DATA = ');
  852.   WRITELN (CONVERT_TO_HEX(DATA),'    HEX ADDR = ', CONVERT_TO_HEX(ADDR) );
  853.  
  854.   INC(LINE_CNT);
  855.   IF  ( (LINE_CNT >= 16) or (single_step) )
  856.   THEN BEGIN
  857.          GOTOXY( 23,00);
  858.  
  859.          IF SINGLE_STEP
  860.          THEN BEGIN
  861. { * * * * * *  TO PROBE DATA AND ADDRESSES ON CHIP WHILE ON SCREEN  * * * * * }
  862. { Set up mode register to set data port to read mode.                         }
  863.   PORT [PRT_PORT_CNTL] := 04  {PORT_MODE} ;{ PUT 8255 Mode Addr on BUSS.      }
  864.   PORT [PRT_PORT_DATA] := 128 + 16        ;{ MODE_BIT + A_IN                  }
  865.   PORT [PRT_PORT_CNTL] := 04 + 1          ;{ DROP WRITE LINE LOW.             }
  866.   DELAY(1);                                { 1 msec delay.                    }
  867.   PORT [PRT_PORT_CNTL] := 04              ;{ RAISE WRITE LINE BACK HIGH.      }
  868.   SET_ADDRESS ( ADDR );                    {                                  }
  869. { Set /READ line low  to EAROM.                                               }
  870.   PORT [PRT_PORT_CNTL] :=  04; {PORT_MODE;}{ PUT 8255 Mode Reg Addr on BUS    }
  871.   PORT [PRT_PORT_DATA] :=  READ_BIT_ON;    { Set read bit on via mode reg.    }
  872.   PORT [PRT_PORT_CNTL] :=  04 + 1 {WRITE}; { DROP WRITE LINE LOW.             }
  873.   DELAY(1);                                { 1 msec delay.                    }
  874.   PORT [PRT_PORT_CNTL] :=  04;             { RAISE WRITE LINE BACK HIGH.      }
  875. { * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * }
  876.               WRITELN('Data and addr on chip, Enter to display next address.');
  877.               END
  878.  
  879.          ELSE WRITELN('Enter to display next 16 addresses.');
  880.          READLN;
  881.          CLRSCR;
  882.          LINE_CNT := 0;
  883.          GOTOXY(0,2);
  884.        END;
  885. END {Addr_reads};
  886. WRITELN(' Hit Enter to return to menu.');
  887. READLN;
  888. END {READ_EAROM_BLOCK};
  889.  
  890.  
  891. PROCEDURE BEEP ( FREQ, SEC : INTEGER );
  892. BEGIN
  893.  SOUND(FREQ);
  894.  DELAY(SEC*100);
  895.  NOSOUND;
  896. END; { Beep }
  897.  
  898.  
  899.  
  900. PROCEDURE USE_MENU_MODE;
  901. VAR
  902.                A_CHAR : CHAR;              { used to read input able.      }
  903.  
  904.      INPUT_FILE_PARAM : STRING79;
  905. BEGIN
  906.  
  907. REPEAT
  908. BEGIN
  909. CLRSCR;
  910. GotoXY(20,8); WRITELN('ENTER CHOICE OF FUNCTION DESIRED.');
  911. GotoXY(10,12);WRITELN('A : To burn EAROM from jedec file input.');
  912. GotoXY(10,14);WRITELN('B : To verify an EAROM already burned from a file.');
  913. GotoXY(10,16);Writeln('C : To single step through an EAROM.');
  914. GotoXY(10,18);WRITELN('D : To fill an EAROM with a user input byte value.');
  915. GotoXY(10,20);Writeln('Q : TO QUIT PROGRAM.');
  916. GOTOXY(30,22);
  917. readln(A_CHAR);
  918. Input_File_Param := '';
  919.  
  920. CASE A_CHAR OF
  921. 'A','a' : BEGIN  BURN_EAROM (INPUT_FILE_PARAM); BEEP(500,2);  END;
  922. 'B','b' : BEGIN  COMPARE_EAROM;                               END;
  923. 'C','c' : BEGIN  READ_EAROM_BLOCK ; BEEP(500,2);              END;
  924. 'D','d' : BEGIN  FILL_EAROM; BEEP(500,2);                     END;
  925. 'Q','q' : BEGIN  BEEP(2000,1);HALT                            END;
  926.   ELSE  BEGIN
  927.         WRITELN('INVALID ENTRY, Enter to continue.......');
  928.         SOUND(35);
  929.         DELAY(800);
  930.         NOSOUND;
  931.         DELAY(1000);
  932.         END;
  933. END {CASE};
  934. END;
  935.  
  936. UNTIL ((A_CHAR='Q') OR (A_CHAR='q'));
  937. END; { Use_Menu_Mode }
  938.  
  939.  
  940. {*****************************************************************************}
  941. {*                  T H E   M A I N L I N E   C O D E                        *}
  942. {*****************************************************************************}
  943. BEGIN
  944.  
  945.  
  946. WRITELN ('Initializing 8255 .................');
  947. ppi_write(MODE_PORT,128 );
  948. WRITELN ('Initialize complete................');
  949.  
  950. INPUT_FILE_PARAM := '';
  951.  
  952. IF ( PARAMCOUNT > 1 )
  953. THEN BEGIN
  954.        Textcolor (0);
  955.        TextBackGround (7);
  956.        WRITELN('Too many parameters passed, check parameters input.');
  957.        NormVideo;
  958.        TextColor (15+blink );
  959.        WRITELN('Hit enter to exit program.');
  960.        NormVideo;
  961.        READLN;
  962.        HALT;
  963.      END;
  964.  
  965. IF PARAMCOUNT=0
  966. THEN USE_MENU_MODE
  967. ELSE BEGIN
  968.        INPUT_FILE_PARAM := PARAMSTR(1);
  969.        BURN_EAROM (INPUT_FILE_PARAM);
  970.      END;
  971.  
  972. END.
  973.