C   10

HOST.C

Guest on 18th August 2021 03:19:29 PM

  1. /*
  2. *       This is an unsupported piece of test code written by Alan Craven
  3. *       of SSD ltd. to aid testing of COMMS links. It is designed to run on
  4. *       an IBM PC-XT with 640k of RAM using COM1 to COM4 as the serial link.
  5. *       If you wish to port this to another machine it should be noted that
  6. *       the code talks directly to hardware addresses. If any problems occur
  7. *       please contact Alan Craven who may be able to help. The code was
  8. *       produced by the BORLAND C++ compiler using their libraries.
  9. *       You will notice that the comments and documentation are minimal!!!
  10. *       This code was evolved rather than planned thus is not well structured.
  11. *       If anybody wishes to try and rectify this I am happy to help with any
  12. *       problems in understanding the code as it exists.
  13. *       GOOD LUCK!!!!
  14. */
  15. #include        "h:\bc4\include\stdio.h"
  16. #include        <dos.h>
  17. #include        <time.h>
  18. #define STX 0x02
  19. #define ETX 0x03
  20. #define EOT 0x04
  21. #define ENQ 0x05
  22. #define ACK 0x06
  23. #define LF  0x0a
  24. #define CR  0x0d
  25. #define NAK 0x15
  26. #define TRUE 0x20
  27. #define FALSE 0x40
  28. #define LOOPTIME 529.0
  29. int     COM_STATUS;
  30. int     COM_DATA;
  31. int     COM_REG1;
  32. int     COM_REG2;
  33. char    list,gid,uid;
  34. char    buf[80];
  35. char    buf2[80],txbuf[20],rxbuf[20],*pnt;
  36. char    seqbuf[100][20],filename[80],num[80];
  37. int     i,j,count,maxcount;
  38. float   repcount;
  39. float   getfloat();
  40. FILE    *fopen(),*fp;
  41. int     main();
  42. void    ack();
  43. void    address();
  44. void    baud();
  45. void    fast();
  46. void    format(char *,char *,char,char);
  47. void    getinput(char *,FILE *);
  48. void    help();
  49. void    listing();
  50. void    nak();
  51. void    nolist();
  52. void    oput_reply(char *);
  53. void    poll(char *,char *);
  54. void    repeat();
  55. void    select(char *,char *);
  56. void    sequence();
  57. void    sys();
  58. void    wait_time(float);
  59.  
  60.  
  61. int     main(int argc, char *argv[])
  62.         {
  63.         if(argc==2)
  64.                 {
  65.                 switch(atoi(argv[1]))
  66.                         {
  67.                         case 1:
  68.                                 COM_STATUS=     0x3fd;
  69.                                 COM_DATA=       0x3f8;
  70.                                 COM_REG1=       0x3f9;
  71.                                 COM_REG2=       0x3fb;
  72.                                 break;
  73.                         case 2:
  74.                                 COM_STATUS=     0x2fd;
  75.                                 COM_DATA=       0x2f8;
  76.                                 COM_REG1=       0x2f9;
  77.                                 COM_REG2=       0x2fb;
  78.                                 break;
  79.                         case 3:
  80.                                 COM_STATUS=     0x3ed;
  81.                                 COM_DATA=       0x3e8;
  82.                                 COM_REG1=       0x3e9;
  83.                                 COM_REG2=       0x3eb;
  84.                                 break;
  85.                         case 4:
  86.                                 COM_STATUS=     0x2ed;
  87.                                 COM_DATA=       0x2e8;
  88.                                 COM_REG1=       0x2e9;
  89.                                 COM_REG2=       0x2eb;
  90.                                 break;
  91.                         default :
  92.                                 printf("Usage: HOST <COM PORT>\n");
  93.                                 printf("Where COM PORT is a number between 1 and 4\n");
  94.                                 printf("to use com ports 1 to 4.\n\n\n");
  95.                                 exit(0);
  96.                         }
  97.                 }
  98.         else
  99.                 {
  100.                 COM_STATUS=     0x3fd;
  101.                 COM_DATA=       0x3f8;
  102.                 COM_REG1=       0x3f9;
  103.                 COM_REG2=       0x3fb;
  104.                 system("CLS");
  105.                 printf("\n\n\n\n\nDefaulting to COM PORT 1.\n\n\n");
  106.                 system("PAUSE");
  107.                 }
  108.         outp(COM_REG2,0x80);    /* these lines talk directly to the ibm's */
  109.         outp(COM_DATA,0x0c);    /* uart to set it up to be 9600 baud, 7 bit data, */
  110.         outp(COM_REG1,0x00);    /* even parity, 1 start bit & 1 stop bit. */
  111.         outp(COM_REG2,0x1a);
  112.         system("CLS");          /* introduction message */
  113.         printf("                         HOST EMULATOR.\n");
  114.         printf("                         ==============\n");
  115.         printf("                           SSD  LTD.\n");
  116.         printf("                           =========\n\n\n\n");
  117.         printf("Input instrument address > ");/* set up the instrument address */
  118.         getinput(&buf[0],stdin);              /* get initial unit address */
  119.         gid=buf[0];
  120.         uid=buf[1];
  121.         printf("\n");
  122.         list = FALSE;
  123.         for(i=0;i==19;i++)
  124.                 {                       /* initialise a few buffers */
  125.                 buf[i]=0;
  126.                 buf2[i]=0;
  127.                 txbuf[i]=0;
  128.                 rxbuf[i]=0;
  129.                 }
  130. /*
  131. *       This is the main loop which waits for an input line and then calls
  132. *       the relevant handler.
  133. */
  134.         while(1)
  135.                 {
  136.                 printf("host>");
  137.                 getinput(&buf[0],stdin);
  138.                 if(strcmp(&buf[0],"EXIT")==0)
  139.                         exit(0);
  140.                 if(strcmp(&buf[0],"exit")==0)exit(0);
  141.                 else if(strcmp(&buf[0],"ACK")==0)ack();
  142.                 else if(strcmp(&buf[0],"ack")==0)ack();
  143.                 else if(strcmp(&buf[0],"NAK")==0)nak();
  144.                 else if(strcmp(&buf[0],"nak")==0)nak();
  145.                 else if(strcmp(&buf[0],"SYS")==0)sys();
  146.                 else if(strcmp(&buf[0],"sys")==0)sys();
  147.                 else if(strcmp(&buf[0],"LIST")==0)listing();
  148.                 else if(strcmp(&buf[0],"list")==0)listing();
  149.                 else if(strcmp(&buf[0],"NOLIST")==0)nolist();
  150.                 else if(strcmp(&buf[0],"nolist")==0)nolist();
  151.                 else if(strcmp(&buf[0],"")==0);              /* catch line feeds */
  152.                 else if(strcmp(&buf[0],"HELP")==0)help();
  153.                 else if(strcmp(&buf[0],"help")==0)help();
  154.                 else if(strcmp(&buf[0],"REP")==0)repeat();
  155.                 else if(strcmp(&buf[0],"rep")==0)repeat();
  156.                 else if(strcmp(&buf[0],"SEQ")==0)sequence();
  157.                 else if(strcmp(&buf[0],"seq")==0)sequence();
  158.                 else if(strcmp(&buf[0],"FAST")==0)fast();
  159.                 else if(strcmp(&buf[0],"fast")==0)fast();
  160.                 else if(strcmp(&buf[0],"SAVE")==0)save();
  161.                 else if(strcmp(&buf[0],"save")==0)save();
  162.                 else if(strcmp(&buf[0],"LOAD")==0)load();
  163.                 else if(strcmp(&buf[0],"load")==0)load();
  164.                 else if(strcmp(&buf[0],"BAUD")==0)baud();
  165.                 else if(strcmp(&buf[0],"baud")==0)baud();
  166.                 else if(buf[0]=='*')address();
  167.                 else
  168. /*
  169. *       This bit deals with messages that need to be sent to the slave
  170. *       device.
  171. */
  172.                         {
  173.                         if(buf[0]=='#')
  174.                                 {           /* repeat last command */
  175.                                 j=send_mess(&txbuf[0]);
  176.                                 }
  177.                         else
  178.                                 {                     /* format and send a command */
  179.                                 format(&buf[0],&txbuf[0],gid,uid);
  180.                                 j=send_mess(&txbuf[0]);
  181.                                 }
  182.                         if(j == 0)
  183.                                 {                /* look for a reply */
  184.                                 if(!rcve_reply(&rxbuf[0]))
  185.                                         {
  186.                                         if(rxbuf[1] < ACK)
  187.                                                 oput_reply(&rxbuf[2]);
  188.                                         else
  189.                                                 oput_reply(&rxbuf[1]);
  190.                                         }
  191.                                 }
  192.                         }
  193.                 }
  194.         }
  195. /*
  196. *       A small routine to transmit an ACK to the slave.
  197. */
  198. void ack()
  199.         {
  200.         char *ptr;
  201.         txbuf[0] = ACK;
  202.         txbuf[1] = (char)NULL;
  203.         ptr = &txbuf[0];
  204.         while(*ptr)
  205.                 {
  206.                 while(((j=inp(COM_STATUS))&0x0020)==0)
  207.                         ;/* is ibm uart ready */
  208.                 outp(COM_DATA,*ptr++); /* yes so output character */
  209.                 }
  210.         if(list == TRUE)
  211.                 {
  212.                 fprintf(fp,"%c%c        ",gid,uid);
  213.                 fprintf(fp,"ACK");
  214.                 fputc(0x09,fp);
  215.                 fputc(0x09,fp);
  216.                 }
  217.         if(!rcve_reply(&rxbuf[0]))
  218.                 {
  219.                 if(rxbuf[1] < ACK)
  220.                         oput_reply(&rxbuf[2]);
  221.                 else
  222.                         oput_reply(&rxbuf[1]);
  223.                 }
  224.         }
  225.  
  226.  
  227. void address()               /* change unit address */
  228.         {
  229.         gid=buf[1];
  230.         uid=buf[2];
  231.         printf("\nInstrument address is now %c%c\n\n",gid,uid);
  232.         }
  233.  
  234.  
  235. void baud()                  /* set the link baud rate */
  236.         {
  237.         printf("Input required baud rate >");
  238.         getinput(&buf[0],stdin);
  239.         if(strcmp(&buf[0],"110")==0)system("mode com1:110,e,7,2 > null");
  240.         else if(strcmp(&buf[0],"300")==0)system("mode com1:300,e,7,1 > null");
  241.         else if(strcmp(&buf[0],"600")==0)system("mode com1:600,e,7,1 > null");
  242.         else if(strcmp(&buf[0],"1200")==0)system("mode com1:1200,e,7,1 > null");
  243.         else if(strcmp(&buf[0],"2400")==0)system("mode com1:2400,e,7,1 > null");
  244.         else if(strcmp(&buf[0],"4800")==0)system("mode com1:4800,e,7,1 > null");
  245.         else if(strcmp(&buf[0],"9600")==0)system("mode com1:9600,e,7,1 > null");
  246.         system("del null");
  247.         printf("BAUD rate set to %s\n",&buf[0]);
  248.         }
  249.  
  250. /*
  251. *       Implements fast access to the drive, i.e. it does not send the
  252. *       instrument address for each message in the sequence.
  253. */
  254. void fast()
  255.         {
  256.         printf("Is fast sequence loaded [y/n]? >");
  257.         getinput(&buf[0],stdin);
  258.         if((buf[0] != 'y')&&(buf[0] != 'Y'))
  259.                 {
  260.                 count=0;
  261.                 for(printf("input fast sequence >"),
  262.                         getinput(&buf[0],stdin)
  263.                         ;
  264.                         ((strcmp(&buf[0],"END")!=0)&&(strcmp(&buf[0],"end")!=0))
  265.                         ;
  266.                         strcpy(&seqbuf[count][0],&buf[0]),
  267.                         printf("input fast sequence >"),
  268.                         getinput(&buf[0],stdin),
  269.                         count++
  270.                         )
  271.                                 ;
  272.                 maxcount=count-1;
  273.                 }
  274.         printf("Fast - input repeat number >");
  275.         getinput(&num[0],stdin);
  276.         for(repcount=getfloat(&num[0]);repcount>0.0;repcount -= 1.0)
  277.                 {
  278.                 printf("\nSequence count = %6.0f\n",repcount);
  279.                 for(count=0;count<=maxcount;count++)
  280.                         {
  281.                         strcpy(&buf[0],&seqbuf[count][0]);
  282.                         printf("%s\n",&buf[0]);
  283.                         if(buf[0] == '*')
  284.                                 address();
  285.                         else
  286.                                 {
  287.                                 format(&buf[0],&txbuf[0],gid,uid);
  288.                                 if(count==0)
  289.                                         j=send_mess(&txbuf[0]);
  290.                                 else
  291.                                         j=send_mess(&txbuf[5]);
  292.                                 if(j == 0)
  293.                                         {
  294.                                         if(!rcve_reply(&rxbuf[0]))
  295.                                                 {
  296.                                                 if(rxbuf[1] < ACK)
  297.                                                         oput_reply(&rxbuf[2]);
  298.                                                 else
  299.                                                         oput_reply(&rxbuf[1]);
  300.                                                 }
  301.                                         }
  302.                                 }
  303.                         }
  304.                 }
  305.         }
  306.  
  307.  
  308. void format(mesbuf,txbuf,gid,uid) /* routine that puts the message into either */
  309. char    *mesbuf,*txbuf,gid,uid;     /* select format or poll format */
  310.         {
  311.         *txbuf++ = EOT;
  312.         *txbuf++ =gid;
  313.         *txbuf++ =gid;
  314.         *txbuf++ =uid;
  315.         *txbuf++ =uid;
  316.         if(*mesbuf++ == '?')
  317.                 poll(mesbuf,txbuf);  /* put into poll format */
  318.         else
  319.                 select(--mesbuf,txbuf);  /* put into select format */
  320.         }
  321.  
  322.  
  323. float getfloat(bufpnt) /* gets a floating point number from the input buffer */
  324. char    *bufpnt;
  325.         {
  326.         float   val;
  327.         val = 0.0;
  328.         while(*bufpnt)
  329.                 {
  330.                 val *= 10.0;
  331.                 val += (float)(*bufpnt++ & 0x0f);
  332.                 }
  333.         return(val);
  334.         }
  335.  
  336.  
  337. void getinput(bufpnt,ifp) /* routine that gets an input line */
  338. char    *bufpnt;
  339. FILE    *ifp;
  340.         {
  341.         while((*bufpnt++ =getc(ifp))!= LF);
  342.         *--bufpnt= (char)NULL;
  343.         }
  344.  
  345.  
  346. void help()          /* prints out a help screen */
  347.         {
  348.         system("cls");
  349.         printf("                      IDI HOST EMULATOR.\n");
  350.         printf("                      ==================\n\n");
  351.         printf("COMMANDS\n");
  352.         printf("        BAUD    Allows selection of baud rate for the serial link\n");
  353.         printf("        FAST    As per SEQ but the first message send includes GID and UID\n");
  354.         printf("                and all subsequent messages in the sequence do not.\n");
  355.         printf("        HELP    Displays this screen\n");
  356.         printf("        LIST    All serial I/O is recorded in the filename asked for.\n");
  357.         printf("        LOAD    Allows a sequence of commands to be loaded from a file.\n");
  358.         printf("        NOLIST  Turns of I/O recording.\n");
  359.         printf("        REP     Allows a single command to be repeatedly sent to the slave.\n");
  360.         printf("                It requests a command and a repeat number, range 0 - 999999.\n");
  361.         printf("                The repeat command prompt = rephost>\n");
  362.         printf("        SAVE    Allows a sequence of commands to be saved into a file\n");
  363.         printf("        SEQ     Allows a sequence of commands to be repeatedly sent to the\n");
  364.         printf("                slave. It requests a sequence of commands and a repeat number.\n");
  365.         printf("                Up to 100 commands are allowed in the sequence.\n");
  366.         printf("                The sequence command prompt = input sequence >\n");
  367.         printf("                The sequence terminator is 'END'\n");
  368.         printf("        SYS     Allows user to issue DOS commands.\n");
  369.         printf("        WAITn   Waits for n seconds, where n is an integer, range 0 - 999999\n");
  370.         printf("\n(..more..)\nHIT RETURN TO CONTINUE.....");
  371.         getinput(&buf[0],stdin);
  372.         system("cls");
  373.         printf("                      IDI HOST EMULATOR.\n");
  374.         printf("                      ==================\n\n\n\n");
  375.         printf("COMMANDS\n");
  376.         printf("        #       Repeats the last command sent.\n");
  377.         printf("        *45     Sets the slave address to be 45\n");
  378.         printf("        SS50.0  Sets parameter SS to be 50.0\n");
  379.         printf("        ?SS     Requests the value of parameter SS\n");
  380.         printf("        ES      Sends the command ES with no data\n");
  381.         printf("        ACK     Sends an ACK to the slave\n");
  382.         printf("        NAK     Sends a NAK to the slave\n");
  383.         printf("\n      NOTE:- The host emulator routine is case sensitive.\n");
  384.         printf("\nHIT RETURN TO CONTINUE.....");
  385.         getinput(&buf[0],stdin);
  386.         system("cls");
  387.         printf("                      IDI HOST EMULATOR.\n");
  388.         printf("                      ==================\n\n\n\n");
  389.         }
  390.  
  391.  
  392. void listing()        /* allows all i/o to be listed in a file or to a device */
  393.         {
  394.         printf("Input filename >");
  395.         getinput(&filename[0],stdin);
  396.         if((fp = fopen(&filename[0],"w")) == NULL)
  397.                 {
  398.                 printf("Unable to open file %s\n",&filename[0]);
  399.                 }
  400.         list = TRUE;
  401.         }
  402.  
  403. /*
  404. *       Loads a text file into the sequence buffer.
  405. */
  406.  
  407. load()
  408.         {
  409.         printf("Input filename >");
  410.         getinput(&filename[0],stdin);
  411.         if((fp=fopen(&filename[0],"r"))==NULL)
  412.                 {
  413.                 printf("Unable to open file %s",&filename[0]);
  414.                 return(1);
  415.                 }
  416.         for(count=0
  417.                 ;
  418.                 ((strcmp(&seqbuf[count-1][0],"END")!=0)&&(strcmp(&seqbuf[count-1][0],"end")!=0))
  419.                 ;
  420.                 getinput(&seqbuf[count][0],fp),count++);
  421.         maxcount=count-2;
  422.         fclose(fp);
  423.         return(0);
  424.         }
  425.  
  426. /*
  427. *       Sends a NAK out to the instrument.
  428. */
  429. void nak()
  430.         {
  431.         char *ptr;
  432.         txbuf[0] = NAK;
  433.         txbuf[1] = NULL;
  434.         ptr = &txbuf[0];
  435.         while(*ptr)
  436.                 {
  437.                 while(((j=inp(COM_STATUS))&0x0020)==0)
  438.                         ;/* is ibm uart ready */
  439.                 outp(COM_DATA,*ptr++); /* yes so output character */
  440.                 }
  441.         if(list == TRUE)
  442.                 {
  443.                 fprintf(fp,"%c%c        ",gid,uid);
  444.                 fprintf(fp,"NAK");
  445.                 fputc(0x09,fp);
  446.                 fputc(0x09,fp);
  447.                 }
  448.         if(!rcve_reply(&rxbuf[0]))
  449.                 {
  450.                 if(rxbuf[1] < ACK)
  451.                         oput_reply(&rxbuf[2]);
  452.                 else
  453.                         oput_reply(&rxbuf[1]);
  454.                 }
  455.         }
  456.  
  457.  
  458. void nolist()        /* switches off listing */
  459.         {
  460.         if(fclose(fp) == -1)
  461.                 {
  462.                 printf("Unable to close file %s\n",&filename[0]);
  463.                 }
  464.         list = FALSE;
  465.         }
  466.  
  467.  
  468. void oput_reply(bufpnt) /* output reply onto the terminal */
  469. char    *bufpnt;
  470.         {
  471.         printf("%s\n",bufpnt);
  472.         if(list == TRUE)
  473.                 fprintf(fp,"%s\n",bufpnt);
  474.         }
  475.  
  476.  
  477. void poll(mesbuf,txbuf) /* put a message into poll format */
  478. char    *mesbuf,*txbuf;
  479.         {
  480.         *txbuf++ =*mesbuf++;
  481.         *txbuf++ =*mesbuf++;
  482.         *txbuf++ = ENQ;
  483.         *txbuf   = NULL;
  484.         }
  485.  
  486.  
  487. rcve_reply(bufpnt)   /* this collects the reply from the slave */
  488. char    *bufpnt;
  489.         {
  490.         int     i,k;
  491.         k=0;
  492.         for(i=0;i<7000;i++)
  493.                 {     /* message timeout loop */
  494.                 if((inp(COM_STATUS))&0x0001)
  495.                         {    /* is there a char ready */
  496.                         i=0;
  497.                         *bufpnt=inp(COM_DATA);   /* if yes then get it */
  498.                         if(k)
  499.                                 return(0);
  500.                         if(*bufpnt == ETX)
  501.                                 {
  502.                                 k=1;
  503.                                 *bufpnt= NULL;
  504.                                 }
  505.                         if(*bufpnt == ACK)
  506.                                 {   /* translate an ACK into a string */
  507.                                 *bufpnt++ = NULL;
  508.                                 *bufpnt++ ='A';
  509.                                 *bufpnt++ ='C';
  510.                                 *bufpnt++ ='K';
  511.                                 *bufpnt = NULL;
  512.                                 return(0);
  513.                                 }
  514.                         if(*bufpnt == NAK)
  515.                                 {   /* translate a NAK into a string */
  516.                                 *bufpnt++ = NULL;
  517.                                 *bufpnt++ ='N';
  518.                                 *bufpnt++ ='A';
  519.                                 *bufpnt++ ='K';
  520.                                 *bufpnt = NULL;
  521.                                 return(0);
  522.                                 }
  523.                         if(*bufpnt == EOT)
  524.                                 {   /* translate an EOT into a string */
  525.                                 *bufpnt++ = NULL;
  526.                                 *bufpnt++ ='E';
  527.                                 *bufpnt++ ='O';
  528.                                 *bufpnt++ ='T';
  529.                                 *bufpnt = NULL;
  530.                                 return(0);
  531.                                 }
  532.                         bufpnt++;
  533.                         }
  534.                 }
  535.         printf("Message timeout \n\n"); /* no message received */
  536.         if(list == TRUE)
  537.                 fprintf(fp,"Message timeout\n");
  538.         return(1);
  539.         }
  540.  
  541.  
  542. void repeat()     /* repeats a single command 'repcount' times */
  543.         {
  544.         printf("rephost>");
  545.         getinput(&buf[0],stdin);
  546.         if(buf[0] != '#')
  547.                 format(&buf[0],&txbuf[0],gid,uid);
  548.         printf("rephost - input repeat number >");
  549.         getinput(&num[0],stdin);
  550.         for(repcount=getfloat(&num[0]);repcount>0.0;repcount -= 1.0)
  551.                 {
  552.                 j=send_mess(&txbuf[0]);
  553.                 if(j == 0)
  554.                         {
  555.                         if(!rcve_reply(&rxbuf[0]))
  556.                                 {
  557.                                 if(rxbuf[1] < ACK)
  558.                                         oput_reply(&rxbuf[2]);
  559.                                 else
  560.                                         oput_reply(&rxbuf[1]);
  561.                                 }
  562.                         }
  563.                 }
  564.         }
  565.  
  566. /*
  567. *       Saves the contents of the sequence buffer as a text file.
  568. */
  569. save()
  570.         {
  571.         printf("Input file name >");
  572.         getinput(&filename[0],stdin);
  573.         if((fp=fopen(&filename[0],"w"))==NULL)
  574.                 {
  575.                 printf("Unable to open file %s\n",&filename[0]);
  576.                 return(1);
  577.                 }
  578.         for(count=0;count<=maxcount;count++)
  579.                 {
  580.                 fprintf(fp,"%s",&seqbuf[count][0]);
  581.                 fprintf(fp,"\n");
  582.                 }
  583.         fprintf(fp,"END\n");
  584.         fclose(fp);
  585.         return(0);
  586.         }
  587.  
  588.  
  589. void select(mesbuf,txbuf) /* put a message into select format */
  590. char    *mesbuf,*txbuf;
  591.         {
  592.         *txbuf++ = STX;
  593.         while(*mesbuf)
  594.                 *txbuf++ = *mesbuf++;
  595.         *txbuf++ = ETX;
  596.         *txbuf   = NULL;
  597.         }
  598.  
  599.  
  600. send_mess(bufpnt)   /* this outputs the message on an RS232 link */
  601. char    *bufpnt;
  602.         {
  603.         int     i;
  604.         char    bcc,*ptr;
  605.         float   time;
  606.         ptr = bufpnt;
  607.         while((*ptr!=STX)&&(*ptr!=ENQ))
  608.                 ptr++;
  609.         ptr++;
  610.         i=0;
  611.         time = 0.0;
  612.         if((*ptr == 'W')||(*ptr == 'w'))
  613.                 {  /* this bit detects wait commands */
  614.                 ptr++;
  615.                 if((*ptr == 'A')||(*ptr == 'a'))
  616.                         {
  617.                         ptr++;
  618.                         if((*ptr == 'I')||(*ptr == 'i'))
  619.                                 {
  620.                                 ptr++;
  621.                                 if((*ptr == 'T')||(*ptr == 't'))
  622.                                         {
  623.                                         ptr++;
  624.                                         while(*ptr)
  625.                                                 {
  626.                                                 if(*ptr != ETX)
  627.                                                         {
  628.                                                         time += (float)(*ptr & 0x0f);
  629.                                                         time *= 10.0;
  630.                                                         }
  631.                                                 ptr++;
  632.                                                 }
  633.                                         time /= 10.0;
  634.                                         wait_time(time);
  635.                                         return(1);
  636.                                         }
  637.                                 }
  638.                         }
  639.                 }
  640.         bcc=0;  /* if not a wait it is output and a bcc is calculated */
  641.         while(*bufpnt)
  642.                 {
  643.                 if(i)
  644.                         bcc=bcc^*bufpnt;
  645.                 if(*bufpnt== STX)
  646.                         i=1;
  647.                 while(((inp(COM_STATUS))&0x0020)==0)
  648.                         ;/* is ibm uart ready */
  649.                 outp(COM_DATA,*bufpnt++); /* yes so output character */
  650.                 }
  651.         bufpnt--;
  652.         if(i)
  653.                 {     /* if not a poll then output the bcc */
  654.                 while(((inp(COM_STATUS))&0x0020)==0)
  655.                         ;
  656.                 outp(COM_DATA,bcc);
  657.                 }
  658.         if(list == TRUE)
  659.                 {
  660.                 fprintf(fp,"%c%c        ",gid,uid);
  661.                 fprintf(fp,"%s",&buf[0]);
  662.                 fputc(0x09,fp);
  663.                 fputc(0x09,fp);
  664.                 }
  665.         return(0);
  666.         }
  667.  
  668.  
  669. void sequence()   /* repeats a sequence of commands 'repcount' times */
  670.         {
  671.         printf("Is sequence loaded ? [y/n]>");
  672.         getinput(&buf[0],stdin);
  673.         if((buf[0] != 'y')&&(buf[0] != 'Y'))
  674.                 {
  675.                 count=0;
  676.                 for(printf("input sequence >"),
  677.                         getinput(&buf[0],stdin)
  678.                         ;
  679.                         ((strcmp(&buf[0],"END")!=0)&&(strcmp(&buf[0],"end")!=0))
  680.                         ;
  681.                         strcpy(&seqbuf[count][0],&buf[0]),
  682.                         printf("input sequence >"),
  683.                         getinput(&buf[0],stdin),
  684.                         count++
  685.                         )
  686.                                 ;
  687.                 maxcount=count-1;
  688.                 }
  689.         printf("seqhost - input repeat number >");
  690.         getinput(&num[0],stdin);
  691.         for(repcount=getfloat(&num[0]);repcount>0.0;repcount -= 1.0)
  692.                 {
  693.                 printf("\nSequence count = %6.0f\n",repcount);
  694.                 for(count=0;count<=maxcount;count++)
  695.                         {
  696.                         strcpy(&buf[0],&seqbuf[count][0]);
  697.                         printf("%s\n",&buf[0]);
  698.                         if(buf[0] == '*')
  699.                                 address();
  700.                         else
  701.                                 {
  702.                                 format(&buf[0],&txbuf[0],gid,uid);
  703.                                 j=send_mess(&txbuf[0]);
  704.                                 if(j == 0)
  705.                                         {
  706.                                         if(!rcve_reply(&rxbuf[0]))
  707.                                                 {
  708.                                                 if(rxbuf[1] < ACK)
  709.                                                         oput_reply(&rxbuf[2]);
  710.                                                 else
  711.                                                         oput_reply(&rxbuf[1]);
  712.                                                 }
  713.                                         }
  714.                                 }
  715.                         }
  716.                 }
  717.         }
  718.  
  719.  
  720. void sys()    /* outputs a DOS command */
  721.         {
  722.         printf("Input command >");
  723.         getinput(&buf[0],stdin);
  724.         system(&buf[0]);
  725.         }
  726.  
  727.  
  728. void wait_time(float time)  /* waits in this routine for "time" seconds */
  729.         {
  730.         float   loop;
  731.         clock_t start;
  732.         clock_t time_now;
  733.         printf("WAITING FOR = %1.0f SECONDS.\n",time);
  734.         while(time > 0.0)
  735.                 {
  736.                 start = clock();
  737.                 time_now = clock();
  738.                 while(time_now < start+18)
  739.                         {
  740.                         time_now = clock();
  741.                         }
  742.                 time -= 1.0;
  743.                 printf("%c%6.0f",CR,time);
  744.                 fflush(stdout);
  745.                 }
  746.         printf("\n");
  747.         }

Raw Paste


Login or Register to edit or fork this paste. It's free.