home *** CD-ROM | disk | FTP | other *** search
/ HAM Radio 3 / hamradioversion3.0examsandprograms1992.iso / mods / caty-767 / y767inst.pas < prev    next >
Pascal/Delphi Source File  |  1989-12-09  |  59KB  |  1,433 lines
  1. UNIT Y767INST (* Y767 Instruction routines  D. J. Wilke N3HGQ 09/27/89 *);
  2.  
  3. INTERFACE
  4.  
  5. USES CRT, DOS, Y767GLO, Y767UTIL,
  6.      Y767DISP, Y767COMM, Y767RTC;
  7.  
  8. PROCEDURE LoadMemories(MemFileToUse : STRING);
  9. PROCEDURE SelectMemFile;
  10. PROCEDURE SetUpSplit(Page,BarPos : INTEGER; FreqSet : STRING);
  11. PROCEDURE SetVFO(Page,BarPos : INTEGER);
  12. PROCEDURE Pager(Page,BarPos : INTEGER);
  13. PROCEDURE LoadVFO(VFOFileToUse : STRING);
  14. PROCEDURE SelectVFOFile;
  15. PROCEDURE HGSelect;
  16. PROCEDURE SetFreq;
  17. PROCEDURE VFOMRSelect;
  18. PROCEDURE MemSelect;
  19. PROCEDURE ModeSelect;
  20. PROCEDURE ProgStep;
  21. PROCEDURE CTCSSToneSet;
  22. PROCEDURE WhatWasThat(Param : String5; Col,Row : INTEGER);
  23. PROCEDURE CatSend(Param : String5; StatusUpdateSize : INTEGER);
  24. PROCEDURE StatusUpdate(Param : String86);
  25. PROCEDURE TurnCatOn;
  26. PROCEDURE TurnCatOff;
  27. PROCEDURE CheckStatus(Inst : String5);
  28. PROCEDURE QuickStat;
  29. PROCEDURE MainFrame;
  30. PROCEDURE MainMenu;
  31. FUNCTION Offset(Page,BarPos : INTEGER) : STRING;
  32.  
  33. IMPLEMENTATION
  34.  
  35. (*▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓*)
  36. PROCEDURE LoadMemories(MemFileToUse : STRING);
  37.  
  38. VAR
  39.     RecNo,DotPos,
  40.     Result,BCDin     : INTEGER;
  41.     Ok               : BOOLEAN;
  42.     FreqChr          : STRING;
  43.     Tone             : STRING[2];
  44.     DispFreq         : STRING[7];
  45.     FreqSet          : STRING[8];
  46.     FreqString,
  47.     LSDFreq          : STRING[10];
  48.     Desc             : STRING[50];
  49.     FreqTune         : REAL;
  50.     Mode             : CHAR;
  51.  
  52. BEGIN (* LoadMemories *)
  53.     WINDOW(2,6,79,23);
  54.     PrMessage('Load memories from Datafile',4);
  55.     CLRSCR;
  56.     ASSIGN(Y767MemDataFile,MemFileToUse);
  57.     {$I-} RESET(Y767MemDataFile) {$I+} ;
  58.     Ok := (IOResult = 0);
  59.     IF NOT Ok THEN BEGIN
  60.         TEXTCOLOR(20);
  61.         TEXTBACKGROUND(DBG);                 (* Error colors *)
  62.         GOTOXY(20,6);
  63.         WRITE('Cannot find FT-767 memory channel data file.');
  64.         GOTOXY(20,7);
  65.         WRITE('Memory channels will NOT be loaded.');
  66.         GOTOXY(20,8);
  67.         WRITE('Press return to continue.');
  68.         Warble(1000,800);
  69.         READLN;
  70.     END (* IF NOT Ok *)
  71.     ELSE BEGIN
  72.         RecNo   := 0;
  73.         FreqString := '';
  74.         TEXTCOLOR(PFG);
  75.         TEXTBACKGROUND(BLUE);              (* Special parameter colors *)
  76.         GOTOXY(26,3);
  77.         WRITE(' Using Datafile ');
  78.         TEXTCOLOR(SFG);
  79.         TEXTBACKGROUND(BLUE);              (* Filename colors *)
  80.         WRITE(MemFileToUse,' ');
  81.         TEXTCOLOR(DFG);
  82.         TEXTBACKGROUND(DBG);               (* Default screen colors *)
  83.         GOTOXY(5,5);
  84.         WRITE('Memory   Frequency   Tone  ');
  85.         GOTOXY(33,5);
  86.         WRITE('Identifier, Description, Offset, Notes');
  87.         PrLines('H',6,75,11,11,SBA,DBG,196); (* Display divider line *)
  88.         PrLines('V',9,9,12,21,SBA,DBG,179);
  89.         PrLines('V',26,26,12,21,SBA,DBG,179);
  90.         PrLines('V',31,31,12,21,SBA,DBG,179);
  91.         CatSend(Nul3String+CHR(0)+CHR(9),5); (* Load into VFO A *)
  92.         FOR Index := 1 TO 9 DO BEGIN
  93.             READLN(Y767MemDataFile);         (* Read past column titles *)
  94.         END; (* FOR Index *)
  95.         WHILE RecNo < 10 DO BEGIN
  96.             FreqString := '';
  97.             LSDFreq    := '';
  98.             FreqSet    := '';
  99.             TEXTCOLOR(PFG);
  100.             TEXTBACKGROUND(DBG);             (* Parameter colors *)
  101.             READLN(Y767MemDataFile,Y767MemFileParams);
  102.             IF LENGTH(Y767MemFileParams) > 26 THEN BEGIN
  103.                 GOTOXY(6,RecNo + 7);
  104.                 FreqString    := COPY(Y767MemFileParams,1,8);
  105.                 Tone          := COPY(Y767MemFileParams,10,2);
  106.                 Mode          := Y767MemFileParams[13];
  107.                 DispFreq      := COPY(Y767MemFileParams,15,7);
  108.                 Desc          := COPY(Y767MemFileParams,25,50);
  109.                 GOTOXY(6,RecNo + 7);  WRITE(RecNo);
  110.                 GOTOXY(12,RecNo + 7); WRITE(DispFreq);
  111.                 GOTOXY(20,RecNo + 7); WRITE('MHz.');
  112.                 GOTOXY(27,RecNo + 7); WRITE(Tone);
  113.                 GOTOXY(33,RecNo + 7); WRITE(Desc);
  114.                 VAL(FreqString,FreqTune,Result);
  115.                 FreqTune := FreqTune/100000.0;
  116.                 CheckFreq(FreqTune);             (* Check if valid Freq *)
  117.                 LSDFreq  := MakeLSDMSD(FreqString,8);
  118.                 FreqSet  := FreqParm(LSDFreq,8);
  119.                 IF NOT FreqErrorFlag THEN BEGIN  (* Send the Freq to 767 *)
  120.                     CatSend(MultString(3,NUL)+CHR(RecNo)+CHR($A),8); (*Sel Mem ch *)
  121.                     CatSend(FreqSet+CHR(8),5);   (* Set the frequency *)
  122.                     CASE Mode OF
  123.                         'L' : Mode := CHR($10);
  124.                         'U' : Mode := CHR($11);
  125.                         'C' : Mode := CHR($12);
  126.                         'A' : Mode := CHR($13);
  127.                         'F' : Mode := CHR($14);
  128.                         'K' : Mode := CHR($15);
  129.                     END; (* CASE *)
  130.                     CatSend(Nul3String+Mode+CHR($A),8); (* Set Mem Mode *)
  131.                     CatSend(Nul3String+CHR($60)+CHR($A),86); (* Move to Mem *)
  132.                 END; (* IF NOT *)
  133.             END; (* IF LENGTH *)
  134.             INC(RecNo);
  135.         END; (* WHILE RecNo *)
  136.         CatSend(Nul3String+CHR(2)+CHR(9),5); (* Now, turn on MR *)
  137.         WINDOW(1,1,80,25);
  138.         Pause;
  139.         PrFKeys;
  140.         TEXTCOLOR(DFG);
  141.         TEXTBACKGROUND(DBG);                 (* Default screen colors *)
  142.     END; (* ELSE *)
  143. END; (* LoadMemories *)
  144.  
  145. (*▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓*)
  146. PROCEDURE SelectMemFile;
  147.  
  148. VAR
  149.     MemoryProgramFile : CHAR;
  150.     MemFileToUse      : STRING[12];
  151.  
  152. BEGIN (* SelectMemFile *)
  153.     WINDOW(2,2,79,4);
  154.     PrMessage('     Load Memories from Database File     ',3);
  155.     WINDOW(2,6,79,23);
  156.     CLRSCR;
  157.     PrMessage('Choose a Memory Datafile:',2);
  158.     GOTOXY(20,4);
  159.     TEXTCOLOR(RFG);
  160.     TEXTBACKGROUND(DBG);                     (* Requested parameter colors *)
  161.     WRITELN('1. Default FT-767GX memory setup program.');
  162.     GOTOXY(20,5);
  163.     WRITELN('2. HF/VHF Packet frequencies program.');
  164.     GOTOXY(20,6);
  165.     WRITELN('3. Two meter FM voice repeaters program.');
  166.     GOTOXY(20,7);
  167.     WRITELN('4. HAM HF/VHF CW subbands program.');
  168.     GOTOXY(20,8);
  169.     WRITELN('5. HAM HF/VHF/UHF phone subbands program.');
  170.     GOTOXY(20,9);
  171.     WRITELN('6. Commercial FAX frequencies program.');
  172.     GOTOXY(20,10);
  173.     WRITELN('7. Commercial RTTY frequencies program.');
  174.     GOTOXY(20,11);
  175.     WRITELN('8. Commercial AMTOR/SITOR frequencies program.');
  176.     GOTOXY(55,2);
  177.     MemoryProgramFile := READKEY;
  178.     CASE MemoryProgramFile OF
  179.         '1' : MemFileToUse := 'Y767DEF .MEM';
  180.         '2' : MemFileToUse := 'Y767PAK .MEM';
  181.         '3' : MemFileToUse := 'Y7672MR .MEM';
  182.         '4' : MemFileToUse := 'Y767CWB .MEM';
  183.         '5' : MemFileToUse := 'Y767PHB .MEM';
  184.         '6' : MemFileToUse := 'Y767FAX .MEM';
  185.         '7' : MemFileToUse := 'Y767RTY .MEM';
  186.         '8' : MemFileToUse := 'Y767AMT .MEM';
  187.     END; (* CASE *)
  188.     LoadMemories(MemFileToUse);
  189. END; (* SelectMemFile *)
  190.  
  191. (*▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓*)
  192. PROCEDURE SetUpSplit(Page,BarPos : INTEGER; FreqSet : STRING);
  193. (* Tune VFO B to repeater's INPUT Freq, VFO A to repeater's OUTPUT *)
  194.  
  195. BEGIN (* SetUpSplit *)
  196.     CatSend(Nul3String+CHR(1)+CHR(9),5);     (* Set up to load VFO B *)
  197.     CatSend(Offset(Page,BarPos)+CHR(8),5);   (* Set VFO B frequency *)
  198.     CatSend(Nul3String+CHR(0)+CHR(9),5);     (* Set up to load VFO A *)
  199.     CatSend(FreqSet+CHR(8),5);               (* Set VFO A frequency *)
  200.     IF (ORD(Update[1])) AND ($08) = 0 THEN   (* Mask off Split bit *)
  201.         CatSend(SplitTog,26);                (* Toggle Split on, if off *)
  202. END; (* SetUpSplit *)
  203.  
  204. (*▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓*)
  205. PROCEDURE SetVFO(Page,BarPos : INTEGER);
  206.  
  207. VAR
  208.     FreqSet    : STRING[8];
  209.     LSDFreq    : STRING[8];
  210.     FreqString : STRING[8];
  211.     Result     : INTEGER;
  212.     Mode       : CHAR;
  213.     FreqTune   : REAL;
  214.  
  215. BEGIN (* SetVFO *)
  216.     FreqString  := COPY(MemArray[Page *10 +BarPos],1,8);
  217.     VAL(FreqString,FreqTune,Result);
  218.     FreqTune := FreqTune/100000.0;
  219.     IF COPY(MemArray[Page *10 +BarPos],1,8) <> '        ' THEN BEGIN
  220.         LSDFreq := MakeLSDMSD(COPY(MemArray[Page *10 +BarPos],1,8),8);
  221.         FreqSet := FreqParm(LSDFreq,8);
  222.         Mode    := MemArray[Page *10 +BarPos,13];
  223.         CASE Mode OF
  224.             'L' : Mode := CHR($10);
  225.             'U' : Mode := CHR($11);
  226.             'C' : Mode := CHR($12);
  227.             'A' : Mode := CHR($13);
  228.             'F' : Mode := CHR($14);
  229.             'K' : Mode := CHR($15);
  230.         END; (* CASE *)
  231.         CheckFreq(FreqTune);                 (* Check if within valid range *)
  232.         IF NOT FreqErrorFlag THEN BEGIN
  233.             CatSend(MultString(3,NUL)+Mode+CHR($A),8); (* Set the Mode *)
  234.             IF COPY(MemArray[Page *10 +BarPos],23,1) = '-' THEN
  235.                 SetUpSplit(Page,BarPos,FreqSet); (* Load VFO with minus offset *)
  236.             IF COPY(MemArray[Page *10 +BarPos],23,1) = '+' THEN
  237.                 SetUpSplit(Page,BarPos,FreqSet); (* Load VFO with plus offset *)
  238.             IF COPY(MemArray[Page *10 +BarPos],23,1) = ' ' THEN BEGIN
  239.                 CatSend(Aclr,26);            (* Turn off SPLIT/CLAR/OFFSET *)
  240.                 CatSend(Nul3String+CHR(0)+CHR(9),5); (* Set up to load VFO A *)
  241.                 CatSend(FreqSet+CHR(8),5);   (* Set VFO A frequency *)
  242.             END; (* IF *)
  243.             TEXTCOLOR(SFG);
  244.             TEXTBACKGROUND(DBG);             (* Selected Freq colors *)
  245.             PrDfPage(Page,Page *10 +BarPos,1); (* Place bar *)
  246.             CatSend(Check,86);               (* Get new parameters *)
  247.             QuickStat;                       (* Display new Freq *)
  248.             WINDOW(5,12,79,22);              (* Back to paging window *)
  249.             GOTOXY(1,BarPos);                (* Put cursor at beg of line *)
  250.             Peep(2000);                      (* Give audible signal *)
  251.         END; (* IF NOT *)
  252.     END; (* IF *)
  253. END; (* SetVFO *)
  254.  
  255. (*▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓*)
  256. PROCEDURE Pager(Page,BarPos : INTEGER);
  257.  
  258. BEGIN (* Pager *)
  259.     TEXTCOLOR(PFG);
  260.     TEXTBACKGROUND(DBG);                     (* Requested param colors *)
  261.     CLRSCR;                                  (* Remove all old entries *)
  262.     PrDfPage(Page,0,10);                     (* Put up 10 line page *)
  263.     TEXTCOLOR(BFG);
  264.     TEXTBACKGROUND(BBG);                     (* Selection bar colors *)
  265.     PrDfPage(Page,Page *10 +BarPos,1);       (* Put bar on 1 or 10 *)
  266.     TEXTCOLOR(PFG);
  267.     TEXTBACKGROUND(DBG);                     (* Requested param colors *)
  268.     GOTOXY(1,BarPos);                        (* Put cursor at beg of line *)
  269. END; (* Pager *)
  270.  
  271. (*▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓*)
  272. PROCEDURE LoadVFO(VFOFileToUse : STRING);
  273.  
  274. VAR
  275.     RecNo,Page,
  276.     Xpos,BarPos,
  277.     Result,BCDin     : INTEGER;
  278.     Ok,Fk,Display    : BOOLEAN;
  279.     Choice           : CHAR;
  280.  
  281. BEGIN (* LoadVFO *)
  282.     WINDOW(2,6,79,23);
  283.     PrMessage('Load VFO A from Datafile',4);
  284.     CLRSCR;
  285.     ASSIGN(Y767VFODataFile,VFOFileToUse);
  286.     {$I-} RESET(Y767VFODataFile) {$I+} ;
  287.     Ok := (IOResult = 0);
  288.     IF NOT Ok THEN BEGIN
  289.         TEXTCOLOR(20);
  290.         TEXTBACKGROUND(DBG);                 (* Error colors *)
  291.         GOTOXY(20,6);
  292.         WRITE('Cannot find FT-767 VFO database file.');
  293.         GOTOXY(20,7);
  294.         WRITE('VFO A will NOT be loaded.');
  295.         GOTOXY(20,8);
  296.         WRITE('Press return to continue.');
  297.         Warble(1000,800);
  298.         READLN;
  299.     END (* IF NOT Ok *)
  300.     ELSE BEGIN                               (* File read OK, get data *)
  301.         RecNo      := 0;
  302.         Page       := 0;
  303.         Display    := TRUE;                  (* Display pages of datafile *)
  304.         Xpos       := 5;
  305.         BarPos     := 1;                     (* Bar at top on page 0 *)
  306.         TEXTCOLOR(PFG);
  307.         TEXTBACKGROUND(BLUE);                (* Special parameter colors *)
  308.         GOTOXY(26,3);
  309.         WRITE(' Using Datafile ');
  310.         TEXTCOLOR(SFG);
  311.         TEXTBACKGROUND(BLUE);                 (* Filename colors *)
  312.         WRITE(VFOFileToUse,' ');
  313.         TEXTCOLOR(DFG);
  314.         TEXTBACKGROUND(DBG);                 (* Default screen colors *)
  315.         GOTOXY(2,18);
  316.         WRITE('  <Page Up>  <Page Down>  <',CHR(24),',',CHR(25));
  317.         WRITE('> to select  <',CHR(17),CHR(196),CHR(217),'> to set VFO  <End> to exit');
  318.         GOTOXY(5,5);
  319.         WRITE('Record  Freq   Ofs  Mode   ');
  320.         GOTOXY(33,5);
  321.         WRITE('Identifier, Description, Notes');
  322.         PrLines('H',6,75,11,11,SBA,DBG,196); (* Display divider line *)
  323.         FILLCHAR(MemArray,SIZEOF(MemArray),' '); (* Initialize array *)
  324.         FOR Index := 1 TO 9 DO BEGIN
  325.            READLN(Y767VFODataFile);          (* Read past column titles *)
  326.         END; (* FOR Index *)
  327.         WINDOW(5,12,79,22);                  (* Paging window *)
  328.         WHILE NOT EOF(Y767VFODataFile) DO BEGIN
  329.             TEXTCOLOR(PFG);
  330.             TEXTBACKGROUND(DBG);             (* Parameter colors *)
  331.             INC(RecNo);
  332.             READLN(Y767VFODataFile,Y767MemFileParams);
  333.             (* Make bar length = 70 characters for valid entries *)
  334.             IF (LENGTH(Y767MemFileParams) < 70) THEN BEGIN
  335.                 Y767MemFileParams := Y767MemFileParams
  336.                 + MultString(70 - LENGTH(Y767MemFileParams),' ');
  337.             END; (* IF *)
  338.             MemArray[RecNo] := Y767MemFileParams;
  339.         END; (* WHILE NOT EOF*)
  340.         CLRSCR;
  341.         PrDfPage(Page,0,10);                 (* Display Page 0 *)
  342.         GOTOXY(1,BarPos);
  343.         TEXTCOLOR(BFG);
  344.         TEXTBACKGROUND(BBG);
  345.         PrDfPage(Page,Page *10 +BarPos,1);   (* Put bar on 1st entry *)
  346.         GOTOXY(1,BarPos);
  347.         WHILE Display DO BEGIN
  348.             REPEAT
  349.                 InKey(Fk,Choice);
  350.             UNTIL (Choice IN [#72..#82])
  351.                OR (Choice = #13);
  352.             CASE Choice OF
  353.                  #13 : SetVFO(Page,BarPos);                   (* <Enter> *)
  354.                  #72 : BEGIN                                  (* Cursor Up *)
  355.                            DEC(BarPos);
  356.                            IF BarPos = 0 THEN BEGIN           (* At top? *)
  357.                                BarPos := 10;                  (* Then rollover *)
  358.                                DEC(Page);
  359.                                IF Page < 0 THEN Page := 9;
  360.                                Pager(Page,BarPos);
  361.                            END;
  362.                            TEXTCOLOR(PFG);
  363.                            TEXTBACKGROUND(DBG);
  364.                            GOTOXY(1,BarPos);
  365.                            TEXTCOLOR(BFG);
  366.                            TEXTBACKGROUND(BBG);
  367.                            PrDfPage(Page,Page *10 +BarPos,1); (* Place bar *)
  368.                            TEXTCOLOR(PFG);
  369.                            TEXTBACKGROUND(DBG);
  370.                            IF BarPos = 10 THEN
  371.                                PrDfPage(Page,Page *10 +1,1)   (* Remove old bar at top *)
  372.                            ELSE
  373.                                PrDfPage(Page,Page *10 +BarPos +1,1); (* Else old bar *)
  374.                            GOTOXY(1,BarPos);
  375.                        END;
  376.                  #73 : BEGIN                                  (* Page UP *)
  377.                            DEC(Page);
  378.                            IF Page < 0 THEN Page := 9;
  379.                            BarPos := 10;
  380.                            Pager(Page,BarPos);
  381.                        END;
  382.                  #79 : Display := FALSE;                      (* End *)
  383.                  #80 : BEGIN                                  (* Cursor Down *)
  384.                            INC(BarPos);
  385.                            IF BarPos = 11 THEN BEGIN          (* At bottom? *)
  386.                                BarPos := 1;                   (* Then rollover *)
  387.                                INC(Page);
  388.                                IF Page = 10 THEN Page := 0;
  389.                                Pager(Page,BarPos);
  390.                            END;
  391.                            TEXTCOLOR(PFG);
  392.                            TEXTBACKGROUND(DBG);
  393.                            GOTOXY(1,BarPos);
  394.                            TEXTCOLOR(BFG);
  395.                            TEXTBACKGROUND(BBG);
  396.                            PrDfPage(Page,Page *10 +BarPos,1); (* Place bar *)
  397.                            TEXTCOLOR(PFG);
  398.                            TEXTBACKGROUND(DBG);
  399.                            IF BarPos = 1 THEN
  400.                                PrDfPage(Page,Page *10 +10,1)  (* Remove old bar at bot *)
  401.                            ELSE
  402.                                PrDfPage(Page,Page *10 +BarPos -1,1); (* Else old bar *)
  403.                            GOTOXY(1,BarPos);
  404.                        END;
  405.                  #81 : BEGIN                                  (* Page Down *)
  406.                            INC(Page);
  407.                            IF Page = 10 THEN Page := 0;
  408.                            BarPos := 1;
  409.                            Pager(Page,BarPos);
  410.                        END; (* #81 *)
  411.             END; (* CASE *)
  412.         END; (* WHILE Display *)
  413.     END; (* ELSE *)
  414.     WINDOW(2,6,79,23);
  415.     TEXTCOLOR(DFG);
  416.     TEXTBACKGROUND(DBG);                     (* Default screen colors *)
  417. END; (* LoadVFO *)
  418.  
  419. (*▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓*)
  420. PROCEDURE SelectVFOFile;
  421.  
  422. VAR
  423.     VFOProgramFile : CHAR;
  424.     VFOFileToUse   : STRING[12];
  425.  
  426. BEGIN (* SelectVFOFile *)
  427.     WINDOW(2,2,79,4);
  428.     PrMessage('     Load VFO A from Database File     ',3);
  429.     WINDOW(2,6,79,23);
  430.     CLRSCR;
  431.     PrMessage('Choose a VFO Datafile:',2);
  432.     GOTOXY(20,4);
  433.     TEXTCOLOR(RFG);
  434.     TEXTBACKGROUND(DBG);                     (* Requested parameter colors *)
  435.     WRITELN('1. Two Meter FM Voice Repeaters.');
  436.     GOTOXY(20,5);
  437.     WRITELN('2. RTTY press frequencies 2.024 - 14.565 MHz.');
  438.     GOTOXY(20,6);
  439.     WRITELN('3. RTTY press frequencies 14.568 - 19.280 MHz.');
  440.     GOTOXY(20,7);
  441.     WRITELN('4. RTTY press frequencies 19.565 - 25.337 MHz.');
  442.     GOTOXY(20,8);
  443.     WRITELN('5. International Shortwave  2.000 - 11.500 MHz.');
  444.     GOTOXY(20,9);
  445.     WRITELN('6. International Shortwave 11.600 - 28.000 MHz.');
  446.     GOTOXY(20,10);
  447.     WRITELN('7. 25 Meter Shortwave Band 11.700 - 11.975 MHz.');
  448.     GOTOXY(20,11);
  449.     WRITELN('8. 31 Meter Shortwave Band  9.500 -  9.775 MHz.');
  450.     GOTOXY(20,12);
  451.     WRITELN('9. AM Broadcast Band 0.550 - 1.600 MHz.');
  452.     GOTOXY(55,2);
  453.     VFOProgramFile := READKEY;
  454.     CASE VFOProgramFile OF
  455.         '1' : VFOFileToUse := 'Y7672MR .DAT';
  456.         '2' : VFOFileToUse := 'Y767TTA .DAT';
  457.         '3' : VFOFileToUse := 'Y767TTB .DAT';
  458.         '4' : VFOFileToUse := 'Y767TTC .DAT';
  459.         '5' : VFOFileToUse := 'Y767SWA .DAT';
  460.         '6' : VFOFileToUse := 'Y767SWB .DAT';
  461.         '7' : VFOFileToUse := 'Y76725M .DAT';
  462.         '8' : VFOFileToUse := 'Y76731M .DAT';
  463.         '9' : VFOFileToUse := 'Y767AMB .DAT';
  464.     END; (* CASE *)
  465.     LoadVFO(VFOFileToUse);
  466. END; (* SelectVFOFile *)
  467.  
  468. (*▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓*)
  469. PROCEDURE HGSelect (* Select between Ham or General coverage bands *);
  470.  
  471. VAR
  472.     HGS,CovSel : CHAR;
  473.  
  474. BEGIN (* HgSelect *)
  475.     TEXTCOLOR(DFG);
  476.     TEXTBACKGROUND(DBG);                     (* Default screen colors *)
  477.     WINDOW(1,1,80,5);
  478.     PrMessage('Ham/General Coverage Screen',4);
  479.     WINDOW(2,6,79,23);
  480.     CLRSCR;
  481.     PrBandLimits;                            (* Display band limits table *)
  482.     (* Display headings & draw `Band Mode' box *)
  483.     TEXTCOLOR(RFG);
  484.     TEXTBACKGROUND(DBG);                     (* Requested parameter colors *)
  485.     GOTOXY(56,1); WRITE ('     Band Mode     ');
  486.     PrBox;                                   (* Draw `H/G Select' box *)
  487.     (* Prompt for Ham or General coverage *)
  488.     TEXTCOLOR(RFG);
  489.     TEXTBACKGROUND(DBG);                     (* Requested parameter colors *)
  490.     GOTOXY(11,1); WRITE('H');
  491.     TEXTCOLOR(DFG);
  492.     TEXTBACKGROUND(DBG);                     (* Default screen colors *)
  493.     WRITE(' = Ham Bands, ');
  494.     TEXTCOLOR(RFG);
  495.     TEXTBACKGROUND(DBG);                     (* Requested parameter colors *)
  496.     WRITE('G');
  497.     TEXTCOLOR(DFG);
  498.     TEXTBACKGROUND(DBG);                     (* Default screen colors *)
  499.     WRITE(' = General Coverage');
  500.     GOTOXY(11,3); WRITE('Enter H or G.');
  501.     GOTOXY(25,3); WRITE(CHR(198));
  502.     FOR Index := 1 TO 29 DO
  503.         WRITE(CHR(205));
  504.     WRITE(CHR(16));
  505.     IF SetSel THEN BEGIN
  506.         TEXTCOLOR(RFG);
  507.         TEXTBACKGROUND(DBG);                 (* Requested parameter colors *)
  508.         GOTOXY(58,3); WRITE ('       ?        ');
  509.         GOTOXY(65,3);
  510.         REPEAT
  511.             CovSel := UPCASE(ReadKey);
  512.         UNTIL (CovSel = 'H') OR (CovSel = 'G');
  513.         GOTOXY(58,3);
  514.         IF CovSel = 'H' THEN BEGIN
  515.             HGS := CHR(32);
  516.             WRITE('   Ham Bands    ');
  517.         END (* IF Covsel *)
  518.         ELSE BEGIN
  519.             HGS := CHR(33);
  520.             WRITE('  Gen Coverage  ');
  521.         END; (* ELSE *)
  522.     END; (* IF SetSel *)
  523.     TEXTCOLOR(DFG);
  524.     TEXTBACKGROUND(DBG);                     (* Default screen colors *)
  525.     CatSend(Nul3String+HGS+CHR($A),26);
  526.     MainMenu;
  527. END; (* HgSelect *)
  528.  
  529. (*▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓*)
  530. PROCEDURE SetFreq;
  531. (* Get frequency, build BCD Hex string for use in CatSend Subroutine *)
  532.  
  533. VAR
  534.     FreqString,LSDFreq,FreqSet : STRING[10];
  535.     MHzString,KHzString : STRING[10];
  536.     FreqInt : STRING[8];
  537.     FreqTrans : STRING;
  538.     FreqTune : REAL;
  539.     DotPos,Result,BCDIn,MHz,KHz,Hz : INTEGER;
  540.  
  541. BEGIN (* SetFreq *)
  542.     FreqString := '';                        (* Initialize variables *)
  543.     MHzString  := '';
  544.     KHzString  := '';
  545.     FreqTune   := 0.0;
  546.     FreqInt    := '';
  547.     LSDFreq    := '';
  548.     FreqSet    := '';
  549.     DotPos     := 0;
  550.     TEXTCOLOR(DFG);
  551.     TEXTBACKGROUND(DBG);                     (* Default screen colors *)
  552.     WINDOW(1,1,80,5);
  553.     PrMessage('           Set Frequency Screen            ',4);
  554.     WINDOW(2,6,79,23);
  555.     CLRSCR;
  556.     (* Display headings & draw `Operating Frequency' box *)
  557.     TEXTCOLOR(RFG);
  558.     TEXTBACKGROUND(DBG);                     (* Requested parameter colors *)
  559.     GOTOXY(56,1); WRITE('Operating Frequency');
  560.     PrBox;                                   (* Draw `Op Freq' box *)
  561.     IF SetSel THEN PrBandLimits;             (* Display band limits table *)
  562.     (* Prompt for desired frequency *)
  563.     TEXTCOLOR(DFG);
  564.     TEXTBACKGROUND(DBG);                     (* Default screen colors *)
  565.     GOTOXY(11,3); WRITE('Enter desired frequency.');
  566.     GOTOXY(36,3); WRITE(CHR(198));
  567.     FOR Index := 1 TO 18 DO
  568.         WRITE(CHR(205));
  569.     WRITE(CHR(16));
  570.     GOTOXY(69,3); WRITE('MHz.');
  571.     IF SetSel THEN BEGIN
  572.         TEXTCOLOR(RFG);
  573.         TEXTBACKGROUND(DBG);                 (* Requested parameter colors *)
  574.         GOTOXY(59,3); WRITE('         ');
  575.         GOTOXY(59,3);
  576.         READLN(FreqString);
  577.     END
  578.     ELSE FreqString := ('145.03075');
  579.     VAL(FreqString,FreqTune,Result);         (* Freq is REAL number *)
  580.     CheckFreq(FreqTune);
  581.     IF NOT FreqErrorFlag THEN BEGIN
  582.         GOTOXY(57,3);                        (* Set up `Op Freq' box *)
  583.         WRITE(FreqTune:10:5);                (* Display Freq in box *)
  584.         (* Pad Freq with leading and trailing zeros, if necessary *)
  585.         DotPos := Pos('.',FreqString);
  586.         DELETE(FreqString,DotPos,1);
  587.         IF DotPos = 0 THEN DotPos := LENGTH(FreqString) + 1;
  588.         FreqInt := MultString(4 - DotPos,'0')
  589.             + FreqString + MultString(8 - LENGTH(FreqInt),'0');
  590.         LSDFreq := MakeLSDMSD(FreqInt,8);
  591.         FreqSet := FreqParm(LSDFreq,8);
  592.         IF NOT SetSel THEN BEGIN
  593.             GOTOXY(19,12); WRITE(LENGTH(FreqString),'  Positions.');
  594.             GOTOXY(10,13); WRITE(FreqTune:10:5,'  MHz. (FreqTune)');
  595.             GOTOXY(12,14); WRITE(FreqInt,'  Normal BCD (FreqInt)');
  596.             GOTOXY(12,15); WRITE(LSDFreq,'  Inverted BCD (LSDFreq)');
  597.             GOTOXY(13,16); WRITE(COPY(FreqSet,1,1));
  598.             GOTOXY(15,16); WRITE(COPY(FreqSet,2,1));
  599.             GOTOXY(17,16); WRITE(COPY(FreqSet,3,1));
  600.             GOTOXY(19,16); WRITE(COPY(FreqSet,4,1));
  601.             GOTOXY(22,16); WRITE('BCD string LSD->MSD (FreqSet)');
  602.             Pause;
  603.         END; (* NOT SetSel *)
  604.     (* Send the Frequency to 767 *)
  605.     CatSend(MultString(4,Nul) + CHR(9),5);   (* Turn off Mem mode 1st *)
  606.     CatSend(FreqSet + CHR(8),5);             (* Set the frequency *)
  607.     END; (* IF NOT *)
  608.     MainMenu;
  609. END; (* SetFreq *)
  610.  
  611. (*▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓*)
  612. PROCEDURE VFOMRSelect;
  613. (* Select between VFOs and Memory *)
  614.  
  615. VAR
  616.     VMS,VMSel : CHAR;
  617.  
  618. BEGIN (* VFOMRSelect *)
  619.     VMS := CHR(0);                           (* Initialize variables *)
  620.     TEXTCOLOR(DFG);
  621.     TEXTBACKGROUND(DBG);                     (* Default screen colors *)
  622.     WINDOW(1,1,80,5);
  623.     PrMessage('Select VFO/Memory Screen',4);
  624.     WINDOW(2,6,79,23);
  625.     CLRSCR;
  626.     (* Display headings & draw `Operating Frequency' box *)
  627.     TEXTCOLOR(RFG);
  628.     TEXTBACKGROUND(DBG);                     (* Requested parameter colors *)
  629.     GOTOXY(57,1); WRITE('     Selected      ');
  630.     PrBox;
  631.     (* Prompt for VFO A, VFO B or Memory *)
  632.     GOTOXY(11,1); WRITE('A=VFO A, B=VFO B, M=Memory');
  633.     GOTOXY(11,3); WRITE('Enter A, B, or M.');
  634.     GOTOXY(29,3); WRITE(CHR(198));
  635.     FOR Index := 1 TO 25 DO
  636.         Write(CHR(205));
  637.     WRITE(CHR(16));
  638.     IF SetSel THEN BEGIN
  639.         TEXTCOLOR(RFG);
  640.         TEXTBACKGROUND(DBG);                 (* Requested parameter colors *)
  641.         GOTOXY(60,3); WRITE('     ?    ');
  642.         GOTOXY(65,3);
  643.         VMSel := UPCASE(ReadKey);
  644.         CASE VMSel OF
  645.             'A' : BEGIN
  646.                   VMS := CHR(0);
  647.                   GOTOXY(60,3); WRITE('  VFO  A  ');
  648.                   END;
  649.             'B' : BEGIN
  650.                   VMS := CHR(1);
  651.                   GOTOXY(60,3); WRITE('  VFO  B  ');
  652.                   END;
  653.             'M' : BEGIN
  654.                   VMS := CHR(2);
  655.                   GOTOXY(60,3); WRITE('  MEMORY  ');
  656.                   END;
  657.         END; (* CASE *)
  658.     END; (* IF SetSel *)
  659.     TEXTCOLOR(DFG);
  660.     TEXTBACKGROUND(DBG);                     (* Default screen colors *)
  661.     CatSend(Nul3String+VMS+CHR(9),5);        (* Set VFOs or Mem *)
  662.     MainMenu;
  663. END; (* VFOMRSelect *)
  664.  
  665. (*▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓*)
  666. PROCEDURE MemSelect;
  667. (* Select memory channel *)
  668.  
  669. VAR
  670.     MemCh,MCH : CHAR;
  671.     MemAddr   : INTEGER;
  672.     MemFreq   : REAL;
  673.  
  674. BEGIN (* MemSelect *)
  675.     TEXTCOLOR(DFG);
  676.     TEXTBACKGROUND(DBG);                     (* Default screen colors *)
  677.     WINDOW(1,1,80,5);
  678.     PrMessage('Select Memory Screen',4);
  679.     WINDOW(2,6,79,23);
  680.     CLRSCR;
  681.     PrMessage('Current Memory Parameters ',5); (* Display Mem Chan headings *)
  682.     GOTOXY(13,6); WRITE(' Channel');
  683.     GOTOXY(29,6); WRITE('Frequency');
  684.     GOTOXY(48,6); WRITE('Mode');
  685.     GOTOXY(62,6); WRITE('Tone');
  686.     PrLines('H',6,75,12,12,SBA,DBG,196);     (* Display divider line *)
  687.     TEXTCOLOR(RFG);
  688.     TEXTBACKGROUND(DBG);                     (* Requested parameter colors *)
  689.     FOR Index := 0 TO 9 DO BEGIN             (* Display Memory channel numbers *)
  690.         GOTOXY(12,Index + 8);
  691.         WRITE('Memory 0');
  692.         WRITE(Index);
  693.     END;
  694.     PrMem(27,86,8,27,49,59); (* Display channel data from Update stream *)
  695.     (* Display headings & draw `Selected Memory' box *)
  696.     TEXTCOLOR(RFG);
  697.     TEXTBACKGROUND(DBG);                     (* Requested parameter colors *)
  698.     GOTOXY(58,1); WRITE('Selected Memory');
  699.     PrBox;                                   (* Draw `Memory Select' box *)
  700.     (* Prompt for desired memory number *)
  701.     GOTOXY(11,3); WRITE('Enter desired memory.');
  702.     GOTOXY(33,3); WRITE(CHR(198));
  703.     FOR Index := 1 TO 21 DO
  704.         WRITE(CHR(205)); WRITE(CHR(16));
  705.     GOTOXY(60,3); WRITE('Channel');
  706.     IF SetSel THEN
  707.     TEXTCOLOR(RFG);
  708.     TEXTBACKGROUND(DBG);                     (* Requested parameter colors *)
  709.     GOTOXY(69,3); WRITE('  ');
  710.     REPEAT
  711.         MemCh := (ReadKey);
  712.     UNTIL MemCh IN [#48..#57];
  713.     (* Display Channel # in `Selected Memory' box *)
  714.     GOTOXY(69,3); WRITE('0',MemCh);
  715.     MCH := CHR((ORD(MemCh) - 48));           (* Compute Bin value *)
  716.     MemAddr := (ORD(MemCh) - 48) * 6 + 27;   (* Compute Addr in Update stream *)
  717.     GOTOXY(59,3); WRITE('            ');
  718.     (* Display Memory Channel Frequency in `Selected Memory' box *)
  719.     PrFreq(Update,MemAddr,59,3); (* Display Mem Freq from Update stream *)
  720.     CatSend(Nul3String+MCH+CHR($A),8);       (* Set the channel *)
  721.     CatSend(Nul3String+CHR(2)+CHR(9),5);     (* Switch mode to MR *)
  722.     MainMenu;
  723. END; (* MemSelect *)
  724.  
  725. (*▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓*)
  726. PROCEDURE ModeSelect (* Select operating Mode *);
  727.  
  728. VAR
  729.     ModeSel : CHAR;
  730.     Mode    : STRING;
  731.  
  732. BEGIN (* ModeSelect *)
  733.     TEXTCOLOR(DFG);
  734.     TEXTBACKGROUND(DBG);                     (* Default screen colors *)
  735.     WINDOW(1,1,80,5);
  736.     PrMessage('Select Mode Screen',4);
  737.     WINDOW(2,6,79,23);
  738.     CLRSCR;
  739.     (* Display headings & draw `Mode' box *)
  740.     TEXTCOLOR(RFG);
  741.     TEXTBACKGROUND(DBG);                     (* Requested parameter colors *)
  742.     GOTOXY(58,1); WRITE('Selected Memory');
  743.     GOTOXY(56,1); WRITE('       Mode        ');
  744.     PrBox;                                   (* Draw `Mode Select' box *)
  745.     (* Prompt for VFO A, VFO B or Memory *)
  746.     GOTOXY(11,1); WRITE('L=LSB, U=USB, C=CW, A=AM, F=FM, K=FSK');
  747.     GOTOXY(11,3); WRITE('Enter L, U, C, A, F, or K.');
  748.     GOTOXY(38,3); WRITE(CHR(198));
  749.     FOR Index := 1 to 16 DO
  750.         WRITE(CHR(205));
  751.     WRITE(CHR(16));
  752.     IF SetSel THEN BEGIN
  753.         TEXTCOLOR(RFG);
  754.         TEXTBACKGROUND(DBG);                 (* Requested parameter colors *)
  755.         GOTOXY(60,3); WRITE ('     ?    ');
  756.         GOTOXY(65,3);
  757.         REPEAT
  758.             ModeSel := UPCASE(ReadKey);
  759.             CASE ModeSel OF
  760.                 'L' : BEGIN
  761.                       Mode := CHR($10);
  762.                       GOTOXY(60,3); WRITE(' Lower SB ');
  763.                       END;
  764.                 'U' : BEGIN
  765.                       Mode := CHR($11);
  766.                       GOTOXY(60,3); WRITE(' Upper SB ');
  767.                       END;
  768.                 'C' : BEGIN
  769.                       Mode := CHR($12);
  770.                       GOTOXY(60,3); WRITE('    CW    ');
  771.                       END;
  772.                 'A' : BEGIN
  773.                       Mode := CHR($13);
  774.                       GOTOXY(60,3); WRITE('    AM    ');
  775.                       END;
  776.                 'F' : BEGIN
  777.                       Mode := CHR($14);
  778.                       GOTOXY(60,3); WRITE('    FM    ');
  779.                       END;
  780.                 'K' : BEGIN
  781.                       Mode := CHR($15);
  782.                       GOTOXY(60,3); WRITE('    FSK   ');
  783.                       END;
  784.             END; (* Case *)
  785.         UNTIL (ModeSel = 'L') OR (ModeSel = 'U') OR (ModeSel = 'C') OR
  786.               (ModeSel = 'A') OR (ModeSel = 'F') OR (ModeSel = 'K');
  787.         TEXTCOLOR(DFG);
  788.         TEXTBACKGROUND(DBG);                 (* Default screen colors *)
  789.         CatSend(Nul3String+Mode+CHR($A),8);  (* Set the Mode *)
  790.         MainMenu;
  791.     END; (* IF SetSel *)
  792. END; (* ModeSelect *)
  793.  
  794. (*▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓*)
  795. PROCEDURE ProgStep;
  796. (* Set step size for Programmed frequency Step Up/Down *)
  797.  
  798. VAR
  799.     StepSet, StepFreq   : STRING[6];
  800.     LSDStep             : STRING[6];
  801.     StepInt             : STRING[4];
  802.     StepChr             : STRING;
  803.     Result,BCDin,DotPos : INTEGER;
  804.     TuneStep            : REAL;
  805.  
  806. BEGIN (* ProgStep *)
  807.     LSDStep  := '';
  808.     StepFreq := '';
  809.     StepInt  := '';
  810.     StepSet  := '';
  811.     TEXTCOLOR(DFG);
  812.     TEXTBACKGROUND(DBG);                     (* Default screen colors *)
  813.     WINDOW(1,1,80,5);
  814.     IF DownFlag THEN
  815.         PrMessage('Set Increment for Frequency Step DOWN',4)
  816.     ELSE
  817.         PrMessage('Set Increment for Frequency Step UP',4);
  818.     WINDOW(2,6,79,23);
  819.     CLRSCR;
  820.     (* Display headings & draw `Programmed Step Size' box *)
  821.     TEXTCOLOR(RFG);
  822.     TEXTBACKGROUND(DBG);                     (* Requested parameter colors *)
  823.     GOTOXY(56,1); WRITE('Programmed Step Size');
  824.     PrBox;                                   (* Draw `Step Size' box *)
  825.     GOTOXY(11,3); WRITE('Enter desired Step Size.');
  826.     GOTOXY(36,3); WRITE(CHR(198));
  827.     FOR Index := 1 TO 18 DO
  828.         WRITE(CHR(205));
  829.     WRITE(CHR(16));
  830.     GOTOXY(67,3); WRITE('KHz.');
  831.     IF SetSel THEN BEGIN
  832.         TEXTCOLOR(RFG);
  833.         TEXTBACKGROUND(DBG);             (* Requested parameter colors *)
  834.         GOTOXY(61,3); WRITE('     ');
  835.         GOTOXY(61,3); READLN(StepFreq);
  836.     END
  837.     ELSE StepFreq := '12.34';
  838.     VAL(StepFreq,TuneStep,Result);
  839. {   IF (StepFreq < 0) OR (StepFreq > 99) THEN
  840.         ErrorAlarm(FreqErr$, 10, 58): GOTO GetStep }
  841.     (* Display Step in `Programmed Step Size' box *)
  842.     GOTOXY(61,3); WRITE(TuneStep:4:2);
  843.     DotPos := Pos('.',StepFreq);
  844.     DELETE(StepFreq,DotPos,1);
  845.     IF DotPos = 0 THEN
  846.         DotPos := LENGTH(StepFreq) +1;
  847.     (* Pad StepFreq with appropriate leading zeros *)
  848.     CASE DotPos OF
  849.         1 : StepInt := '00' + StepFreq;
  850.         2 : StepInt := '0'  + StepFreq;
  851.         3 : StepInt := StepFreq;
  852.     END; (* CASE *)
  853.     CASE LENGTH(StepInt) OF
  854.         1 : StepInt := StepInt + '000';
  855.         2 : StepInt := StepInt + '00';
  856.         3 : StepInt := StepInt + '0';
  857.     END; (* CASE *)
  858.     (* Construct 4 byte LSDStep string (LSD -> MSD) *)
  859.     Index := 4;
  860.     WHILE Index <> 0 DO BEGIN
  861.         LSDStep := LSDStep + COPY(StepInt,Index - 1,2);
  862.         Index := Index - 2;
  863.     END;
  864.     (* Convert LSDStep to 2 hex bytes *)
  865.     Index := 1;
  866.     WHILE Index < 4 DO BEGIN
  867.         StepChr := COPY(LSDStep,Index,2);
  868.         VAL(StepChr,BCDin,Result);
  869.         Index := Index + 2;
  870.         StepSet := StepSet + Translate(BCDin);
  871.     END; (* WHILE Index *)
  872.     IF SetSel = FALSE THEN BEGIN
  873.         GOTOXY(13,12); WRITE(LENGTH(StepFreq),'  Positions.');
  874.         GOTOXY(10,13); WRITE(TuneStep:4:2,' KHz.');
  875.         GOTOXY(10,14); WRITE(StepInt,'  Normal BCD');
  876.         GOTOXY(10,15); WRITE(LSDStep,'  Inverted BCD');
  877.         GOTOXY(11,16); WRITE(COPY(StepSet,1,1));
  878.         GOTOXY(13,16); WRITE(COPY(StepSet,2,1));
  879.         GOTOXY(16,16); WRITE('StepSet binary string.');
  880.         Pause;
  881.     END; (* IF SetSel *)
  882.     CatSend(Nul3String+CHR(0)+CHR(9),5);     (* First turn off Mem mode *)
  883.     IF DownFlag THEN
  884.         CatSend(CHR(0)+CHR(0)+StepSet+CHR(5),5)  (* Set step DN *)
  885.     ELSE
  886.         CatSend(CHR(0)+CHR(0)+StepSet+CHR(4),5); (* Set step UP *)
  887.     MainMenu;
  888. END; (* ProgStep *)
  889.  
  890. (*▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓*)
  891. PROCEDURE CTCSSToneSet;
  892.  
  893. VAR
  894.     ToneSet,ToneFreq : STRING[8];
  895.     Tone             : REAL;
  896.     Result           : INTEGER;
  897.  
  898. BEGIN (* CTCSSToneSet *)
  899.     ToneSet := ''; ToneFreq := '';           (* Initialize collection strings *)
  900.     TEXTCOLOR(DFG);
  901.     TEXTBACKGROUND(DBG);                     (* Default screen colors *)
  902.     WINDOW(1,1,80,5);
  903.     PrMessage('CTCSS Tones Screen',4);
  904.     WINDOW(2,6,79,23);
  905.     CLRSCR;
  906.     TEXTCOLOR(RFG);
  907.     TEXTBACKGROUND(DBG);                     (* Requested parameter colors *)
  908.     GOTOXY(56,1); WRITE('CTCSS Tone Frequency'); (* Display headings *)
  909.     PrBox;                                   (* Draw `CTCSS Tone' box *)
  910.     (* Display CTCSS valid frequencies table *)
  911.     GOTOXY(17,6); WRITE('67.0           123.0          186.2         C77.0');
  912.     GOTOXY(17,7); WRITE('71.9           127.3          192.8         C79.7');
  913.     GOTOXY(17,8); WRITE('77.0           131.8          203.5         C82.5');
  914.     GOTOXY(17,9); WRITE('82.5           136.5          210.7         C85.4');
  915.     GOTOXY(17,10); WRITE('88.5           141.3          218.1         C88.5');
  916.     GOTOXY(17,11); WRITE('94.8           146.2          225.7         C91.5');
  917.     GOTOXY(17,12); WRITE('100.0          151.4          233.6');
  918.     GOTOXY(17,13); WRITE('103.5          156.7          241.8');
  919.     GOTOXY(17,14); WRITE('107.2          162.2          250.3     `C'' tones have');
  920.     GOTOXY(17,15); WRITE('110.9          167.9          C67.0       high Q (80)');
  921.     GOTOXY(17,16); WRITE('114.8          173.8          C71.9');
  922.     GOTOXY(17,17); WRITE('118.8          179.9          C74.7');
  923.     (* Prompt for desired frequency *)
  924.     GOTOXY(7,3); WRITE('Enter CTCSS Tone from table.');
  925.     GOTOXY(36,3); WRITE(CHR(198));
  926.     FOR Index := 1 TO 18 DO
  927.         WRITE(CHR(205));
  928.     WRITE(CHR(16));
  929.     TEXTCOLOR(DFG);
  930.     TEXTBACKGROUND(DBG);                     (* Default screen colors *)
  931.     GOTOXY(68,3); WRITE ('Hz.');
  932.     IF SetSel THEN BEGIN
  933.         TEXTCOLOR(RFG);
  934.         TEXTBACKGROUND(DBG);                 (* Requested parameter colors *)
  935.         GOTOXY(61,3); WRITE('     ');
  936.         GOTOXY(61,3); READLN(ToneFreq);
  937.     END
  938.     ELSE ToneFreq := ('131.8');
  939.     VAL(ToneFreq,Tone,Result);
  940. {   IF (Tone < 67) OR (Tone > 250.3) THEN
  941.         ErrorAlarm(FreqErr$, 8, 58): GOTO GetTone }
  942.     (* Display Tone Frequency in `CTCSS Tone Frequency' box *)
  943.     GOTOXY(61,3); WRITE(Tone:3:1);
  944.     (* Send instruction to 767 *)
  945.     (* Set to zero for now, need routine here *)
  946. {   ToneSet := CHR(0)+CHR(0)+CHR(0)+CHR(0)+CHR($C);
  947.     CatSend(ToneSet,5);                      (* Set the tone frequency *)
  948.     Pause; }
  949.     PrFKeys;
  950.     MainMenu;
  951. END; (* CTCSSToneSet *)
  952.  
  953. (*▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓*)
  954. PROCEDURE WhatWasThat(Param : String5; Col,Row : INTEGER);
  955. (* Display Instruction/Echo as sent from computer/FT-767 *)
  956.  
  957. VAR
  958.     MSN,Result : INTEGER;
  959.  
  960. BEGIN (* WhatWasThat *)
  961.     TEXTCOLOR(SFG);
  962.     TEXTBACKGROUND(DBG);                     (* Returned status colors *)
  963.     GOTOXY(Col,Row);
  964.     FOR Index := 1 TO LENGTH(Param) DO BEGIN
  965.         VAL(Param[Index],MSN,Result);
  966.         WriteHex(ORD(Param[Index]));
  967.         WRITE(' ');                          (* Display as BCD Hex values *)
  968.     END;
  969. END; (* WhatWasThat *)
  970.  
  971. (*▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓*)
  972. PROCEDURE CatSend(Param : String5; StatusUpdateSize : INTEGER);
  973. (* Send Instruction string to 767, get Echo & send ACKnowledge *)
  974.  
  975. VAR
  976.     Temp  : STRING[86];
  977.     Ch    : CHAR;
  978.  
  979. BEGIN (* CatSend *)
  980.     Inst := Param;                           (* Inform Global variable *)
  981.     Echo := '     ';
  982.     ClockFlag := FALSE;                      (* No clock during Comm *)
  983.     SendString(Param,15);                    (* Send Instruction to 767 *)
  984. (* Get 5 character echo from 767, if a match, send ACK string to 767 *)
  985.     IF Test THEN
  986.         FOR Index := 1 TO 5 DO
  987.     Echo[Index] := Inst[Index]               (* Simulate 767 echo *)
  988.     ELSE FOR Index := 1 TO 5 DO
  989.         Echo[Index] := InChar;               (* Get real echo from 767 *)
  990.     IF (Echo = Inst) AND (NOT Test) THEN BEGIN
  991.         (* If Test was TRUE, UPDATE.DAT provided a simulated Update *)
  992.         SendString(AckString,StatusUpdateSize); (* Echo matches, send ACK *)
  993.         FOR Index := 1 TO StatusUpdateSize DO
  994.             Lifo[Index] := InChar;           (* Get real Update from 767 *)
  995.             (* Update stream from 767 is sent last byte first *)
  996.         Temp := Fifo(Lifo);                  (* Convert LIFO to FIFO *)
  997.         Update := Temp;
  998.     END (* IF Echo *)
  999.     ELSE IF Echo <> Inst THEN BEGIN
  1000.         WINDOW(2,6,79,23);
  1001.         ErrorAlarm(CmdErr,0,7);              (* Issue command error warning *)
  1002.         Warble(3000,2400);
  1003.         GOTOXY(31,9);  WRITE('Inst:');
  1004.         GOTOXY(31,10); WRITE('Echo:');
  1005.         WhatWasThat(Inst,38,9);
  1006.         WhatWasThat(Echo,38,10);
  1007.         FlushBuffer;                         (* Clear buffer of trash *)
  1008.         Pause;
  1009.         WINDOW(2,6,79,23);
  1010.         CLRSCR;
  1011.         PrFKeys;
  1012.     END; (* ELSE IF *)
  1013.     ClockFlag := TRUE;                       (* Reinstate RTC *)
  1014. END; (* CatSend *)
  1015.  
  1016. (*▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓*)
  1017. PROCEDURE StatusUpdate(Param : String86);
  1018. (* Display all radio parameters *)
  1019.  
  1020. BEGIN
  1021.     PrFrame(1,80,1,24);                      (* Draw main frame *)
  1022.     TEXTCOLOR(DFG);                          (* Display headers *)
  1023.     TEXTBACKGROUND(DBG);                     (* Default screen colors *)
  1024.     WINDOW(1,1,80,5);
  1025.     PrMessage('Status Update Screen', 4);
  1026.     GOTOXY(3,2); WRITE('LSD        MSD ');
  1027.     WhatWasThat(Inst,3,3);                   (* Display Instr as sent *)
  1028.     WhatWasThat(Echo,3,4);                   (* Display Echo as received *)
  1029.     WINDOW(2,6,79,23);
  1030.     CLRSCR;
  1031.     PrRule; (* Draw inside ruling lines for status screen *)
  1032.     ScreenWrite(CHR(209),18,1,SBA);          (* Dbl/sing tee, top *)
  1033.     PrLines('V',18,0,2,4,SBA,DBG,179);       (* Sing V left side *)
  1034.     ScreenWrite(CHR(207),18,5,SBA);          (* Dbl/sing tee, bot *)
  1035.     ScreenWrite(CHR(209),63,1,SBA);          (* Dbl/sing tee, top *)
  1036.     PrLines('V',63,0,2,4,SBA,DBG,179);       (* Sing V right side *)
  1037.     ScreenWrite(CHR(207),63,5,SBA);          (* Dbl/sing tee, bot *)
  1038.     PrLines('H',3,50,7,0,SBA,DBG,196);       (* Sing H line, mid top *)
  1039.     PrLines('H',3,50,9,0,SBA,DBG,196);       (* Sing H line, mid top *)
  1040.     PrLines('H',3,50,11,0,SBA,DBG,196);      (* Sing H line, mid top *)
  1041.     ScreenWrite(CHR(199),1,13,SBA);          (* Dbl/sing tee, left *)
  1042.     PrLines('H',2,79,13,0,SBA,DBG,196);      (* Sing H line, midscreen *)
  1043.     ScreenWrite(CHR(182),80,13,SBA);         (* Dbl/sing tee, right *)
  1044.     ScreenWrite(CHR(209),52,5,SBA);          (* Dbl/sing tee, top *)
  1045.     PrLines('V',52,0,6,12,SBA,DBG,179);      (* Sing V midscreen, top *)
  1046.     ScreenWrite(CHR(197),52,13,SBA);         (* Sing cross *)
  1047.     PrLines('V',52,0,14,23,SBA,DBG,179);     (* Sing V midscreen, bot *)
  1048.     ScreenWrite(CHR(207),52,24,SBA);         (* Dbl/sing tee, bot *)
  1049.     PrLines('H',54,78,15,0,SBA,DBG,196);     (* Sing H line, mid bot *)
  1050.     (* UPPER LEFT QUADRANT *)
  1051.     TEXTCOLOR(DFG);                          (* Display headings *)
  1052.     TEXTBACKGROUND(DBG);                     (* Default screen colors *)
  1053.     GOTOXY(3,1); WRITE ('Function');
  1054.     GOTOXY(16,1); WRITE ('Frequency');
  1055.     GOTOXY(31,1); WRITE ('Mode');
  1056.     GOTOXY(42,1); WRITE ('Tone');
  1057.     TEXTCOLOR(PFG);
  1058.     TEXTBACKGROUND(DBG);                     (* Parameter screen colors *)
  1059.     GOTOXY(2,7); WRITE ('Clarifier');
  1060.     GOTOXY(4,3); WRITE ('VFO A');
  1061.     GOTOXY(4,5); WRITE ('VFO B');
  1062.     (* Display returned status for VFO A, VFO B, Clarifier *)
  1063.     IF LENGTH(Update) >= 26 THEN BEGIN
  1064.         PrFreq(Param,15,13,3);               (* VFO A *)
  1065.         PrCTCSS(Param,19,39,3);
  1066.         PrMode(Param,20,31,3);
  1067.         PrFreq(Param,21,13,5);              (* VFO B *)
  1068.         PrCTCSS(Param,25,39,5);
  1069.         PrMode(Param,26,31,5);
  1070.         PrFreq(Param,9,13,7);               (* Clarifier *)
  1071.         PrCTCSS(Param,13,39,7);
  1072.         PrMode(Param,14,31,7);
  1073.     END; (* IF LENGTH *)
  1074.     (* UPPER RIGHT QUADRANT *)
  1075.     TEXTCOLOR(PFG);
  1076.     TEXTBACKGROUND(DBG);                     (* Parameter screen colors *)
  1077.     GOTOXY(56,1); WRITE('Operating Frequency');
  1078.     TEXTCOLOR(DFG);                          (* Display headings *)
  1079.     TEXTBACKGROUND(DBG);                     (* Default screen colors *)
  1080.     PrBox;                                   (* Draw `Op Freq' box *)
  1081.     GOTOXY(53,5);
  1082.     FOR Index := 1 to 7 DO
  1083.         WRITE(CHR(205));
  1084.     WRITE(' Selected ');
  1085.     FOR Index := 1 to 8 DO
  1086.         WRITE(CHR(205));
  1087.     TEXTCOLOR(PFG);
  1088.     TEXTBACKGROUND(DBG);                     (* Parameter screen colors *)
  1089.     GOTOXY(54,6); WRITE('Mode');
  1090.     GOTOXY(63,6); WRITE('Tone');
  1091.     GOTOXY(71,6); WRITE('Memory');
  1092.     (* Display returned status for Op Freq, selected mode, tone, memory *)
  1093.     PrFreq(Param,2,59,3);                    (* Op Freq *)
  1094.     IF LENGTH(Update) >= 8 THEN BEGIN
  1095.         PrCTCSS(Param,6,60,7);               (* Tone *)
  1096.         PrMode(Param,7,55,7);                (* Mode *)
  1097.         TEXTCOLOR(SFG);
  1098.         TEXTBACKGROUND(DBG);                 (* Returned status colors *)
  1099.         GOTOXY(73,7); WRITE('0');            (* Memory *)
  1100.         WRITE(Bin2BCDHex(ORD(Param[8])));
  1101.         TEXTCOLOR(DFG);
  1102.         TEXTBACKGROUND(DBG);                 (* Default screen colors *)
  1103.     END; (* IF LENGTH *)
  1104.     (* LOWER LEFT QUADRANT *)
  1105.     TEXTCOLOR(PFG);                          (* Display headings *)
  1106.     TEXTBACKGROUND(DBG);                     (* Parameter screen colors *)
  1107.     FOR Index := 0 TO 9 DO BEGIN
  1108.         GOTOXY(2,Index + 9); WRITE('Memory 0');
  1109.         WRITE(Index);                        (* Display memory number *)
  1110.     END; (* FOR Index *)
  1111.     (* Display returned status for all memories *)
  1112.     IF LENGTH(Update) = 86 THEN BEGIN
  1113.         PrFreq(Param,27,13,9);
  1114.         PrCTCSS(Param,31,39,9);
  1115.         PrMode(Param,32,31,9);
  1116.         PrFreq(Param,33,13,10);
  1117.         PrCTCSS(Param,37,39,10);
  1118.         PrMode(Param,38,31,10);
  1119.         PrFreq(Param,39,13,11);
  1120.         PrCTCSS(Param,43,39,11);
  1121.         PrMode(Param,44,31,11);
  1122.         PrFreq(Param,45,13,12);
  1123.         PrCTCSS(Param,49,39,12);
  1124.         PrMode(Param,50,31,12);
  1125.         PrFreq(Param,51,13,13);
  1126.         PrCTCSS(Param,55,39,13);
  1127.         PrMode(Param,56,31,13);
  1128.         PrFreq(Param,57,13,14);
  1129.         PrCTCSS(Param,61,39,14);
  1130.         PrMode(Param,62,31,14);
  1131.         PrFreq(Param,63,13,15);
  1132.         PrCTCSS(Param,67,39,15);
  1133.         PrMode(Param,68,31,15);
  1134.         PrFreq(Param,69,13,16);
  1135.         PrCTCSS(Param,73,39,16);
  1136.         PrMode(Param,74,31,16);
  1137.         PrFreq(Param,75,13,17);
  1138.         PrCTCSS(Param,79,39,17);
  1139.         PrMode(Param,80,31,17);
  1140.         PrFreq(Param,81,13,18);
  1141.         PrCTCSS(Param,85,39,18);
  1142.         PrMode(Param,86,31,18);
  1143.     END; (* IF LENGTH *)
  1144.     (* LOWER RIGHT QUADRANT *)
  1145.     GOTOXY(54,9); WRITE('Status Byte Information');
  1146.     TEXTCOLOR(PFG);                          (* Display headings *)
  1147.     TEXTBACKGROUND(DBG);                     (* Parameter screen colors *)
  1148.     GOTOXY(53,11); WRITE('PTT:        ');
  1149.     GOTOXY(53,12); WRITE('Ham/Gen:    ');
  1150.     GOTOXY(53,13); WRITE('Transmit:   ');
  1151.     GOTOXY(53,14); WRITE('Split:      ');
  1152.     GOTOXY(53,15); WRITE('VFO:        ');
  1153.     GOTOXY(53,16); WRITE('Mem Recall: ');
  1154.     GOTOXY(53,17); WRITE('Clarifier:  ');
  1155.     GOTOXY(53,18); WRITE('Cat System: ');
  1156.     PrStatusByte;                            (* Display decoded status byte information *)
  1157. END; (* StatusUpdate *)
  1158.  
  1159. (*▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓*)
  1160. PROCEDURE TurnCatOn; (* Activate Computer Aided Tuning system *)
  1161.  
  1162. BEGIN (* TurnCatOn *)
  1163.     CAT := TRUE;
  1164.     CatSend(CatOn,86);
  1165.     ScreenWrite('  CAT is  ON  ',65,4,CLA);
  1166. END; (* TurnCatOn *)
  1167.  
  1168. (*▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓*)
  1169. PROCEDURE TurnCatOff; (* Deactivate Computer Aided Tuning system *)
  1170.  
  1171. BEGIN (* TurnCatOff *)
  1172.     CAT := FALSE;
  1173.     CatSend(CatOff,86);
  1174.     ScreenWrite('  CAT is OFF  ',65,4,COA);
  1175. END; (* TurnCatOff *)
  1176.  
  1177. (*▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓*)
  1178. PROCEDURE CheckStatus(Inst : String5);
  1179. (* No change to radio, just request current status *)
  1180.  
  1181. BEGIN (* CheckStatus *)
  1182.     CatSend(Inst,86);
  1183.     StatusUpdate(Update);
  1184.     Pause;
  1185.     PrFKeys;
  1186.     MainMenu;
  1187. END; (* CheckStatus *)
  1188.  
  1189. (*▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓*)
  1190. PROCEDURE QuickStat;
  1191. (* Do a quick update in upper left box *)
  1192.  
  1193. VAR
  1194.     ModePos : INTEGER;
  1195.  
  1196. BEGIN (* QuickStat *)
  1197.     WINDOW(1,1,20,5);
  1198.     (* Display upper left box headings *)
  1199.     TEXTCOLOR(PFG);
  1200.     TEXTBACKGROUND(Blue);                    (* Parameter screen colors *)
  1201.     GOTOXY(3,2); WRITE('Freq:');
  1202.     TEXTCOLOR(SFG);
  1203.     TEXTBACKGROUND(Blue);                    (* Special status colors *)
  1204.     PrFreq(Update,2,8,2);                    (* Operating Freq *)
  1205.     (* Display selected Memory/VFO, Mode status in upper left box *)
  1206.     TEXTCOLOR(SFG);
  1207.     TEXTBACKGROUND(Blue);                    (* Special status colors *)
  1208.     PrFreq(Update,2,8,2);                    (* Operating Freq *)
  1209.   {  GOTOXY(3,14);
  1210.     IF (ORD(Update[1])) AND ($08) <> 0 THEN BEGIN (* Mask off SPLIT bit *)
  1211.         TEXTCOLOR(SFG +16);
  1212.         WRITE('s');
  1213.     END (* IF *)
  1214.     ELSE WRITE(' ');}
  1215.     TEXTCOLOR(PFG);
  1216.     TEXTBACKGROUND(Blue);                    (* Special param colors *)
  1217.     GOTOXY(3,3); WRITE('Active: ');
  1218.     TEXTCOLOR(SFG);
  1219.     TEXTBACKGROUND(Blue);                    (* Special status colors *)
  1220.     GOTOXY(11,3);
  1221.     IF (ORD(Update[1])) AND ($20) <> 0 THEN BEGIN (* Mask off MR bit *)
  1222.         WRITE('MEMORY ');
  1223.         ModePos := ORD(Update[8]) *6 +32;    (* Calc selected MR mode *)
  1224.     END (* IF *)
  1225.     ELSE IF (ORD(Update[1])) AND ($10) = 0 THEN BEGIN (* Mask off VFO bit *)
  1226.         WRITE('VFO A ');
  1227.         ModePos := 20;
  1228.     END (* ELSE IF *)
  1229.     ELSE BEGIN
  1230.         WRITE('VFO B ');
  1231.         ModePos := 26;
  1232.     END; (* ELSE *)
  1233.     IF (ORD(Update[1])) AND ($08) <> 0 THEN BEGIN (* Mask off SPLIT bit *)
  1234.         TEXTCOLOR(SFG+16);
  1235.         WRITE(CHR(18));
  1236.     END (* IF *)
  1237.     ELSE IF (ORD(Update[1])) AND ($20) = 0 THEN  (* Mask off MR bit *)
  1238.         WRITE(' ');
  1239.     TEXTCOLOR(PFG);
  1240.     TEXTBACKGROUND(Blue);                    (* Special param colors *)
  1241.     GOTOXY(3,4); WRITE('Mode:          ');
  1242.     TEXTCOLOR(SFG);
  1243.     TEXTBACKGROUND(Blue);                    (* Special status colors *)
  1244.     PrMode(Update,ModePos,13,4);
  1245.     TEXTCOLOR(SFG+16);
  1246.     TEXTBACKGROUND(Blue);                    (* Special status colors *)
  1247.     IF (ORD(Update[1])) AND ($40) <> 0 THEN BEGIN (* Mask off Clar bit *)
  1248.         WRITE(' ',CHR(29));
  1249.     END (* IF *)
  1250.     ELSE WRITE('  ');
  1251.     TEXTCOLOR(DFG);
  1252.     TEXTBACKGROUND(DBG);                     (* Default screen colors *)
  1253. END; (* QuickStat *)
  1254.  
  1255. (*▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓*)
  1256. PROCEDURE MainFrame (* Put up Main Frame for all screens *);
  1257.  
  1258. BEGIN (* MainFrame *)
  1259.     CLRSCR;
  1260.     PrFrame(1,80,1,24);                      (* Draw main frame *)
  1261.     PrFKeys;                                 (* Display Function Key line *)
  1262.     PrMessage(Title,2);                      (* Display headings *)
  1263.     PrMessage(Credit,3);
  1264.     PrMessage('Main Menu',4);
  1265.     PrRule;                                  (* Draw inside ruling lines *)
  1266.     ScreenWrite(CHR(209),18,1,SBA);          (* Dbl/sing tee, top *)
  1267.     PrLines('V',18,0,2,4,SBA,DBG,179);       (* Sing V left side *)
  1268.     ScreenWrite(CHR(207),18,5,SBA);          (* Dbl/sing tee, bot *)
  1269.     ScreenWrite(CHR(209),63,1,SBA);          (* Dbl/sing tee, top *)
  1270.     PrLines('V',63,0,2,4,SBA,DBG,179);       (* Sing V right side *)
  1271.     ScreenWrite(CHR(207),63,5,SBA);          (* Dbl/sing tee, bot *)
  1272. END; (* MainFrame *)
  1273.  
  1274. (*▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓*)
  1275. PROCEDURE MainMenu (* Put up Main Menu for selections *);
  1276.  
  1277. VAR
  1278.     Fk     : BOOLEAN;
  1279.     Choice : CHAR;
  1280.  
  1281. BEGIN (* MainMenu *)
  1282.     TurnCatOff;                              (* Disable CAT between jobs *)
  1283.     WINDOW(1,1,80,5);
  1284.     PrMessage('                 Main Menu                 ',4);
  1285.     {
  1286.     (* Display upper left box headings *)
  1287.     TEXTCOLOR(PFG);
  1288.     TEXTBACKGROUND(Blue);                    (* Parameter screen colors *)
  1289.     GOTOXY(3,2); WRITE('Freq ');
  1290.     TEXTCOLOR(SFG);
  1291.     TEXTBACKGROUND(Blue);                    (* Special status colors *)
  1292.     PrFreq(Update,2,8,2);                    (* Operating Freq *)
  1293.     (* Display selected Memory/VFO, Clarifier status in upper left box *)
  1294.     TEXTCOLOR(SFG);
  1295.     TEXTBACKGROUND(Blue);                    (* Special status colors *)
  1296.     PrFreq(Update,2,8,2);                    (* Operating Freq *)
  1297.     TEXTCOLOR(PFG);
  1298.     TEXTBACKGROUND(Blue);                    (* Special param colors *)
  1299.     GOTOXY(3,3); WRITE('Active: ');
  1300.     TEXTCOLOR(SFG);
  1301.     TEXTBACKGROUND(Blue);                    (* Special status colors *)
  1302.     GOTOXY(11,3);
  1303.     IF (ORD(Update[1])) AND ($20) <> 0 THEN  (* Mask off MR bit *)
  1304.         WRITE('MEMORY ')
  1305.     ELSE WRITE('   VFO ');
  1306.     TEXTCOLOR(PFG);
  1307.     TEXTBACKGROUND(Blue);                    (* Special param colors *)
  1308.     GOTOXY(3,4); WRITE('Clarifier: ');
  1309.     TEXTCOLOR(SFG);
  1310.     TEXTBACKGROUND(Blue);                    (* Special status colors *)
  1311.     GOTOXY(14,4);
  1312.     IF (ORD(Update[1])) AND ($40) <> 0 THEN  (* Mask off Clar bit *)
  1313.         WRITE(' ON ')
  1314.     ELSE WRITE ('OFF ');
  1315.     TEXTCOLOR(DFG);
  1316.     TEXTBACKGROUND(DBG);                     (* Default screen colors *)
  1317.     }
  1318.     QuickStat;
  1319.     WINDOW(2,6,79,23);
  1320.     CLRSCR;
  1321.     (* Display Menu selections *)
  1322.     TEXTCOLOR(RFG);
  1323.     TEXTBACKGROUND(DBG);                     (* Requested parameter colors *)
  1324.     GOTOXY(21,2);  WRITE('1    Display radio status screen');
  1325.     GOTOXY(21,3);  WRITE('2    Set Operating frequency');
  1326.     GOTOXY(21,4);  WRITE('3    Programmed frequency Step DOWN');
  1327.     GOTOXY(21,5);  WRITE('4    Programmed frequency Step UP');
  1328.     GOTOXY(21,6);  WRITE('5    Select VFO A/B/Memory');
  1329.     GOTOXY(21,7);  WRITE('6    Select Memory channel');
  1330.     GOTOXY(21,8);  WRITE('7    Set Operating Mode');
  1331.     GOTOXY(21,9);  WRITE('8    Select Ham Bands/General Coverage');
  1332.     GOTOXY(21,10); WRITE('9    Set CTCSS Tone frequencies');
  1333.     GOTOXY(21,11); WRITE('0    Turn off Split, Clarifier, Offset');
  1334.     GOTOXY(21,12); WRITE('+    Step UP 10 Hertz in frequency');
  1335.     GOTOXY(21,13); WRITE('-    Step DN 10 Hertz in frequency');
  1336.     GOTOXY(13,16); WRITE('Choice ' + CHR(16) + (' ') + CHR(17));
  1337.     GOTOXY(21,16);
  1338.     REPEAT
  1339.         InKey(Fk,Choice);                    (* Get Choice from Menu *)
  1340.     UNTIL Choice IN [#43..#68];
  1341.     TurnCatOn;                               (* Enable CAT for Choice *)
  1342.     CASE Choice OF
  1343.         #43 : CatSend(Up10Hz,5);             (* Numeric + *)
  1344.         #44 : (* Constant not used - no action *);
  1345.         #45 : CatSend(Dn10Hz,5);             (* Numeric - *)
  1346.         #46 : (* Constant not used - no action *);
  1347.         #47 : (* Constant not used - no action *);
  1348.         #48 : CatSend(Aclr,26);              (* Numeric 0 *)
  1349.         #49 : CheckStatus(Check);            (* Numeric 1 *)
  1350.         #50 : SetFreq;                       (* Numeric 2 *)
  1351.         #51 : BEGIN
  1352.                   DownFlag := TRUE;
  1353.                   ProgStep;                  (* Numeric 3 *)
  1354.               END;
  1355.         #52 : BEGIN
  1356.                   DownFlag := FALSE;
  1357.                   ProgStep;                  (* Numeric 4 *)
  1358.               END;
  1359.         #53 : VFOMRSelect;                   (* Numeric 5 *)
  1360.         #54 : MemSelect;                     (* Numeric 6 *)
  1361.         #55 : ModeSelect;                    (* Numeric 7 *)
  1362.         #56 : HGSelect;                      (* Numeric 8 *)
  1363.         #57 : CTCSSToneSet;                  (* Numeric 9 *)
  1364.         #58 : (* Constant not used - no action *);
  1365.         #59 : SelectMemFile;                 (* Fk 1 *)
  1366.         #60 : SelectVFOFile;                 (* Fk 2 *)
  1367.         #61 : CatSend(BandDn,5);             (* Fk 3 *)
  1368.         #62 : CatSend(BandUp,5);             (* Fk 4 *)
  1369.         #63 : CatSend(SplitTog,26);          (* Fk 5 *)
  1370.         #64 : CatSend(ClarTog,26);           (* Fk 6 *)
  1371.         #65 : BEGIN
  1372.                   CatSend(MToV,26);          (* Fk 7 *)
  1373.                   CatSend(Nul3String+CHR(0)+CHR(9),5);
  1374.               END;
  1375.         #66 : BEGIN
  1376.                   CatSend(VToM,26);          (* Fk 8 *)
  1377.                   CatSend(Nul3String+CHR(2)+CHR(9),5);
  1378.               END;
  1379.         #67 : CatSend(Swap,5);               (* Fk 9 *)
  1380.         #68 : QuitFlag := TRUE;              (* Fk 10 quits the program *)
  1381.     END; (* CASE *)
  1382. END; (* MainMenu *)
  1383.  
  1384. (*▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓*)
  1385. FUNCTION Offset(Page,BarPos : INTEGER) : STRING;
  1386. (* Compute repeater Split from operating frequency, return Offset Freq *)
  1387.  
  1388. VAR
  1389.     FreqSet,
  1390.     FreqInt,
  1391.     LSDFreq,
  1392.     Junk,
  1393.     FreqString : STRING[8];
  1394.     Ofs        : CHAR;
  1395.     DotPos,
  1396.     Result     : INTEGER;
  1397.     FreqTune   : REAL;
  1398.  
  1399. BEGIN (* Offset *)
  1400.     LSDFreq    := '';
  1401.     FreqInt    := '';
  1402.     FreqString := '';
  1403.     Ofs        := ' ';
  1404.     (* Get repeater's OUTPUT Frequency from Memory array *)
  1405.     VAL(COPY(MemArray[Page *10 +BarPos],1,8),FreqTune,Result);
  1406.     FreqTune := FreqTune;
  1407.     Ofs := MemArray[Page *10 +BarPos,23];
  1408.     (* 6 meter repeaters *)
  1409.     IF FreqTune < 14400000 THEN BEGIN
  1410.         IF Ofs = '-' THEN FreqTune := FreqTune - 100000;
  1411.         IF Ofs = '+' THEN FreqTune := FreqTune + 100000;
  1412.     END; (* IF *)
  1413.     (* 2 meter repeaters *)
  1414.     IF (FreqTune >= 14400000) AND (FreqTune <= 14800000) THEN BEGIN
  1415.         IF Ofs = '-' THEN FreqTune := FreqTune - 60000;
  1416.         IF Ofs = '+' THEN FreqTune := FreqTune + 60000;
  1417.     END; (* IF *)
  1418.     (* 70 centimeter repeaters *)
  1419.     IF (FreqTune >= 42000000) AND (FreqTune <= 45000000) THEN BEGIN
  1420.         IF Ofs = '-' THEN FreqTune := FreqTune - 500000;
  1421.         IF Ofs = '+' THEN FreqTune := FreqTune + 500000;
  1422.     END; (* IF *)
  1423.     (* Construct LSD->MSD string for Offset value *)
  1424.     STR(FreqTune:8:0,FreqString);
  1425.     WHILE COPY(FreqString,1,1) = ' ' DO
  1426.         DELETE(FreqString,1,1);
  1427.     FreqInt := MultString(8 - LENGTH(FreqString),'0') +FreqString;
  1428.     LSDFreq := MakeLSDMSD(FreqInt,8);
  1429.     Offset  := FreqParm(LSDFreq,8);
  1430. END; (* Offset *)
  1431.  
  1432. END. (* of UNIT Y767INST *)
  1433.