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