home *** CD-ROM | disk | FTP | other *** search
/ Shareware 1 2 the Maxx / sw_1.zip / sw_1 / PROGRAM / PCL4C30.ZIP / XYPACKET.C < prev   
Text File  |  1992-01-04  |  9KB  |  296 lines
  1. #include <stdio.h>
  2. #include <fcntl.h>
  3. #include <sys\types.h>
  4. #include <sys\stat.h>
  5.  
  6. #include "pcl4c.h"
  7. #include "ascii.h"
  8.  
  9. #define FALSE 0
  10. #define TRUE !FALSE
  11. #define ONESECOND 18
  12.  
  13. #define MAXTRY 5
  14. #define LIMIT 20
  15.  
  16. extern GetChar();
  17. extern PutChar();
  18. extern SayError();
  19. extern DisplayLine();
  20.  
  21. int TxPacket(Port,PacketNbr,PacketSize,Buffer,CRCflag)
  22. int Port;            /* COM port [0..3] */
  23. int PacketNbr;       /* Packet # to send */
  24. int PacketSize;      /* Packet size ( must be 128 or 1024 ) */
  25. char Buffer[];       /* Data buffer */
  26. int CRCflag;         /* use CRC if TRUE */
  27. {int  i;
  28.  int Code;
  29.  unsigned short CheckSum;
  30.  int Attempt;
  31.  int PacketType;
  32.  char temp[81];
  33.  /* begin */
  34. #if 0
  35. printf("[TxP: COM%d PacketNbr=%d PacketSize=%d CRCflag=%d]",
  36.     1+Port,PacketNbr,PacketSize,CRCflag);
  37. #endif
  38.  /* better be 128 or 1024 packet length */
  39.  if(PacketSize==1024) PacketType = STX;
  40.  else PacketType = SOH;
  41.  PacketNbr &= 0x00ff;
  42.  /* make up to MAXTRY attempts to send this packet */
  43.  for(Attempt=1;Attempt<=MAXTRY;Attempt++)
  44.      {/* send SOH/STX  */
  45.       Code = PutChar(Port,PacketType);
  46.       /* send packet # */
  47.       Code = PutChar(Port,PacketNbr);
  48.       /* send 1's complement of packet */
  49.       Code = PutChar(Port,255-PacketNbr);
  50.       /* send data */
  51.       CheckSum = 0;
  52.       for(i=0;i<PacketSize;i++)
  53.           {Code = PutChar(Port,Buffer[i]);
  54.            if(CRCflag) CheckSum = UpdateCRC(CheckSum, Buffer[i]);
  55.            else CheckSum += Buffer[i];
  56.           }
  57.       /* send checksum */
  58.       if(CRCflag)
  59.           {Code = PutChar(Port, (CheckSum>>8) & 0x00ff );
  60.            Code = PutChar(Port, CheckSum & 0x00ff );
  61.           }
  62.       else Code = PutChar(Port,CheckSum );
  63.       /* wait for receivers ACK */
  64.       Code = GetChar(Port,10*ONESECOND);
  65.       if((char)Code==CAN)
  66.           {PacketError(Port,PacketNbr,Attempt,"Canceled by remote");
  67.            return(FALSE);
  68.           }
  69.       if((char)Code==ACK) return(TRUE);
  70.       if((char)Code!=NAK)
  71.           {PacketError(Port,PacketNbr,Attempt,"Out of sync");
  72.            return(FALSE);
  73.           }
  74.       /* Attempt again */
  75.      }/* end -- for(Attempt) */
  76.  /* can't send packet ! */
  77.  SayError(Port,"packet timeout");
  78.  return(FALSE);
  79. } /* end -- TxPacket */
  80.  
  81. int RxPacket(Port,PacketNbr,PacketSizePtr,Buffer,CRCflag,EOTptr)
  82. int Port;            /* COM port [0..3] */
  83. int PacketNbr;       /* Packet # expected */
  84. int *PacketSizePtr;  /* Pointer to PacketSize received ( 128 or 1024) */
  85. char Buffer[];       /* 1024 byte data buffer */
  86. int CRCflag;         /* use CRC if TRUE */
  87. int *EOTptr;         /* Pointer to EOT flag */
  88. {int i;
  89.  int Code;
  90.  int Attempt;
  91.  int RxPacketNbr;
  92.  int RxPacketNbrComp;
  93.  unsigned short CheckSum;
  94.  unsigned short RxCheckSum;
  95.  unsigned short RxCheckSum1, RxCheckSum2;
  96.  char PacketType;
  97.  char temp[81];
  98.  /* begin */
  99. #if 0
  100. printf("[RxP: COM%d PacketNbr=%d CRCflag=%d EOTflag=%d]",
  101.     1+Port,PacketNbr,CRCflag,*EOTptr);
  102. #endif
  103.  PacketNbr &= 0x00ff;
  104.  for(Attempt=1;Attempt<=MAXTRY;Attempt++)
  105.      {/* wait for SOH / STX */
  106.       Code = GetChar(Port,10*ONESECOND);
  107.       if(Code==-1)
  108.           {PacketError(Port,PacketNbr,Attempt,"timed out waiting for sender");
  109.            return(FALSE);
  110.           }
  111.       switch((char)Code)
  112.           {
  113.            case SOH:
  114.                /* 128 byte buffer incoming */
  115.                PacketType = SOH;
  116.                *PacketSizePtr = 128;
  117.                break;
  118.            case STX:
  119.                /* 1024 byte buffer incoming */
  120.                PacketType = STX;
  121.                *PacketSizePtr = 1024;
  122.                break;
  123.            case CAN:
  124.                 /* sender has canceled ! */
  125.                 SayError(Port,"Canceled by remote");
  126.                 return(FALSE);
  127.            case EOT:
  128.                 /* all packets have been sent */
  129.                 Code = PutChar(Port,ACK);
  130.                 *EOTptr = TRUE;
  131.                 return(TRUE);
  132.            default:
  133.                 /* error ! */
  134.                 sprintf(temp,"Expecting SOH/STX/EOT/CAN not %xH",(char)Code);
  135.                 PacketError(Port,PacketNbr,Attempt,temp);
  136.                 return(FALSE);
  137.           }
  138.       /* receive packet # */
  139.       Code = GetChar(Port,ONESECOND);
  140.       if(Code==-1)
  141.         {PacketError(Port,PacketNbr,Attempt,"timed out waiting for packet #");
  142.          return(FALSE);
  143.         }
  144.       RxPacketNbr = 0x00ff & Code;
  145.       /* receive 1's complement */
  146.       Code = GetChar(Port,ONESECOND);
  147.       if(Code==-1)
  148.         {PacketError(Port,PacketNbr,Attempt,"timed out waiting for complement of packet #");
  149.          return(FALSE);
  150.         }
  151.       RxPacketNbrComp = 0x00ff & Code;
  152.       /* receive data */
  153.       CheckSum = 0;
  154.       for(i=0;i<*PacketSizePtr;i++)
  155.           {Code = GetChar(Port,ONESECOND);
  156.            if(Code==-1)
  157.                    {PacketError(Port,PacketNbr,Attempt,"timed out waiting for data for packet #");
  158.                     return(FALSE);
  159.                    }
  160.            Buffer[i] = Code;
  161.            /* compute CRC or checksum */
  162.            if(CRCflag) CheckSum = UpdateCRC(CheckSum,Code);
  163.            else CheckSum = (CheckSum + Code) & 0x00ff;
  164.           }
  165.       /* receive CRC/checksum */
  166.       if(CRCflag)
  167.           {/* receive 2 byte CRC */
  168.            Code = GetChar(Port,ONESECOND);
  169.            if(Code==-1)
  170.                    {PacketError(Port,PacketNbr,Attempt,"timed out waiting for 1st CRC byte");
  171.                     return(FALSE);
  172.                    }
  173.            RxCheckSum1 = Code & 0x00ff;
  174.            Code = GetChar(Port,ONESECOND);
  175.            if(Code==-1)
  176.                    {PacketError(Port,PacketNbr,Attempt,"timed out waiting for 2nd CRC byte");
  177.                     return(FALSE);
  178.                    }
  179.            RxCheckSum2 = Code & 0x00ff;
  180.            RxCheckSum = (RxCheckSum1<<8) | RxCheckSum2;
  181.           }
  182.       else
  183.           {/* receive one byte checksum */
  184.            Code = GetChar(Port,ONESECOND);
  185.            if(Code==-1)
  186.                    {PacketError(Port,PacketNbr,Attempt,"timed out waiting for checksum");
  187.                     return(FALSE);
  188.                    }
  189.            RxCheckSum = Code & 0x00ff;
  190.           }
  191.       /* packet # and checksum OK ? */
  192.       if((RxCheckSum==CheckSum)&&(RxPacketNbr==PacketNbr))
  193.           {/* ACK the packet */
  194.            PutChar(Port,ACK);
  195.            return(TRUE);
  196.           } /* end if */
  197.       /* bad packet */
  198.       DisplayLine("Bad Packet",NULL,0);
  199.       Code = PutChar(Port,NAK);
  200.      } /* end -- for(Attempt) */
  201.  /* can't receive packet */
  202.  SayError(Port,"RX packet timeout");
  203.  return(FALSE);
  204. } /* end -- RxPacket */
  205.  
  206. PacketError(Port,Packet,Attempt,MsgPtr)
  207. int Port;
  208. int Packet;
  209. int Attempt;
  210. char *MsgPtr;
  211. {char temp[81];
  212.  sprintf(temp,"Packet %d : Attempt %d : %s",Packet,Attempt,MsgPtr);
  213.  return( SayError(Port,temp) );
  214. }
  215.  
  216. int TxStartup(Port,CRCflagPtr)
  217. int Port;
  218. int *CRCflagPtr;
  219. {int i;
  220.  int Code;
  221.  /* clear Rx buffer */
  222.  SioRxFlush(Port);
  223.  /* wait for receivers start up NAK or 'C' */
  224.  for(i=1;i<LIMIT;i++)
  225.      {if(SioKeyPress())
  226.           {SayError(Port,"Aborted by user");
  227.            return(FALSE);
  228.           }
  229.       Code = GetChar(Port,3*ONESECOND);
  230.       if(Code==-1) continue;
  231.       /* received a byte */
  232.       if((char)Code==NAK)
  233.           {*CRCflagPtr = FALSE;
  234. #if 0
  235.            printf("### TxStartup(CS) OK\n");
  236. #endif
  237.            return(TRUE);
  238.           }
  239.       if((char)Code=='C')
  240.           {*CRCflagPtr = TRUE;
  241. #if 0
  242.            printf("### TxStartup(CRC) OK\n");
  243. #endif
  244.            return(TRUE);
  245.           }
  246.      } /* end -- for(i) */
  247.  /* no response */
  248.  SayError(Port,"No response from receiver");
  249.  return(FALSE);
  250. } /* end -- TxStartup */
  251.  
  252.  
  253. int RxStartup(Port,CRCflagPtr)
  254. int Port;
  255. int *CRCflagPtr;
  256. {int i;
  257.  int Code;
  258.  /* clear Rx buffer */
  259.  SioRxFlush(Port);
  260.  /* Send NAKs or 'C's */
  261.  for(i=1;i<LIMIT;i++)
  262.      {if(SioKeyPress())
  263.           {SayError(Port,"Canceled by user");
  264.            return(FALSE);
  265.           }
  266.       /* stop attempting CRC after 1st 4 tries */
  267.       if((*CRCflagPtr)&&(i==5)) *CRCflagPtr = FALSE;
  268.       /* tell sender that I am ready to receive */
  269.       if(*CRCflagPtr) Code = PutChar(Port,'C');
  270.       else Code = PutChar(Port,NAK);
  271.       Code = GetChar(Port,3*ONESECOND);
  272.       if(Code==-1) continue;
  273.       /* no error -- must be incoming byte -- push byte back onto queue ! */
  274.       SioUnGetc(Port,Code);
  275. #if 0
  276.       printf("### RxStartup OK\n");
  277. #endif
  278.       return(TRUE);
  279.      } /* end -- for(i) */
  280.  /* no response */
  281.  SayError(Port,"No response from sender");
  282.  return(FALSE);
  283. } /* end -- RxStartup */
  284.  
  285. int TxEOT(Port)
  286. int Port;
  287. {int i;
  288.  int Code;
  289.  for(i=0;i<10;i++)
  290.      {Code = PutChar(Port,EOT);
  291.       /* await response */
  292.       Code = GetChar(Port,3*ONESECOND);
  293.       if((char)Code==ACK) return(TRUE);
  294.      } /* end -- for(i) */
  295.   return(FALSE);
  296.  } /* end -- TxEOT */