home *** CD-ROM | disk | FTP | other *** search
/ Prima Shareware 3 / DuCom_Prima-Shareware-3_cd1.bin / PROGRAMO / C / PERSONPR / MODEM_IO.C < prev    next >
Encoding:
C/C++ Source or Header  |  1995-02-11  |  6.7 KB  |  292 lines
  1. /*** MODEM_IO.C ***/
  2.  
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <string.h>
  6. #include <ctype.h>
  7. #include "pcl4c.h"
  8. #include "ascii.h"
  9. #include "modem_io.h"
  10. #include "term_io.h"
  11. #include "win_io.h"
  12.  
  13. #define FALSE 0
  14. #define TRUE !FALSE
  15. #define ONE_SECOND 18
  16.  
  17. /* NOTE: Requires AT COMMAND SET for all functions in this file */
  18.  
  19. static int  Debug = FALSE;
  20.  
  21. static int  LastPort;         /* last port referenced */
  22.  
  23. static char MatchString[80];  /* ModemWaitFor() match string */
  24. static int  MatchLength= 0;   /* string length */
  25. static int  MatchCount = 0;   /* # sub-strings */
  26. static struct
  27.   {char *Start;               /* ptr to 1st char of string */
  28.    char *Ptr;                 /* working ptr */
  29.   } MatchList[10];
  30.  
  31. char Temp[120];
  32.  
  33. /*** PRIVATE functions ***/
  34.  
  35. static int BreakTest(void)
  36. {/* User BREAK ? */
  37.  if(SioBrkKey()||SioKeyPress())
  38.     {WinPutString(SCR_WIN,"User BREAK\n");
  39.      return(TRUE);
  40.     }
  41.  return(FALSE);
  42. }
  43.  
  44. void MatchInit(char *S)
  45. {int  i;
  46.  char C;
  47.  char *Ptr;
  48.  MatchCount = 0;
  49.  strncpy(MatchString,S,80);
  50.  MatchLength = strlen(MatchString);
  51.  Ptr = MatchString;
  52.  MatchList[MatchCount].Start = Ptr;
  53.  MatchList[MatchCount++].Ptr = Ptr;
  54.  while(*Ptr)
  55.    {if(*Ptr=='|')
  56.       {/* mark start of next string */
  57.        MatchList[MatchCount].Start = Ptr + 1;
  58.        MatchList[MatchCount++].Ptr = Ptr + 1;
  59.       }
  60.     Ptr++;
  61.    }
  62. }
  63.  
  64. void MatchUpper(void)
  65. {int i;
  66.  char *Ptr;
  67.  Ptr = MatchString;
  68.  for(i=0;i<MatchLength;i++)
  69.    {*Ptr = toupper(*Ptr);
  70.     Ptr++;
  71.    }
  72. }
  73.  
  74. int MatchChar(char C)
  75. {int  i;
  76.  char *Ptr;
  77.  char *Start;
  78.  /* consider each string in turn */
  79.  for(i=0;i<MatchCount;i++)
  80.    {Ptr = MatchList[i].Ptr;
  81.     Start = MatchList[i].Start;
  82.     if(*Ptr==C)
  83.       {/* char C matches */
  84. #if 0
  85. sprintf(Temp,"<%c:%d:%d>",C,i,(Ptr-Start));
  86. WinPutString(SCR_WIN,Temp);
  87. #endif
  88.        Ptr++;
  89.        if((*Ptr=='|')||(*Ptr=='\0'))
  90.          {MatchList[i].Ptr = Start;
  91. #if 0
  92. sprintf(Temp,"<<%d>>",i);
  93. WinPutString(SCR_WIN,Temp);
  94. #endif
  95.           return i;
  96.          }
  97.        else MatchList[i].Ptr = Ptr;
  98.       }
  99.     else
  100.       {/* char C does NOT match */
  101.        MatchList[i].Ptr = Start;
  102.        /* look again if was not 1st char  */
  103.        if(Ptr!=Start) i--;
  104.       }
  105.    }
  106.  return -1;
  107. }
  108.  
  109. /*** PUBLIC functions ***/
  110.  
  111. /* echos incoming to screen */
  112.  
  113. void ModemEcho(int Port,int Echo)
  114. {int rc;
  115.  long Time;
  116.  Time = SioTimer();
  117.  while(SioTimer() < Time+(long)Echo)
  118.    {rc = CharGet(Port,1);
  119.     if(rc>=0) WinPutChar(SCR_WIN,(char)rc);
  120.    }
  121. }
  122.  
  123. /* send string to modem & get echo */
  124.  
  125. int ModemSendTo(
  126.   int  Port,       /* port to talk to */
  127.   int  Pace,       /* inter-char delay */
  128.   char *String)    /* string to send to modem */
  129. {int i, rc;
  130.  char c;
  131.  int Code;
  132.  long Time;
  133.  if(Debug)
  134.    {sprintf(Temp," [Sending '%s'] ",String);
  135.     WinPutString(SCR_WIN,Temp);
  136.    }
  137.  for(i=0;i<strlen(String);)
  138.     {/* User BREAK ? */
  139.      if(BreakTest()) return(FALSE);
  140.      /* delay <Pace> tics */
  141.      if(Pace>0) SioDelay(Pace);
  142.      /* fetch character */
  143.      c = String[i++];
  144.      switch(c)
  145.         {case '^':
  146.             /* next char is control char */
  147.             c = String[i++] - '@';
  148.             break;
  149.          case '!':
  150.             /* replace ! with carriage return */
  151.             c = CR;
  152.             break;
  153.          case '~':
  154.             /* delay 1/2 second */
  155.             SioDelay(ONE_SECOND/2);
  156.             c = ' ';
  157.             break;
  158.          case ' ':
  159.             /* delay 1/4 second */
  160.             SioDelay(ONE_SECOND/4);
  161.             c = ' ';
  162.             break;
  163.         } /* end switch */
  164.      /* transmit as 7 bit ASCII character */
  165.      CharPut(Port,(char)(0x7f & c));
  166.     }
  167.  return(TRUE);
  168. } /* end SendTo */
  169.  
  170. /* wait for 'String' */
  171.  
  172. /* NOTES:
  173. **  (1)  Will return NULL if no match, else '0' if 1st, '2' if 2nd, etc.
  174. **       where String = "<1st substr>|<2nd substr>| ..."
  175. **  (2)  Example call: ModemWaitFor(COM1,180,FALSE,"more ?|Menu:");
  176. */
  177.  
  178. char ModemWaitFor(
  179.   int  Port,       /* Port to talk to */
  180.   int  Tics,       /* wait in tics for string */
  181.   int  CaseFlag,   /* TRUE = case sensitive compares */
  182.   char *String)    /* string to wait for */
  183. {int i, k;
  184.  int rc;
  185.  char C;
  186.  int Code;
  187.  long Time;
  188.  /* wait for string */
  189.  Time = SioTimer();
  190.  MatchInit(String);
  191.  if(!CaseFlag) MatchUpper();
  192.  if(Debug)
  193.    {sprintf(Temp," [Awaiting '%s'] ",String);
  194.     WinPutString(SCR_WIN,Temp);
  195.    }
  196.  while(SioTimer()<(Time+(long)Tics))
  197.    {/* User BREAK ? */
  198.     if(BreakTest()) return(FALSE);
  199.     /* wait for next character */
  200.     Code = CharGet(Port,1);
  201.     if(Code<-1) return(FALSE);
  202.     if(Code>=0)
  203.       {/* echo char */
  204.        WinPutChar(SCR_WIN,(char)Code);
  205.        /* case sensitive ? */
  206.        if(CaseFlag) C = (char)Code;
  207.        else C = toupper( (char)Code );
  208.        /* does char match ? */
  209.        rc = MatchChar(C);
  210.        if(rc>=0) return ('0' + rc);
  211.       }
  212.    } /* end for(i) */
  213.  return 0;
  214. }
  215.  
  216. /* enter command state */
  217.  
  218. /* NOTE: assumes escape char = '+' & guard time = 1 sec */
  219.  
  220. void ModemCmdState(int Port)
  221. {int i;
  222.  /* delay a bit over 1 second */
  223.  SioDelay(ONE_SECOND+ONE_SECOND/4);
  224.  /* send Escape Code exactly 3 times */
  225.  for(i=0;i<3;i++)
  226.     {CharPut(Port,'+');
  227.      SioDelay(ONE_SECOND/4);
  228.     }
  229.  /* delay again */
  230.  SioDelay(ONE_SECOND+ONE_SECOND/4);
  231. } /* end ModemCmdState */
  232.  
  233. /* hangup phone (in command state) */
  234.  
  235. void ModemHangup(int Port)
  236. {/* enter command state */
  237.  ModemCmdState(Port);
  238.  /* hangup ! */
  239.  ModemSendTo(Port,4,"!AT!");
  240.  ModemEcho(Port,10);
  241.  ModemSendTo(Port,4,"ATH0!");
  242. } /* end Hangup */
  243.  
  244. /* wait for continuous quiet (no incoming serial data) */
  245.  
  246. int ModemQuiet(
  247.   int  Port,       /* Port to talk to */
  248.   int  Tics)       /* # tics quiet required */
  249. {int i;
  250.  int Code;
  251.  long CharTime;
  252.  /* set up */
  253.  CharTime = SioTimer();
  254.  while(1)
  255.    {/* User BREAK ? */
  256.     if(BreakTest())
  257.       {
  258.        return(FALSE);
  259.       }
  260.     /* wait for next character */
  261.     Code = CharGet(Port,1);
  262.     if(Code<-1) return(FALSE);
  263.     if(Code>=0)
  264.       {CharTime = SioTimer();
  265.        WinPutChar(SCR_WIN,(char)Code);
  266.       }
  267.     else
  268.       {/* ==-1, timed out */
  269.        if(SioTimer() >= CharTime+(long)Tics) return TRUE;
  270.       }
  271.    } /* end while */
  272. }
  273.  
  274. void ModemDump(void)
  275. {int i;
  276.  sprintf(Temp,"WAITFOR: Count=%d Length=%d \n",
  277.    MatchCount,MatchLength);
  278.  WinPutString(SCR_WIN,Temp);
  279.  sprintf(Temp,"   String= [0x%x] '%s'\n",MatchString,MatchString);
  280.  WinPutString(SCR_WIN,Temp);
  281.  for(i=0;i<10;i++)
  282.    {if(MatchList[i].Start==NULL) break;
  283.     sprintf(Temp,"   Start=0x%x Ptr=0x%x\n",MatchList[i].Start,MatchList[i].Ptr);
  284.     WinPutString(SCR_WIN,Temp);
  285.    }
  286. }
  287.  
  288. void ModemDebug(void)
  289. {Debug = TRUE;
  290.  WinPutString(SCR_WIN,"[DEBUG]");
  291. }
  292.