home *** CD-ROM | disk | FTP | other *** search
/ Simtel MSDOS 1992 June / SIMTEL_0692.cdr / msdos / telix / tlx_hst.arc / TLX_HST.SLT < prev    next >
Text File  |  1988-12-15  |  54KB  |  1,626 lines
  1. ////////////////////////////////////////////////////////////////////////
  2. //                                                                    //
  3. //  TLX_HST Service Script, Release 1.0                               //
  4. //                                                                    //
  5. //  For Telix SALT version 3.11                                       //
  6. //                                                                    //
  7. //  Written by: Andrzej Taramina                                      //
  8. //                                                                    //
  9. ////////////////////////////////////////////////////////////////////////
  10.  
  11. int CONT_OK = 0;                       // Global function return codes
  12. int GET_OUT  = 99;
  13. int TIME_OUT = 98;
  14.  
  15. main()
  16.  {
  17.   str menu[1] = "M";
  18.   str rom_level[3] = "";
  19.   str func[2];
  20.   int save_scr;
  21.   int t1, t2, t3, t4;
  22.   int stat;
  23.   int ret_code = 0;
  24.   int ran_fn;
  25.   int time_handle;
  26.  
  27.   save_scr = vsavearea(0,0,79,24);
  28.   clear_scr();
  29.   if (carrier())
  30.      {
  31.       clear_scr();
  32.       prints("This Script MUST be run OFFLINE (in terminal mode)");
  33.       prints("Script aborted due to above error.");
  34.       delay(40);
  35.       vrstrarea(save_scr);
  36.       return(-1);
  37.      }
  38.  
  39.   t1 = track("961",0);
  40.   t2 = track("963",0);
  41.   t3 = track("964",0);
  42.   t4 = track("OK",0);
  43.  
  44.   flushbuf();
  45.   cputs("ATI0^M");
  46.   time_handle = timer_start(20);
  47.   while (1)
  48.      {
  49.       terminal();
  50.       stat = track_hit(0);
  51.       if (stat == t1)
  52.          {
  53.           rom_level = "961";
  54.           break;
  55.          }
  56.       else if (stat == t2)
  57.               {
  58.                rom_level = "963";
  59.                break;
  60.               }
  61.       else if (stat == t3)
  62.               {
  63.                rom_level = "964";
  64.                break;
  65.               }
  66.       else if (stat == t4)
  67.               break;
  68.       else if (time_up(time_handle))
  69.               break;
  70.      }
  71.  
  72.   track_free(0);
  73.   timer_free(time_handle);
  74.   if (rom_level == "")
  75.      {
  76.       clear_scr();
  77.       prints("Sorry, your modem is not a USRobotics Courier HST or");
  78.       prints("the ROM level is higher than 964 or lower than 961.");
  79.       prints("HST Service Script aborted.");
  80.       delay (40);
  81.       vrstrarea(save_scr);
  82.       return(-1);
  83.      }
  84.  
  85.   cputs("AT&B0^M");
  86.   set_cparams(2400,0,8,1);
  87.   _local_echo = 1;
  88.  
  89.   while (ret_code == CONT_OK)
  90.      {
  91.       if (menu == "M")
  92.          main_menu(rom_level);
  93.       else
  94.          adv_menu(rom_level);
  95.       ran_fn = 1;
  96.       flushbuf();
  97.       gotoxy(56,18);
  98.       gets(func,2);
  99.       if (menu == "M")
  100.          {
  101.           if (func == "1") ret_code = get_level();
  102.           else if (func == "2")  ret_code = chk_sum();
  103.           else if (func == "3")  ret_code = ram_test();
  104.           else if (func == "4")  ret_code = current_set();
  105.           else if (func == "5")  ret_code = nram_set();
  106.           else if (func == "6")  ret_code = set_clock();
  107.           else if (func == "7")  ret_code = disp_phone();
  108.           else if (func == "8")  ret_code = basic_help();
  109.           else if (func == "9")  ret_code = ext_help();
  110.           else if (func == "10") ret_code = dial_help();
  111.           else if (func == "11") ret_code = set_sregs();
  112.           else if (func == "12") ret_code = switch_help();
  113.           else if (func == "13") ret_code = interface_test();
  114.           else if (func == "14") ret_code = analog_loop();
  115.           else if (func == "15") ret_code = freq_test();
  116.           else if (func == "16") ret_code = data_mode();
  117.           else if (func == "17") ret_code = set_to_nram();
  118.           else if (func == "18") ret_code = write_nram();
  119.           else if (func == "19") ret_code = dial_phone();
  120.           else if (func == "20") ret_code = link_diag();
  121.           else if (func == "TX") ret_code = telix_def(rom_level);
  122.           else if (func == "tx") ret_code = telix_def(rom_level);
  123.           else if (func == "PC") ret_code = pcboard_def(rom_level);
  124.           else if (func == "pc") ret_code = pcboard_def(rom_level);
  125.           else if ((func == "AD" or func == "ad") and
  126.                   rom_level >= "964")
  127.                   {
  128.                    menu = "A";
  129.                    ran_fn = 0;
  130.                    continue;
  131.                   }
  132.           else if (func == "99") break;
  133.           else
  134.              {
  135.               tone(400,50);
  136.               ran_fn = 0;
  137.              }
  138.          }
  139.  
  140.       if (menu == "A")
  141.          {
  142.           if (func == "50") ret_code = disable_comp();
  143.           else if (func == "51") ret_code = auto_comp();
  144.           else if (func == "52") ret_code = enable_comp();
  145.           else if (func == "53") ret_code = set_s15reg();
  146.           else if (func == "54") ret_code = set_rate();
  147.           else if (func == "55") ret_code = modem_inq();
  148.           else if (func == "98")
  149.              {
  150.               menu = "M";
  151.               ran_fn = 0;
  152.              }
  153.           else if (func == "99") break;
  154.           else
  155.              {
  156.               tone(400,50);
  157.               ran_fn = 0;
  158.              }
  159.          }
  160.       if (ran_fn and ret_code == CONT_OK)
  161.          {
  162.           gotoxy(18,23);
  163.           printsc("Press (Enter) to return to function menu......");
  164.           flushbuf();
  165.           gotoxy(0,0);
  166.           inkeyw();
  167.          }
  168.      }
  169.  
  170.  
  171.   if (ret_code == TIME_OUT)
  172.      {
  173.       clear_scr();
  174.       prints("WAITFOR timeout: expected response not received after 20 seconds");
  175.       prints("Script aborted....");
  176.       delay(30);
  177.      }
  178.  
  179.   clear_scr();
  180.   gotoxy(0,0);
  181.   prints("USR TLX_HST SERVICE SCRIPT - EXIT");
  182.   prints(" ");
  183.   prints("The TLX_HST script sets your COM port to 2400-N-8-1 during");
  184.   prints("its operation and resets these parameters to 19200-N-8-1");
  185.   prints("prior to exit. If your default COM parameters are different,");
  186.   prints("Use the TELIX Alt-P command to restore the desired COM ");
  187.   prints("parameters before going back online.");
  188.   prints(" ");
  189.   prints("Thanks for using TLX_HST and TELIX.  Have a nice day.");
  190.   prints(" ");
  191.   prints("Press <Enter> to return to Telix");
  192.   inkeyw();
  193.   set_cparams(19200,0,8,1);
  194.   _local_echo = 1;
  195.   vrstrarea(save_scr);
  196.   return(0);
  197.  }
  198.  
  199. ////////////////////////////////////////////////////////////////////////
  200. //                                                                    //
  201. //  Function to display Main Menu                                     //
  202. //                                                                    //
  203. ////////////////////////////////////////////////////////////////////////
  204.  
  205. main_menu(str rom_level)
  206.  {
  207.   clear_scr();
  208.   prints("                 ┌────────────────────────────────────────────┐              ");
  209.   prints("   ╒═════════════╡ USR COURIER HST - TXL_HST MAIN MENU   v1.0 ╞═════════════╕");
  210.   prints("   │             └────────────────────────────────────────────┘             │");
  211.   prints("   │  1.  Display HST ROM Level             13. Check Modem-PC Interface    │");
  212.   prints("   │  2.  Display HST Memory Checksum       14. Self-Test: Analog Loopback  │");
  213.   prints("   │  3.  HST RAM Test                      15. Self-Test: Answer Frequency │");
  214.   prints("   │  4.  Display HST RAM Settings          16. Self-Test: Reset Data Mode  │");
  215.   prints("   │  5.  Display HST NRAM Settings         17. Reset Modem to NRAM Default │");
  216.   prints("   │  6.  Display/Set Internal TOD Clock    18. Copy RAM Settings to NRAM   │");
  217.   prints("   │  7.  Display/Store Internal Phone #s   19. Dial a number & exit        │");
  218.   prints("   │  8.  Display Basic Command Help        20. Link Diagnostics display    │");
  219.   prints("   │  9.  Display Extended Command Help                                     │");
  220.   prints("   │ 10.  Display Dial Command Help                                         │");
  221.   prints("   │ 11.  Display S-Reg Help/Set S-Reg      TX. Set Telix 3.11 defaults     │");
  222.   prints("   │ 12.  Display Modem Switch Help         PC. Set PCboard 14.x defaults   │");
  223.   prints("   │                               99. EXIT                                 │");
  224.   prints("   ╞════════════════════════════════════════════════════════════════════════╡");
  225.   prints("   │                                                                        │");
  226.   prints("   │            Type desired function code and (Enter): __                  │");
  227.   prints("   │ ┌──────────┐                                   ┌────────────────────┐  │");
  228.   prints("   ╘═╡ AJT 1988 ╞═══════════════════════════════════╡ HST ROM Level:     ╞══╛");
  229.   prints("     └──────────┘                                   └────────────────────┘   ");
  230.   gotoxy(69,20);
  231.   printsc(rom_level);
  232.   if (rom_level >= "964")
  233.      {
  234.       gotoxy(44,12);
  235.       printsc("AD. Advanced Functions");
  236.      }
  237.  }
  238.  
  239. ////////////////////////////////////////////////////////////////////////
  240. //                                                                    //
  241. //  Function to display Advanced Functions Menu                       //
  242. //                                                                    //
  243. ////////////////////////////////////////////////////////////////////////
  244.  
  245. adv_menu(str rom_level)
  246.  {
  247.   clear_scr();
  248.   prints("                 ┌────────────────────────────────────────────┐              ");
  249.   prints("   ╒═════════════╡ USR COURIER HST MODEM - ADVANCED FUNCTIONS ╞═════════════╕");
  250.   prints("   │             └────────────────────────────────────────────┘             │");
  251.   prints("   │ 50.  Disable data compression                                          │");
  252.   prints("   │ 51.  Auto enable/disable compression                                   │");
  253.   prints("   │ 52.  Enable data compression                                           │");
  254.   prints("   │ 53.  S15 register settings                                             │");
  255.   prints("   │ 54.  Set modem-to-modem link rate                                      │");
  256.   prints("   │ 55.  Modem configuration inquiry                                       │");
  257.   prints("   │                                                                        │");
  258.   prints("   │ 98.  Return to Main Menu                                               │");
  259.   prints("   │ 99.  EXIT                                                              │");
  260.   prints("   │                                                                        │");
  261.   prints("   │                                                                        │");
  262.   prints("   │                                                                        │");
  263.   prints("   │                                                                        │");
  264.   prints("   ╞════════════════════════════════════════════════════════════════════════╡");
  265.   prints("   │                                                                        │");
  266.   prints("   │            Type desired function code and (Enter): __                  │");
  267.   prints("   │ ┌──────────┐                                   ┌────────────────────┐  │");
  268.   prints("   ╘═╡ AJT 1988 ╞═══════════════════════════════════╡ HST ROM Level:     ╞══╛");
  269.   prints("     └──────────┘                                   └────────────────────┘   ");
  270.   gotoxy(69,20);
  271.   printsc(rom_level);
  272.  }
  273.  
  274. ////////////////////////////////////////////////////////////////////////
  275. //                                                                    //
  276. //  Function to dial a number and exit                                //
  277. //                                                                    //
  278. ////////////////////////////////////////////////////////////////////////
  279.  
  280. dial_phone()
  281.  {
  282.   str prefix[4];
  283.   str number[25];
  284.  
  285.   while (1)
  286.      {
  287.       clear_scr();
  288.       prints("(T) for tone, (P) for pulse dialing and (Enter)...");
  289.       gotoxy(0,2);
  290.       gets(prefix,1);
  291.       if (prefix == "t" or prefix == "T")
  292.          {
  293.           prefix = "ATDT";
  294.           break;
  295.          }
  296.       if (prefix == "p" or prefix == "P")
  297.          {
  298.           prefix = "ATDP";
  299.           break;
  300.          }
  301.       tone(450,50);
  302.      }
  303.  
  304.   gotoxy(0,5);
  305.   prints("Type desired telephone number and (Enter)");
  306.   gotoxy(0,7);
  307.   gets(number,25);
  308.   gotoxy(0,9);
  309.   hangup();
  310.   prints("Dialing and exitting script.......");
  311.   cputs(prefix);
  312.   cputs(number);
  313.   cputs("^M");
  314.   return(GET_OUT);
  315.  }
  316.  
  317. ////////////////////////////////////////////////////////////////////////
  318. //                                                                    //
  319. //  Function to display HST ROM level                                 //
  320. //                                                                    //
  321. ////////////////////////////////////////////////////////////////////////
  322.  
  323. get_level()
  324.  {
  325.   clear_scr();
  326.   prints("USR HST ROM LEVEL DISPLAY -- ATI0");
  327.   cputs("ATI0^M");
  328.   if (waitfor("OK",10))
  329.      return(CONT_OK);
  330.   else
  331.      return(TIME_OUT);
  332.  }
  333.  
  334. ////////////////////////////////////////////////////////////////////////
  335. //                                                                    //
  336. //  Function to display HST memory check_sum                          //
  337. //                                                                    //
  338. ////////////////////////////////////////////////////////////////////////
  339.  
  340. chk_sum()
  341.  {
  342.   clear_scr();
  343.   prints("USR HST MEMORY CHECKSUM (ROM) DISPLAY -- ATI1");
  344.   cputs("ATI1^M");
  345.   if (waitfor("OK",10))
  346.      return(CONT_OK);
  347.   else
  348.      return(TIME_OUT);
  349.  }
  350.  
  351. ////////////////////////////////////////////////////////////////////////
  352. //                                                                    //
  353. //  Function to perform HST RAM test                                  //
  354. //                                                                    //
  355. ////////////////////////////////////////////////////////////////////////
  356.  
  357. ram_test()
  358. {
  359.   clear_scr();
  360.   prints("USR HST RAM MEMORY TEST -- ATI2");
  361.   cputs("ATI2^M");
  362.   if (waitfor("OK",10))
  363.      return(CONT_OK);
  364.   else
  365.      return(TIME_OUT);
  366.  }
  367.  
  368. ////////////////////////////////////////////////////////////////////////
  369. //                                                                    //
  370. //  Function to display HST RAM settings                              //
  371. //                                                                    //
  372. ////////////////////////////////////////////////////////////////////////
  373.  
  374. current_set()
  375.  {
  376.   clear_scr();
  377.   prints("USR HST CURRENT MODEM SETTINGS -- ATI4");
  378.   cputs("ATI4^M");
  379.   if (not waitfor("HOOK",10)) return(TIME_OUT);
  380.   if (waitfor("OK",10))
  381.      return(CONT_OK);
  382.   else
  383.      return(TIME_OUT);
  384.  }
  385.  
  386. ////////////////////////////////////////////////////////////////////////
  387. //                                                                    //
  388. //  Function to display HST Non-volatile RAM settings                 //
  389. //                                                                    //
  390. ////////////////////////////////////////////////////////////////////////
  391.  
  392. nram_set()
  393.  {
  394.   clear_scr();
  395.   prints("USR HST NON-VOLATILE RAM SETTINGS -- ATI5");
  396.   cputs("ATI5^M");
  397.   if (waitfor("OK",10))
  398.      return(CONT_OK);
  399.   else
  400.      return(TIME_OUT);
  401.  }
  402.  
  403. ////////////////////////////////////////////////////////////////////////
  404. //                                                                    //
  405. //  Function to display HST link diagnostics                          //
  406. //                                                                    //
  407. ////////////////////////////////////////////////////////////////////////
  408.  
  409. link_diag()
  410.  {
  411.   clear_scr();
  412.   prints("USR HST LINK DIAGNOSTICS DISPLAY -- ATI6");
  413.   cputs("ATI6^M");
  414.   if (waitfor("OK",10))
  415.      return(CONT_OK);
  416.   else
  417.      return(TIME_OUT);
  418.  }
  419.  
  420. ////////////////////////////////////////////////////////////////////////
  421. //                                                                    //
  422. //  Function to display/set internal HST TOD clock                    //
  423. //                                                                    //
  424. ////////////////////////////////////////////////////////////////////////
  425.  
  426. set_clock()
  427.  {
  428.   str input[1];
  429.   int ret_val;
  430.  
  431.   ret_val = CONT_OK;
  432.   clear_scr();
  433.   prints("USR HST INTERNAL CLOCK DISPLAY -- ATI3");
  434.   prints("Current modem clock value is:");
  435.   cputs("ATI3^M");
  436.   if (not waitfor("OK",10)) return(TIME_OUT);
  437.   prints(" ");
  438.   prints("Do you wish to set the modem clock (Y/N) ");
  439.   gets(input,1);
  440.   if (input != "Y" and input != "y")
  441.      return(CONT_OK);
  442.   clear_scr();
  443.   prints("USR HST INTERNAL CLOCK SETTING");
  444.   gotoxy(0,2);
  445.   prints("OPTION 1: Synchronize to system clock");
  446.   prints("OPTION 2: Specify your own clock value");
  447.  
  448.   while (1)
  449.      {
  450.       gotoxy(0,5);
  451.       printsc("Type 1 or 2 and (Enter):  ");
  452.       gets(input,1);
  453.       if (input == "1")
  454.          {
  455.           ret_val = sys_clock();
  456.           break;
  457.          }
  458.       else if (input == "2")
  459.          {
  460.           ret_val = usr_clock();
  461.           break;
  462.          }
  463.       else tone(450,50);
  464.      }
  465.  
  466.   gotoxy(0,11);
  467.   prints("Modem Internal clock value is now:");
  468.   cputs("ATI3^M");
  469.   if (waitfor("OK",10))
  470.      return(ret_val);
  471.   else
  472.      return(TIME_OUT);
  473.  }
  474.  
  475. sys_clock()
  476.  {
  477.   str time_str[8];
  478.  
  479.   clear_scr();
  480.   prints("SYNCHRONIZING MODEM CLOCK TO SYSTEM CLOCK");
  481.   gotoxy(0,2);
  482.   printsc("Current system clock is ");
  483.   time(curtime(),time_str);
  484.   prints(time_str);
  485.   cputs("ATK1^M");
  486.   if (not waitfor("OK",10)) return(TIME_OUT);
  487.   prints("^MSetting...");
  488.   cputs("ATI3=");
  489.   cputs(time_str);
  490.   cputs("K1^M");
  491.   if (waitfor("OK",10))
  492.      return(CONT_OK);
  493.   else
  494.      return(TIME_OUT);
  495.  }
  496.  
  497. usr_clock()
  498.  {
  499.   str time_str[8];
  500.  
  501.   clear_scr();
  502.   prints("MANUAL SETTING OF USR HST INTERNAL CLOCK");
  503.   gotoxy(0,2);
  504.   prints("WARNING: The script does not validate the clock value;");
  505.   prints("         an incorrect clock value will return an error.");
  506.   gotoxy(0,6);
  507.   printsc("Type a clock value in HH:MM:SS format and  (Enter): ");
  508.   gets(time_str,8);
  509.   cputs("ATK1^M");
  510.   if (not waitfor("OK",10)) return(TIME_OUT);
  511.   prints("^MSetting...");
  512.   cputs("ATI3=");
  513.   cputs(time_str);
  514.   cputs("K1^M");
  515.   if (waitfor("OK",10))
  516.      return(CONT_OK);
  517.   else
  518.      return(TIME_OUT);
  519.  }
  520.  
  521. ////////////////////////////////////////////////////////////////////////
  522. //                                                                    //
  523. //  Function to set HST S-Registers                                   //
  524. //                                                                    //
  525. ////////////////////////////////////////////////////////////////////////
  526.  
  527. set_sregs()
  528.  {
  529.   str reg_num[2];
  530.   str reg_val[3];
  531.  
  532.   clear_scr();
  533.   prints("SET HST S-REGISTER(S)");
  534.   cputs("ATS$^M");
  535.   if (not waitfor("OK",10)) return(TIME_OUT);
  536.   while (1)
  537.      {
  538.       gotoxy(0,17);
  539.       prints("Enter register you want to set (0-13,16-17,19-23):    ");
  540.       prints("---or press (Enter) to return to abort--");
  541.       gotoxy(54,17);
  542.       gets(reg_num,2);
  543.       if (reg_num == "")
  544.          return(CONT_OK);
  545.       if (reg_num >= "0" and reg_num <= "13")
  546.          break;
  547.       if (reg_num == "16" or reg_num == "17")
  548.          break;
  549.       if (reg_num >= "19" and reg_num <= "23")
  550.          break;
  551.       tone(400,50);
  552.      }
  553.  
  554.   clear_scr();
  555.   printsc("Current value of register S");
  556.   printsc(reg_num);
  557.   prints(":");
  558.   cputs("ATS");
  559.   cputs(reg_num);
  560.   cputs("?^M");
  561.   if (not waitfor("OK",10)) return(TIME_OUT);
  562.  
  563.   while (1)
  564.      {
  565.       gotoxy(0,7);
  566.       printsc("Type new S");
  567.       printsc(reg_num,);
  568.       prints(" register value or (Enter) to leave as is: ");
  569.       gets(reg_val,3);
  570.       if (reg_val == "")
  571.          return(CONT_OK);
  572.       if (reg_val >= "0" and reg_val <="255")
  573.          break;
  574.      }
  575.  
  576.   cputs("ATS");
  577.   cputs(reg_num);
  578.   cputs("=");
  579.   cputs(reg_val);
  580.   cputs("^M");
  581.   if (not waitfor("OK",10)) return(TIME_OUT);
  582.   gotoxy(0,14);
  583.   printsc("New S");
  584.   printsc(reg_num);
  585.   prints(" register value returned by modem is:");
  586.   cputs("ATS");
  587.   cputs(reg_num);
  588.   cputs("?^M");
  589.   if (waitfor("OK",10))
  590.      return(CONT_OK);
  591.   else
  592.      return(TIME_OUT);
  593.  }
  594.  
  595. ////////////////////////////////////////////////////////////////////////
  596. //                                                                    //
  597. //  Function to reset HST to NRAM defaults                            //
  598. //                                                                    //
  599. ////////////////////////////////////////////////////////////////////////
  600.  
  601. set_to_nram()
  602.  {
  603.   str input[1];
  604.   clear_scr();
  605.   prints("Resetting to NRAM defaults may erase changes made to the modem");
  606.   prints("operational parameters or S-Registers if these changes were not");
  607.   prints("copied to NRAM.");
  608.   prints("Do you wish to continue (Y/N):  ");
  609.   gotoxy(30,3);
  610.   gets(input,1);
  611.   if (input != "y" and input != "Y")
  612.      return(CONT_OK);
  613.   cputs("ATZ^M");
  614.   if (waitfor("OK",10))
  615.      return(CONT_OK);
  616.   else
  617.      return(TIME_OUT);
  618.  }
  619.  
  620. ////////////////////////////////////////////////////////////////////////
  621. //                                                                    //
  622. //  Function to display HST Basic command help                        //
  623. //                                                                    //
  624. ////////////////////////////////////////////////////////////////////////
  625.  
  626. basic_help()
  627.  {
  628.   clear_scr();
  629.   cputs("AT$^M");
  630.   if (not waitfor("Hook",10)) return(TIME_OUT);
  631.   if (not waitfor("Hook",10)) return(TIME_OUT);
  632.   if (waitfor("OK",10))
  633.      return(CONT_OK);
  634.   else
  635.      return(TIME_OUT);
  636.  }
  637.  
  638. ////////////////////////////////////////////////////////////////////////
  639. //                                                                    //
  640. //  Function to display HST Basic Command help                        //
  641. //                                                                    //
  642. ////////////////////////////////////////////////////////////////////////
  643.  
  644. ext_help()
  645.  {
  646.   clear_scr();
  647.   cputs("AT&$^M");
  648.   if (waitfor("OK",30))
  649.      return(CONT_OK);
  650.   else
  651.      return(TIME_OUT);
  652.  }
  653.  
  654. ////////////////////////////////////////////////////////////////////////
  655. //                                                                    //
  656. //  Function to display HST Dialling Command help                        //
  657. //                                                                    //
  658. ////////////////////////////////////////////////////////////////////////
  659.  
  660. dial_help()
  661.  {
  662.   clear_scr();
  663.   cputs("ATD$^M");
  664.   if (not waitfor("Hook",30)) return(TIME_OUT);
  665.   if (waitfor("OK",30))
  666.      return(CONT_OK);
  667.   else
  668.      return(TIME_OUT);
  669.  }
  670.  
  671. ////////////////////////////////////////////////////////////////////////
  672. //                                                                    //
  673. //  Function to display HST S-register help                           //
  674. //                                                                    //
  675. ////////////////////////////////////////////////////////////////////////
  676.  
  677. sreg_help()
  678.  {
  679.   clear_scr();
  680.   cputs("ATS$^M");
  681.   if (waitfor("OK",30))
  682.      return(CONT_OK);
  683.   else
  684.      return(TIME_OUT);
  685.  }
  686.  
  687. ////////////////////////////////////////////////////////////////////////
  688. //                                                                    //
  689. //  Function to display HST Switch settings help                      //
  690. //                                                                    //
  691. ////////////////////////////////////////////////////////////////////////
  692.  
  693. switch_help()
  694.  {
  695.   clear_scr();
  696.   prints("HST DIP SWITCH HELP SCREEN");
  697.   prints(" ");
  698.   prints("    ▄  ▄   ");
  699.   prints("   ┌──────┐┌─┬─┬─┬─┬─┬─┬─┬─┬─┬─┐");
  700.   prints(" UP│██████││ │█│ │█│ │ │█│ │ │█│   FACTORY");
  701.   prints(" DN│      ││█│ │█│ │█│█│ │█│█│ │   SETTINGS");
  702.   prints("   └──────┘└─┴─┴─┴─┴─┴─┴─┴─┴─┴─┘");
  703.   prints("      ▀  ▀      1 2 3 4 5 6 7 8 9 10");
  704.   prints(" ");
  705.   prints(" Sw#         Description                 Sw#           Description       ");
  706.   prints(" ------------------------------------------------------------------------");
  707.   prints("  1...Data Terminal Ready Override        6...Carrier Detect Override    ");
  708.   prints("      UP=DTR Normal  DN=DTR always ON         UP=Pin 8     DN=Always ON  ");
  709.   prints("  2...Verbal/Numeric Result Codes         7...Single/Multiple Phone      ");
  710.   prints("      UP=Verbal      DN=Numeric               UP=Single    DN=Multiple   ");
  711.   prints("  3...Result Code Display                 8...Command Set Recognition    ");
  712.   prints("      UP=No Display  DN=Display               UP=Dumb Mode DN=Smart Mode ");
  713.   prints("  4...Command Mode Local Echo             9...Normal Mode Escape Code op.");
  714.   prints("      UP=Echo        DN=No Echo               UP=Hang Up   DN=Keep Connect");
  715.   prints("  5...Auto Answer                        10...Power-on Software Defaults ");
  716.   prints("      UP=AA 1st ring DN=No AA                 UP=Use NRAM  DN=Use ROM    ");
  717.   prints(" ");
  718.   prints("  Quad Switch: Send/Receive UP=Pin2 Xmit/Pin3 Rcv DN=Pin2 Rcv/Pin3 Xmit");
  719.   return(CONT_OK);
  720.  }
  721.  
  722. ////////////////////////////////////////////////////////////////////////
  723. //                                                                    //
  724. //  Function to write to NRAM                                         //
  725. //                                                                    //
  726. ////////////////////////////////////////////////////////////////////////
  727.  
  728. write_nram()
  729.  {
  730.   str input[1];
  731.  
  732.   clear_scr();
  733.   prints("WRITING CHANGES TO NRAM MAY CHANGE YOUR POWER-UP MODEM DEFAULTS.");
  734.   gotoxy(1,3);
  735.   printsc("Do you wish to continue (Y/N):  ");
  736.  
  737.   while (1)
  738.      {
  739.       gotoxy(31,3);
  740.       gets(input,1);
  741.       if (input == "y" or input == "Y")
  742.          break;
  743.       if (input == "n" or input == "N")
  744.          return(CONT_OK);
  745.       tone(400,50);
  746.      }
  747.  
  748.   cputs("AT&W^M");
  749.   if (not waitfor("OK",10)) return(TIME_OUT);
  750.   return(nram_set());
  751.  }
  752.  
  753. ////////////////////////////////////////////////////////////////////////
  754. //                                                                    //
  755. //  Function to perform PC to Modem interface test                    //
  756. //                                                                    //
  757. ////////////////////////////////////////////////////////////////////////
  758.  
  759. interface_test()
  760.  {
  761.   clear_scr();
  762.   prints("PC/MODEM INTERFACE TEST: If the Modem/PC Interface is functional,");
  763.   prints("the modem will respond with 'OK'...");
  764.   delay_scr(50);
  765.   cputs("AT^M");
  766.   if (waitfor("OK",10))
  767.      return(CONT_OK);
  768.   else
  769.      return(TIME_OUT);
  770.  }
  771.  
  772. ////////////////////////////////////////////////////////////////////////
  773. //                                                                    //
  774. //  Function to perform Analog Loopback test                          //
  775. //                                                                    //
  776. ////////////////////////////////////////////////////////////////////////
  777.  
  778. analog_loop()
  779.  {
  780.   clear_scr();
  781.   prints("ANALOG LOOPBACK SELF-TEST OF THE HST MODEM:  The HST will");
  782.   prints("modulate and demodulate its own internal test pattern and return");
  783.   prints("the pattern to the screen.  The first step, upon success, will");
  784.   prints("display 'CONNECT 2400'.  The second step will display 'NO CARRIER'");
  785.   cputs("AT&M0S16=5D^M");
  786.   if (not waitfor("CONNECT 2400",20)) return(TIME_OUT);
  787.   delay_scr(30);
  788.   cputs("X");
  789.   if (not waitfor("NO CARRIER",20)) return(TIME_OUT);
  790.   prints(" ");
  791.   prints("Test Complete.");
  792.   cputs("AT&M4S16=0^M");
  793.   if (waitfor("OK",20))
  794.      return(CONT_OK);
  795.   else
  796.      return(TIME_OUT);
  797.  }
  798.  
  799. ////////////////////////////////////////////////////////////////////////
  800. //                                                                    //
  801. //  Function to test Answer Frequency                                 //
  802. //                                                                    //
  803. ////////////////////////////////////////////////////////////////////////
  804.  
  805. freq_test()
  806.  {
  807.   clear_scr();
  808.   prints("EXERCISING THE ANSWER FREQUENCY OF THE HST.  In a stand-alone mode,");
  809.   prints("the modem will return a 'NO CARRIER' response to this command.");
  810.   cputs("AT&M0S16=5A^M");
  811.   if (not waitfor("CONNECT 2400",20)) return(TIME_OUT);
  812.   delay_scr(30);
  813.   cputs("X");
  814.   if (not waitfor("NO CARRIER",20)) return(TIME_OUT);
  815.   prints(" ");
  816.   prints("Test Complete.");
  817.   cputs("AT&M4S16=0^M");
  818.   if (waitfor("OK",20))
  819.      return(CONT_OK);
  820.   else
  821.      return(TIME_OUT);
  822.  }
  823.  
  824. ////////////////////////////////////////////////////////////////////////
  825. //                                                                    //
  826. //  Function to reset HST data modes & error control                  //
  827. //                                                                    //
  828. ////////////////////////////////////////////////////////////////////////
  829.  
  830. data_mode()
  831.  {
  832.   clear_scr();
  833.   prints("RESET STANDARD HST DATA MODE.  This function will reset the HST");
  834.   prints("modem error control and data mode defaults for normal operation.");
  835.   prints(" ");
  836.   cputs("AT&M4S16=0^M");
  837.   if (waitfor("OK",20))
  838.      return(CONT_OK);
  839.   else
  840.      return(TIME_OUT);
  841.  }
  842.  
  843. ////////////////////////////////////////////////////////////////////////
  844. //                                                                    //
  845. //  Function to set PCBoard defaults                                  //
  846. //                                                                    //
  847. ////////////////////////////////////////////////////////////////////////
  848.  
  849. pcboard_def(str rom_level)
  850.  {
  851.   str input[1];
  852.  
  853.   clear_scr();
  854.   flushbuf();
  855.   prints("MODEM SWITCH SETTINGS FOR PCBOARD 14.X HOST OPERATIONS");
  856.   prints(" ");
  857.   prints("    ▄  ▄   ");
  858.   prints("   ┌──────┐┌─┬─┬─┬─┬─┬─┬─┬─┬─┬─┐");
  859.   prints(" UP│██████││█│█│ │ │ │█│█│ │█│█│");
  860.   prints(" DN│      ││ │ │█│█│█│ │ │█│ │ │");
  861.   prints("   └──────┘└─┴─┴─┴─┴─┴─┴─┴─┴─┴─┘");
  862.   prints("      ▀  ▀  1 2 3 4 5 6 7 8 9 10");
  863.   prints(" ");
  864.   prints("NOTE: Switch 7 setting may be changed if you are running");
  865.   prints("      a multi-phone operation");
  866.   prints(" ");
  867.   printsc("Press <Enter> to continue with other modem parameters");
  868.   gets(input,1);
  869.   clear_scr();
  870.   prints("This function will set all modem operational parameters and");
  871.   prints("S-Registers to their optimum values for 19200 bps operation");
  872.   prints("when using PCBoard 14.x software.  The settings implemented");
  873.   prints("via this option are consistent with the HST settings used by");
  874.   prints("Clark Development's PCBMODEM program.");
  875.   return(set_def(rom_level,1));
  876.  }
  877.  
  878. telix_def(str rom_level)
  879.  {
  880.   str input[1];
  881.  
  882.   flushbuf();
  883.   clear_scr();
  884.   prints("MODEM SWITCH SETTINGS FOR TELIX 3.11 ORIGINATE OPERATIONS");
  885.   prints(" ");
  886.   prints("    ▄  ▄   ");
  887.   prints("   ┌──────┐┌─┬─┬─┬─┬─┬─┬─┬─┬─┬─┐");
  888.   prints(" UP│██████││█│█│ │ │ │█│█│ │ │█│");
  889.   prints(" DN│      ││ │ │█│█│█│ │ │█│█│ │");
  890.   prints("   └──────┘└─┴─┴─┴─┴─┴─┴─┴─┴─┴─┘");
  891.   prints("      ▀  ▀  1 2 3 4 5 6 7 8 9 10");
  892.   prints(" ");
  893.   printsc("Press <Enter> to continue with other modem parameters");
  894.   gets(input,1);
  895.   clear_scr();
  896.   prints("This function will set all modem operational parameters and");
  897.   prints("S-Registers to their optimum values for 19200 bps operation");
  898.   prints("when using Telix 3.11 in originate mode when communicating");
  899.   prints("with PCBoard 14.x HST-equipped Bulletin Board Systems.");
  900.   return(set_def(rom_level,0));
  901.  }
  902.  
  903. set_def(str rom_level, int do_pcbdef)
  904.  {
  905.   str input[1];
  906.   int xpos, ypos;
  907.  
  908.   prints(" ");
  909.   prints("You May chose the 'FAST' method which will set all parameters");
  910.   prints("at once without any accompanying display, or the 'SLOW' method");
  911.   prints("which walks you throught the process one parameter at a time.");
  912.   prints("The SLOW method may take a couple minutes to complete.");
  913.   prints(" ");
  914.   printsc("Type 'F' for FAST method, 'S' for SLOW, (Enter) to abort: ");
  915.   xpos = getx();
  916.   ypos = gety();
  917.   while (1)
  918.      {
  919.       gotoxy(xpos,ypos);
  920.       gets(input,1);
  921.       if (input == "")
  922.          return(CONT_OK);
  923.       else if (input == "f" or input == "F")
  924.                {
  925.                 if (do_pcbdef)
  926.                    return(fast_set_pcb(rom_level));
  927.                 else
  928.                    return(fast_set_telix(rom_level));
  929.                }
  930.       else if (input == "s" or input == "S")
  931.               return(slow_set(rom_level,do_pcbdef));
  932.       else
  933.           tone(400,50);
  934.      }
  935.  }
  936.  
  937. slow_set(str rom_level, int do_pcbdef)
  938.  {
  939.   clear_scr();
  940.   prints("SET TRANSMITTER ENABLED : ATC1");
  941.   cputs("ATC1^M");
  942.   if (not waitfor("OK",10)) return(TIME_OUT);
  943.   delay_scr(20);
  944.   clear_scr();
  945.   prints("SET COMMAND MODE ECHO OFF: ATE0");
  946.   cputs("ATE0^M");
  947.   if (not waitfor("OK",10)) return(TIME_OUT);
  948.   delay_scr(20);
  949.   clear_scr();
  950.   prints("SET LOCAL ECHO OFF AFTER CONNECT: ATF1");
  951.   cputs("ATF1^M");
  952.   if (not waitfor("OK",10)) return(TIME_OUT);
  953.   delay_scr(20);
  954.   clear_scr();
  955.   if (do_pcbdef)
  956.      {
  957.       prints("DISABLE SPEAKER: ATM0");
  958.       cputs("ATM0^M");
  959.       if (not waitfor("OK",10)) return(TIME_OUT);
  960.       delay_scr(20);
  961.      }
  962.   else
  963.      {
  964.       prints("SET SPEAKER ON UNTIL CARRIER ESTABLISHED: ATM1");
  965.       cputs("ATM1^M");
  966.       if (not waitfor("OK",10)) return(TIME_OUT);
  967.       delay_scr(20);
  968.      }
  969.   clear_scr();
  970.   prints("SET QUIET MODE OFF-RESULT CODES DISPLAYED: ATQ0");
  971.   cputs("ATQ0^M");
  972.   if (not waitfor("OK",10)) return(TIME_OUT);
  973.   delay_scr(20);
  974.   clear_scr();
  975.   prints("SET RESULTS TO VERBAL MODE: ATV1");
  976.   cputs("ATV1^M");
  977.   if (not waitfor("OK",10)) return(TIME_OUT);
  978.   delay_scr(20);
  979.   clear_scr();
  980.   prints("SET EXTENDED RESULT CODE OPTION: ATX6");
  981.   cputs("ATX6^M");
  982.   if (not waitfor("OK",10)) return(TIME_OUT);
  983.   delay_scr(20);
  984.   clear_scr();
  985.   prints("SET U.S. ANSWER SEQUENCE DEFAULT: ATB1");
  986.   cputs("ATB1^M");
  987.   if (not waitfor("OK",10)) return(TIME_OUT);
  988.   delay_scr(20);
  989.   clear_scr();
  990.   prints("EXTENDED FUNCTION-ENABLE ARQ RESULT CODE: AT&A1");
  991.   cputs("AT&A1^M");
  992.   if (not waitfor("OK",10)) return(TIME_OUT);
  993.   delay_scr(20);
  994.   clear_scr();
  995.   prints("EXTENDED FUNCTION-FIX DTE RATE: AT&B1");
  996.   cputs("AT&B1^M");
  997.   if (not waitfor("OK",10)) return(TIME_OUT);
  998.   delay_scr(20);
  999.   clear_scr();
  1000.   prints("EXTENDED FUNCTION-XMIT DATA CTS HARDWARE FLOW CONTROL: AT&H1");
  1001.   cputs("AT&H1^M");
  1002.   if (not waitfor("OK",10)) return(TIME_OUT);
  1003.   delay_scr(20);
  1004.   clear_scr();
  1005.   prints("EXTENDED FUNCTION-RCV DATA FLOW CONTROL DISABLED: AT&I0");
  1006.   cputs("AT&I0^M");
  1007.   if (not waitfor("OK",10)) return(TIME_OUT);
  1008.   delay_scr(20);
  1009.   if (rom_level >= "964")
  1010.      {
  1011.       clear_scr();
  1012.       prints("EXTENDED FUNCTION (964)-DISABLE DATA COMPRESSION: AT&K0");
  1013.       cputs("AT&K0^M");
  1014.       if (not waitfor("OK",10)) return(TIME_OUT);
  1015.       delay_scr(20);
  1016.      }
  1017.   clear_scr();
  1018.   prints("EXTENDED FUNCTION-ERROR CONTROL MODE NORMAL/ARQ: AT&M4");
  1019.   cputs("AT&M4^M");
  1020.   if (not waitfor("OK",10)) return(TIME_OUT);
  1021.   delay_scr(20);
  1022.   clear_scr();
  1023.   prints("EXTENDED FUNCTION-DATA RATE SET TO NORMAL LINK OPERATIONS: AT&N0");
  1024.   cputs("AT&N0^M");
  1025.   if (not waitfor("OK",10)) return(TIME_OUT);
  1026.   delay_scr(20);
  1027.   clear_scr();
  1028.   prints("EXTENDED FUNCTION-SET PULSE DIAL MAKE/BREAK RATIO TO U.S.: AT&P0");
  1029.   cputs("AT&P0^M");
  1030.   if (not waitfor("OK",10)) return(TIME_OUT);
  1031.   delay_scr(20);
  1032.   clear_scr();
  1033.   prints("EXTENDED FUNCTION-RCV DATA FLOW CONTROL->PASS ON RTS HIGH: AT&R2");
  1034.   cputs("AT&R2^M");
  1035.   if (not waitfor("OK",10)) return(TIME_OUT);
  1036.   delay_scr(20);
  1037.   clear_scr();
  1038.   prints("EXTENDED FUNCTION-MODEM CONTROLS DATA SET READY LINE: AT&S1");
  1039.   cputs("AT&S1^M");
  1040.   if (not waitfor("OK",10)) return(TIME_OUT);
  1041.   delay_scr(20);
  1042.   clear_scr();
  1043.   prints("EXTENDED FUNCTION-SEND DESTRUCTIVE, EXPEDITED BREAKS: AT&Y1");
  1044.   cputs("AT&Y1^M");
  1045.   if (not waitfor("OK",10)) return(TIME_OUT);
  1046.   delay_scr(20);
  1047.   clear_scr();
  1048.   prints("S-REGISTER- DISABLE AUTO ANSWER: ATS0=0");
  1049.   cputs("ATS0=0^M");
  1050.   if (not waitfor("OK",10)) return(TIME_OUT);
  1051.   delay_scr(20);
  1052.   clear_scr();
  1053.   prints("S-REGISTER-RESET INCOMING RING COUNT TO ZERO: ATS1=0");
  1054.   cputs("ATS1=0^M");
  1055.   if (not waitfor("OK",10)) return(TIME_OUT);
  1056.   delay_scr(20);
  1057.   clear_scr();
  1058.   if (do_pcbdef)
  1059.      {
  1060.       prints("S-REGISTER- SET ASCII ESCAPE CODE DEFAULT TO X'FF': ATS2=255");
  1061.       cputs("ATS2=255^M");
  1062.       if (not waitfor("OK",10)) return(TIME_OUT);
  1063.       delay_scr(20);
  1064.      }
  1065.   else
  1066.      {
  1067.       prints("S-REGISTER- SET ASCII ESCAPE CODE DEFAULT TO '+': ATS2=43");
  1068.       cputs("ATS2=43^M");
  1069.       if (not waitfor("OK",10)) return(TIME_OUT);
  1070.       delay_scr(20);
  1071.      }
  1072.   clear_scr();
  1073.   prints("S-REGISTER- SET ASCII CARRIAGE RETURN TO 13: ATS3=13");
  1074.   cputs("ATS3=13^M");
  1075.   if (not waitfor("OK",10)) return(TIME_OUT);
  1076.   delay_scr(20);
  1077.   clear_scr();
  1078.   prints("S-REGISTER- SET ASCII LINE FEED TO 10: ATS4=10");
  1079.   cputs("ATS4=10^M");
  1080.   if (not waitfor("OK",10)) return(TIME_OUT);
  1081.   delay_scr(20);
  1082.   clear_scr();
  1083.   prints("S-REGISTER- SET ASCII BACKSPACE TO 8: ATS5=8");
  1084.   cputs("ATS5=8^M");
  1085.   if (not waitfor("OK",10)) return(TIME_OUT);
  1086.   delay_scr(20);
  1087.   clear_scr();
  1088.   prints("S-REGISTER- SET #SECONDS MODEM WAITS BEFORE DIALING T0 2: ATS6=2");
  1089.   cputs("ATS6=2^M");
  1090.   if (not waitfor("OK",10)) return(TIME_OUT);
  1091.   delay_scr(20);
  1092.   clear_scr();
  1093.   prints("S-REGISTER- SET #SECONDS MODEM WAITS FOR CARRIER TO 30: ATS7=30");
  1094.   cputs("ATS7=30^M");
  1095.   if (not waitfor("OK",10)) return(TIME_OUT);
  1096.   delay_scr(20);
  1097.   clear_scr();
  1098.   prints("S-REGISTER- SET DURATION OF PAUSE (,) TO 2/10TH SECOND: ATS8=2");
  1099.   cputs("ATS8=2^M");
  1100.   if (not waitfor("OK",10)) return(TIME_OUT);
  1101.   delay_scr(20);
  1102.   clear_scr();
  1103.   prints("S-REGISTER- REQUIRED DURATION OF REMOTE CARRIER 6/10TH SEC: ATS9=6");
  1104.   cputs("ATS9=6^M");
  1105.   if (not waitfor("OK",10)) return(TIME_OUT);
  1106.   delay_scr(20);
  1107.   clear_scr();
  1108.   prints("S-REGISTER- HANG UP 5 SEC AFTER LOSS OF CARRIER: ATS10=50");
  1109.   cputs("ATS10=50^M");
  1110.   if (not waitfor("OK",10)) return(TIME_OUT);
  1111.   delay_scr(20);
  1112.   clear_scr();
  1113.   prints("S-REGISTER- TOUCH-TONE DURATION AND SPACING IS 70 MILLISECS: ATS11=70");
  1114.   cputs("ATS11=70^M");
  1115.   if (not waitfor("OK",10)) return(TIME_OUT);
  1116.   delay_scr(20);
  1117.   clear_scr();
  1118.   prints("S-REGISTER- ESCAPE CODE SEQUENCE GUARD TIME IS 50 MICSSECS: ATS12=50");
  1119.   cputs("ATS12=50^M");
  1120.   if (not waitfor("OK",10)) return(TIME_OUT);
  1121.   delay_scr(20);
  1122.   clear_scr();
  1123.   prints("S-REGISTER- SET BIT-MAPPED REGISTER TO ZERO: ATS13=0");
  1124.   cputs("ATS13=0^M");
  1125.   if (not waitfor("OK",10)) return(TIME_OUT);
  1126.   delay_scr(20);
  1127.   clear_scr();
  1128.   prints("S-REGISTER- SET SELF-TEST REGISTER TO DATA MODE (NO TEST): ATS16=0");
  1129.   cputs("ATS16=0^M");
  1130.   if (not waitfor("OK",10)) return(TIME_OUT);
  1131.   delay_scr(20);
  1132.   clear_scr();
  1133.   prints("S-REGISTER- SET ARQ LINK DISCONNECT REASON REGISTER TO ZERO: ATS17=0");
  1134.   cputs("ATS17=0^M");
  1135.   if (not waitfor("OK",10)) return(TIME_OUT);
  1136.   delay_scr(20);
  1137.   clear_scr();
  1138.   if (do_pcbdef)
  1139.      {
  1140.       prints("S-REGISTER- SET INACTIVITY TIMER TO FIVE MINUTE AUTO HANGUP: ATS19=5");
  1141.       cputs("ATS19=5^M");
  1142.       if (not waitfor("OK",10)) return(TIME_OUT);
  1143.       delay_scr(20);
  1144.      }
  1145.   else
  1146.      {
  1147.       prints("S-REGISTER- SET INACTIVITY TIMER TO ZERO (NO AUTO HANGUP): ATS19=0");
  1148.       cputs("ATS19=0^M");
  1149.       if (not waitfor("OK",10)) return(TIME_OUT);
  1150.       delay_scr(20);
  1151.      }
  1152.   clear_scr();
  1153.   prints("S-REGISTER- SET NO CARRIER REASON CODE REGISTER TO ZERO: ATS20=0");
  1154.   cputs("ATS20=0^M");
  1155.   if (not waitfor("OK",10)) return(TIME_OUT);
  1156.   delay_scr(20);
  1157.   clear_scr();
  1158.   prints("S-REGISTER- SET LENGTH OF BREAKS TO 100 MILLISECONDS: ATS21=10");
  1159.   cputs("ATS21=10^M");
  1160.   if (not waitfor("OK",10)) return(TIME_OUT);
  1161.   delay_scr(20);
  1162.   clear_scr();
  1163.   prints("S-REGISTER- SET ASCII VALUE OF XON TO 17: ATS22=17");
  1164.   cputs("ATS22=17^M");
  1165.   if (not waitfor("OK",10)) return(TIME_OUT);
  1166.   delay_scr(20);
  1167.   clear_scr();
  1168.   prints("S-REGISTER- SET ASCII VALUE OF XOFF TO 19: ATS23=19");
  1169.   cputs("ATS23=19^M");
  1170.   if (not waitfor("OK",10)) return(TIME_OUT);
  1171.   delay_scr(20);
  1172.   return(write_parms());
  1173.  }
  1174.  
  1175. fast_set_telix(str rom_level)
  1176.  {
  1177.   clear_scr();
  1178.   prints("SENDING TELIX SETUP PARAMETERS TO HST MODEM.......");
  1179.   prints(" ");
  1180.   cputs("AT C1 E0 F1 M1 Q0 V1 X6 B1^M");
  1181.   if (not waitfor("OK",10)) return(TIME_OUT);
  1182.   delay_scr(20);
  1183.   cputs("AT &A1 &B1 &G0 &H1 &I0 ^M");
  1184.   if (not waitfor("OK",10)) return(TIME_OUT);
  1185.   delay_scr(20);
  1186.   if (rom_level >= "964")
  1187.      cputs("AT &K0");
  1188.   else
  1189.      cputs("AT");
  1190.   cputs(" &M4 &N0 &P0 &R2 &S1 &Y1^M");
  1191.   if (not waitfor("OK",10)) return(TIME_OUT);
  1192.   delay_scr(20);
  1193.   cputs("AT S0=0 S1=0 S2=43 S3=13 ^M");
  1194.   if (not waitfor("OK",10)) return(TIME_OUT);
  1195.   delay_scr(20);
  1196.   cputs("AT S4=10 S5=8 S6=2 S7=60 S8=2 ^M");
  1197.   if (not waitfor("OK",10)) return(TIME_OUT);
  1198.   delay_scr(20);
  1199.   cputs("AT S9=6 S10=7 S11=70 S12=50 ^M");
  1200.   if (not waitfor("OK",10)) return(TIME_OUT);
  1201.   delay_scr(20);
  1202.   cputs("AT S13=0 S16=0 S17=0 ^M");
  1203.   if (not waitfor("OK",10)) return(TIME_OUT);
  1204.   delay_scr(20);
  1205.   cputs("AT S19=0 S20=0 S21=10 S22=17 S23=19^M");
  1206.   if (not waitfor("OK",10)) return(TIME_OUT);
  1207.   delay_scr(20);
  1208.   return(write_parms());
  1209.  }
  1210.  
  1211. fast_set_pcb(str rom_level)
  1212.  {
  1213.   clear_scr();
  1214.   prints("SENDING PCBOARD SETUP PARAMETERS TO HST MODEM.......");
  1215.   prints(" ");
  1216.   cputs("AT C1 E0 F1 M0 Q0 V1 X6 B1^M");
  1217.   if (not waitfor("OK",10)) return(TIME_OUT);
  1218.   delay_scr(20);
  1219.   cputs("AT &A1 &B1 &G0 &H1 &I0 &M4 ^M");
  1220.   if (not waitfor("OK",10)) return(TIME_OUT);
  1221.   delay_scr(20);
  1222.   if (rom_level >= "964")
  1223.      cputs("AT &K0");
  1224.   else
  1225.      cputs("AT");
  1226.   cputs(" &N0 &P0 &R2 &S1 &Y1^M");
  1227.   if (not waitfor("OK",10)) return(TIME_OUT);
  1228.   delay_scr(20);
  1229.   cputs("AT S0=0 S1=1 S2=255 S3=13^M");
  1230.   if (not waitfor("OK",10)) return(TIME_OUT);
  1231.   delay_scr(20);
  1232.   cputs("AT S4=10 S5=8 S6=2 S7=30 S8=2^M");
  1233.   if (not waitfor("OK",10)) return(TIME_OUT);
  1234.   delay_scr(20);
  1235.   cputs("AT S9=6 S10=7 S11=70 S12=50^M");
  1236.   if (not waitfor("OK",10)) return(TIME_OUT);
  1237.   delay_scr(20);
  1238.   cputs("AT S13=0 S16=0 S17=0^M");
  1239.   if (not waitfor("OK",10)) return(TIME_OUT);
  1240.   delay_scr(20);
  1241.   cputs("AT S19=5 S20=0 S21=10 S22=17 S23=19^M");
  1242.   if (not waitfor("OK",10)) return(TIME_OUT);
  1243.   delay_scr(20);
  1244.   return(write_parms());
  1245.  }
  1246.  
  1247. write_parms()
  1248.  {
  1249.   str input[1];
  1250.  
  1251.   clear_scr();
  1252.   prints("ALL DEFAULTS HAVE BEEN SET....");
  1253.   prints(" ");
  1254.   prints("Y to write defaults to NRAM");
  1255.   prints("N to abort");
  1256.   gotoxy(1,5);
  1257.   printsc("Type Y/N and (Enter)   ");
  1258.   while (1)
  1259.      {
  1260.       gotoxy(22,5);
  1261.       gets(input,1);
  1262.       if (input == "n" or input == "N")
  1263.          return(CONT_OK);
  1264.       else if (input == "y" or input == "Y")
  1265.               break;
  1266.       else
  1267.          tone(400,50);
  1268.      }
  1269.  
  1270.   cputs("AT&W^M");
  1271.   if (not waitfor("OK",10)) return(TIME_OUT);
  1272.   clear_scr();
  1273.   prints("If you changed switch settings 2,3,4,5 OR 9, a hardware reset");
  1274.   prints("must be performed for the new switch settings to go into effect.");
  1275.   prints("(hardware reset can be done now or later via power-off/power-on).");
  1276.   prints(" ");
  1277.   printsc("Do you wish a hardware reset to be performed now (Y/N):   ");
  1278.  
  1279.   while (1)
  1280.      {
  1281.       gotoxy(56,4);
  1282.       gets(input,1);
  1283.       if (input == "n" or input == "N")
  1284.          return(CONT_OK);
  1285.       else if (input == "y" or input == "Y")
  1286.               break;
  1287.       else
  1288.          tone(400,50);
  1289.      }
  1290.  
  1291.   clear_scr();
  1292.   prints("RESETTING HARDWARE TO NRAM AND NEW SWITCH SETTINGS");
  1293.   cputs("ATZ^M");
  1294.   if (waitfor("OK",10))
  1295.      return(CONT_OK);
  1296.   else
  1297.      return(TIME_OUT);
  1298.  }
  1299.  
  1300. ////////////////////////////////////////////////////////////////////////
  1301. //                                                                    //
  1302. //  Function to disable MNP level 5 data compression                  //
  1303. //                                                                    //
  1304. ////////////////////////////////////////////////////////////////////////
  1305.  
  1306. disable_comp()
  1307.  {
  1308.   clear_scr();
  1309.   printsc("DISABLE MNP LEVEL 5 DATA COMPRESSION - AT&K0");
  1310.   cputs("AT&K0^M");
  1311.   if (waitfor("OK",10))
  1312.      return(CONT_OK);
  1313.   else
  1314.      return(TIME_OUT);
  1315.  }
  1316.  
  1317. ////////////////////////////////////////////////////////////////////////
  1318. //                                                                    //
  1319. //  Function to auto enable/disable MNP level 5 data compression      //
  1320. //                                                                    //
  1321. ////////////////////////////////////////////////////////////////////////
  1322.  
  1323. auto_comp()
  1324.  {
  1325.   clear_scr();
  1326.   printsc("AUTO ENABLE/DISABLE MNP LEVEL 5 DATA COMPRESSION - AT&K1");
  1327.   cputs("AT&K1^M");
  1328.   if (waitfor("OK",10))
  1329.      return(CONT_OK);
  1330.   else
  1331.      return(TIME_OUT);
  1332.  }
  1333.  
  1334. ////////////////////////////////////////////////////////////////////////
  1335. //                                                                    //
  1336. //  Function to enable MNP level 5 data compression                   //
  1337. //                                                                    //
  1338. ////////////////////////////////////////////////////////////////////////
  1339.  
  1340. enable_comp()
  1341.  {
  1342.   clear_scr();
  1343.   printsc("FORCE ENABLE MNP LEVEL 5 DATA COMPRESSION - AT&K2");
  1344.   cputs("AT&K2^M");
  1345.   if (waitfor("OK",10))
  1346.      return(CONT_OK);
  1347.   else
  1348.      return(TIME_OUT);
  1349.  }
  1350.  
  1351. ////////////////////////////////////////////////////////////////////////
  1352. //                                                                    //
  1353. //  Function displays Modem Configuration Inquiry screen              //
  1354. //                                                                    //
  1355. ////////////////////////////////////////////////////////////////////////
  1356.  
  1357. modem_inq()
  1358.  {
  1359.   clear_scr();
  1360.   printsc("MODEM CONFIGURATION INQUIRY SCREEN - ATI7");
  1361.   printsc(" ");
  1362.   cputs("ATI7^M");
  1363.   if (waitfor("OK",10))
  1364.      return(CONT_OK);
  1365.   else
  1366.      return(TIME_OUT);
  1367.  }
  1368.  
  1369. ////////////////////////////////////////////////////////////////////////
  1370. //                                                                    //
  1371. //  Function sets the S15 register                                    //
  1372. //                                                                    //
  1373. ////////////////////////////////////////////////////////////////////////
  1374.  
  1375. set_s15reg()
  1376.  {
  1377.   str input[1];
  1378.   str new_value[2];
  1379.  
  1380.   clear_scr();
  1381.   prints("ROM LEVEL 964 - S-REGISTER 15 SETTINGS");
  1382.   prints("S-register 15 controls many of the level 964 ROM features. Each bit");
  1383.   prints("in the register controls a modem feature or function, as shown below");
  1384.   prints("The corresponding bit value precedes each feature description.");
  1385.   prints("To select a feature, add its bit value to the total and store the");
  1386.   prints("the total in the register.  The max S15 value is 91 (64+16+8+2+1).");
  1387.   prints(" ");
  1388.   prints("Bit value   1: disable high-frequency equalization if it causes");
  1389.   prints("               problems on shorter-link calls");
  1390.   prints("Bit value   2: disable 7200/4800bps online fallback");
  1391.   prints("Bit value   4: Reserved");
  1392.   prints("Bit value   8: use 128-byte buffer in non-MNP operation");
  1393.   prints("Bit Value  16: disable MNP Service Class (Level 4).  Retransmitting");
  1394.   prints("               the larger level 4 data blocks may be a problem when");
  1395.   prints("               you expect a great number of errors during a call.");
  1396.   prints("Bit Value  32: Reserved");
  1397.   prints("Bit Value  64: Turn this bit on if you are unable to connect with a");
  1398.   prints("              'MNP-compatible' modem at 2400bps.  Certain MNP modems");
  1399.   prints("               are not fully compatible with the Microcom standard.");
  1400.   prints("Bit Value 128: Reserved");
  1401.   prints(" ");
  1402.   printsc("Do you wish to change the value of S-register 15 (Y/N)?");
  1403.   gets(input,1);
  1404.   if (input != "y" and input != "Y")
  1405.      return(CONT_OK);
  1406.   gotoxy(0,21);
  1407.   prints("New total bit value for S-register 15 (0-91) or <Enter> to abort:    ");
  1408.   while (1)
  1409.      {
  1410.       gotoxy(66,21);
  1411.       gets(new_value,2);
  1412.       if (new_value == "")
  1413.          return(CONT_OK);
  1414.       else if (new_value >= "0" and new_value <= "91")
  1415.               break;
  1416.       tone(400,50);
  1417.      }
  1418.   clear_scr();
  1419.   printsc("SETTING NEW S-REGISTER 15 VALUE - ATS15=");
  1420.   prints(new_value);
  1421.   cputs("ATS15=");
  1422.   cputs(new_value);
  1423.   cputs("^M");
  1424.   if (waitfor("OK",10))
  1425.      return(CONT_OK);
  1426.   else
  1427.      return(TIME_OUT);
  1428.  }
  1429.  
  1430. ////////////////////////////////////////////////////////////////////////
  1431. //                                                                    //
  1432. //  Function to list/set Modem link rate settings                     //
  1433. //                                                                    //
  1434. ////////////////////////////////////////////////////////////////////////
  1435.  
  1436. set_rate()
  1437.  {
  1438.   str input[1];
  1439.   str new_rate[4];
  1440.  
  1441.   clear_scr();
  1442.   prints("MODEM LINK RATE SETTINGS - AT&Nx");
  1443.   prints(" ");
  1444.   prints("This command allows you to set the modem LINK rate (the data rate ");
  1445.   prints("on the modem-modem connection) to a FIXED value between 300cps and");
  1446.   prints("9600cps.  Normally, the default (&N0) allows the modem to adapt its");
  1447.   prints("rate to that of the receiving modem.  Forcing a fixed link rate  ");
  1448.   prints("will cause your modem to disconnect if the other modem is not set ");
  1449.   prints("at the same rate.  Unless you have a need for this feature, use of ");
  1450.   prints("the default value is recommended.");
  1451.   prints(" ");
  1452.   prints("Do you want to change the modem's link rate setting (Y/N):   ");
  1453.   gotoxy(59,10);
  1454.   gets(input,2);
  1455.   if (input != "y" and input != "Y")
  1456.      return(CONT_OK);
  1457.   clear_scr();
  1458.   prints("CHANGE LINK RATE SETTING - AT&Nx");
  1459.   prints(" ");
  1460.   prints("0=set link rate to DEFAULT - AUTO SPEED DETECT");
  1461.   prints("1=set link rate to 300bps");
  1462.   prints("2=set link rate to 1200bps");
  1463.   prints("3=set link rate to 2400bps");
  1464.   prints("4=set link rate to 4800bps");
  1465.   prints("5=set link rate to 7200bps");
  1466.   prints("6=set link rate to 9600bps");
  1467.   gotoxy(0,10);
  1468.   prints("Enter new link rate value (0-6) or <Enter> to abort:   ");
  1469.   while (1)
  1470.      {
  1471.       gotoxy(53,10);
  1472.       gets(input,1);
  1473.       if (input == "")
  1474.          return(CONT_OK);
  1475.       else if (input == "0")
  1476.               {
  1477.                new_rate = "Auto";
  1478.                break;
  1479.               }
  1480.       else if (input == "1")
  1481.               {
  1482.                new_rate = "300";
  1483.                break;
  1484.               }
  1485.       else if (input == "2")
  1486.               {
  1487.                new_rate = "1200";
  1488.                break;
  1489.               }
  1490.       else if (input == "3")
  1491.               {
  1492.                new_rate = "2400";
  1493.                break;
  1494.               }
  1495.       else if (input == "4")
  1496.               {
  1497.                new_rate = "4800";
  1498.                break;
  1499.               }
  1500.       else if (input == "5")
  1501.               {
  1502.                new_rate = "7200";
  1503.                break;
  1504.               }
  1505.       else if (input == "6")
  1506.               {
  1507.                new_rate = "7200";
  1508.                break;
  1509.               }
  1510.       tone(400,50);
  1511.      }
  1512.  
  1513.   clear_scr();
  1514.   printsc("SETTING NEW LINK RATE TO ");
  1515.   printsc(new_rate);
  1516.   printsc(" bps: AT&N");
  1517.   prints(input);
  1518.   cputs("AT&N");
  1519.   cputs(input);
  1520.   cputs("^M");
  1521.   if (waitfor("OK",10))
  1522.      return(CONT_OK);
  1523.   else
  1524.      return(TIME_OUT);
  1525.  }
  1526.  
  1527. ////////////////////////////////////////////////////////////////////////
  1528. //                                                                    //
  1529. //  Function to display/set RAM-stored phone numbers                  //
  1530. //                                                                    //
  1531. ////////////////////////////////////////////////////////////////////////
  1532.  
  1533. disp_phone()
  1534.  {
  1535.   str num0[36];
  1536.   str num1[36];
  1537.   str num2[36];
  1538.   str num3[36];
  1539.   str change_num[1];
  1540.   str new_num[36];
  1541.  
  1542.   while (1)
  1543.      {
  1544.       num0 = "";
  1545.       num1 = "";
  1546.       num2 = "";
  1547.       num3 = "";
  1548.       clear_scr();
  1549.       printsc("RAM-STORED NUMBERS (BLANK INDICATES NO NUMBER STORED)");
  1550.       gotoxy(0,2);
  1551.       flushbuf();
  1552.       cputs("AT&Z0?^M");
  1553.       get_num(num0);
  1554.       flushbuf();
  1555.       cputs("AT&Z1?^M");
  1556.       get_num(num1);
  1557.       flushbuf();
  1558.       cputs("AT&Z2?^M");
  1559.       get_num(num2);
  1560.       flushbuf();
  1561.       cputs("AT&Z3?^M");
  1562.       get_num(num3);
  1563.  
  1564.       printsc("NUMBER 0: ");
  1565.       prints(num0);
  1566.       printsc("NUMBER 1: ");
  1567.       prints(num1);
  1568.       printsc("NUMBER 2: ");
  1569.       prints(num2);
  1570.       printsc("NUMBER 3: ");
  1571.       prints(num3);
  1572.  
  1573.       gotoxy(0,10);
  1574.       printsc("Number to change (0-3) or (Enter) to leave unchanged:   ");
  1575.       while (1)
  1576.          {
  1577.           gotoxy(54,10);
  1578.           gets(change_num,1);
  1579.           if (change_num == "")
  1580.              return(CONT_OK);
  1581.           else if (change_num >= "0" and change_num <= "3")
  1582.                   break;
  1583.           tone(400,50);
  1584.          }
  1585.  
  1586.       gotoxy(0,12);
  1587.       printsc("Enter new number (36 pos.max.) ____________________________________");
  1588.       gotoxy(31,12);
  1589.       gets(new_num,36);
  1590.       cputs("AT&Z");
  1591.       cputs(change_num);
  1592.       cputs("=");
  1593.       cputs(new_num);
  1594.       cputs("^M");
  1595.       gotoxy(0,16);
  1596.       printsc("New number has been stored in RAM at position ");
  1597.       prints(change_num);
  1598.       delay_scr(20);
  1599.      }
  1600.  }
  1601.  
  1602. get_num(str number)
  1603.  {
  1604.   int i, chr;
  1605.   str temp[5];
  1606.  
  1607.   chr = cgetct(100);
  1608.   if (chr != 13)
  1609.      prints("ERROR: Expecting CR");
  1610.   chr = cgetct(100);
  1611.   if (chr != 10)
  1612.      prints("ERROR: Expecting LF");
  1613.  
  1614.   for (i = 0; i < 36; ++i)
  1615.       {
  1616.        chr = cgetct(100);
  1617.        if (chr == 13 or chr == -1)
  1618.           {
  1619.            delay(10);
  1620.            return();
  1621.           }
  1622.        else
  1623.           setchr(number,i,chr);
  1624.       }
  1625.  }
  1626.