wincelnk.c

DALLAS 1 Wire 总线 SDK 支持多种高级语言

   // small delay
   Sleep(0);//(3.11)

   // write the byte (string of bits)
   fReadStat = ReadFile(ComID[Prt], (LPSTR) inbuf, inlen, &dwLength,
                        NULL);

   // check for less read (3.11)
   if ((fReadStat == 1) && (dwLength != (unsigned short)inlen))
   {
      temp_len = dwLength;
      Sleep(10);
      fReadStat = ReadFile(ComID[Prt], (LPSTR)&inbuf[temp_len], inlen - temp_len, &dwLength,
                           NULL);
      dwLength += temp_len;
   }


   // check for an error
   if (!fReadStat)
      ler = GetLastError();

   // check if need to restore timeouts
   if (timeout > 0)
   {
      CommTimeOuts.ReadIntervalTimeout = DEF_READ_INT;
      CommTimeOuts.ReadTotalTimeoutMultiplier = DEF_READ_MULT;
      CommTimeOuts.ReadTotalTimeoutConstant = DEF_READ_CONST;
      CommTimeOuts.WriteTotalTimeoutMultiplier = DEF_WRITE_MULT;
      CommTimeOuts.WriteTotalTimeoutConstant = DEF_WRITE_CONST;
      SetCommTimeouts(ComID[Prt], &CommTimeOuts);
   }

   // check results
   if (fReadStat)
   {
      ClearCommError(ComID[Prt], &dwErrorFlags, &ComStat);
      return (short)dwLength;
   }
   else
      return 0;
}


//--------------------------------------------------------------------------
//  Description:
//     Send a break on the com port for len ms
//
//  len > 0 - do a break for len ms
//      = 0 - remove an infinite break
//      < 0 - set an infinite break
//
void BreakCOM(int Prt)  //, short len)
{

   short len = 2;
   int rt;

   // set a break?
   if (len != 0)
      // start the reset pulse
      if (SetCommBreak(ComID[Prt]) != 1) rt = FALSE;

    // special case for very small break times
   if ((len < 5) && (len > 0))
   {
      // get a time stamp
      MarkTime();
      // wait for len ms
      while (!ElapsedTime(len));
   }
   else if (len >= 5)
      // sleep
      Sleep(len);

   // is this not an infinite break?
   if (len >= 0)
      // clear the reset pulse
      if (ClearCommBreak(ComID[Prt]) != 1)
         rt = FALSE;

   rt = TRUE;
}


//--------------------------------------------------------------------------
//  Description:
//     Drop and then raise power (DTR,RTS) on the com port
//
int PowerCOM(short Prt, short len)
{
   DCB dcb;

   // drop power?
   if (len != 0)
   {
      // DTR/RTS off (inverse loader mode for the 5000)
      dcb.DCBlength = sizeof(DCB);
      if (GetCommState(ComID[Prt], &dcb) != 1)
         return FALSE;
      dcb.fDtrControl = DTR_CONTROL_DISABLE;  // disable DTR
      dcb.fRtsControl = RTS_CONTROL_DISABLE;
      if (SetCommState(ComID[Prt], &dcb) != 1)
         return FALSE;
   }

   // special case for very small break times
   if ((len < 5) && (len > 0))
   {
      // get a time stamp
      MarkTime();
      // wait for len ms
      while (!ElapsedTime(len));
   }
   else if (len >= 5)
      // sleep
      Sleep(len);

   // is this not an infinite power drop?
   if (len >= 0)
   {
      // DTR/RTS on
      dcb.DCBlength = sizeof(DCB);
      if (GetCommState(ComID[Prt], &dcb) != 1)
         return FALSE;
      dcb.fDtrControl = DTR_CONTROL_ENABLE;  // enable DTR
      dcb.fRtsControl = RTS_CONTROL_ENABLE;
      if (SetCommState(ComID[Prt], &dcb) != 1)
         return FALSE;
   }

   return TRUE;
}


//--------------------------------------------------------------------------
//  Description:
//     Drop and then raise power (DTR,RTS) on the com port
//
int RTSCOM(short Prt, short len)
{
   DCB dcb;

   // clear RTS?
   if (len != 0)
   {
      // DTR/RTS off (inverse loader mode for the 5000)
      dcb.DCBlength = sizeof(DCB);
      if (GetCommState(ComID[Prt], &dcb) != 1)
         return FALSE;
      dcb.fDtrControl = DTR_CONTROL_ENABLE;  // enable DTR
      dcb.fRtsControl = RTS_CONTROL_DISABLE;
      if (SetCommState(ComID[Prt], &dcb) != 1)
         return FALSE;
   }

   // special case for very small break times
   if ((len < 5) && (len > 0))
   {
      // get a time stamp
      MarkTime();
      // wait for len ms
      while (!ElapsedTime(len));
   }
   else if (len >= 5)
      // sleep
      Sleep(len);

   // is this not an infinite clear RTS?
   if (len >= 0)
   {
      // DTR/RTS on
      dcb.DCBlength = sizeof(DCB);
      if (GetCommState(ComID[Prt], &dcb) != 1)
         return FALSE;
      dcb.fRtsControl = RTS_CONTROL_ENABLE;
      if (SetCommState(ComID[Prt], &dcb) != 1)
         return FALSE;
   }

   return TRUE;
}


//--------------------------------------------------------------------------
//  Description:
//     Check to see if DSR is set.
//
int DSRHigh(short Prt)
{
   DCB dcb;
   uchar rbuf[] = { 0xFF, 0x00 };
   short rt = FALSE;

   // DSR flow control on
   dcb.DCBlength = sizeof(DCB);
   if (GetCommState(ComID[Prt], &dcb) != 1)
      return FALSE;
   dcb.fRtsControl = RTS_CONTROL_ENABLE;
   dcb.fOutxDsrFlow = TRUE;              // DSR output flow control
   if (SetCommState(ComID[Prt], &dcb) != 1)
      return FALSE;

   // if can write then DSR must be high
   if (WriteCOM(Prt,1,rbuf))
      rt = TRUE;

   // DTR/RTS on
   dcb.DCBlength = sizeof(DCB);
   if (GetCommState(ComID[Prt], &dcb) != 1)
      return FALSE;
   dcb.fOutxDsrFlow = FALSE;              // DSR output flow control
   if (SetCommState(ComID[Prt], &dcb) != 1)
      return FALSE;

   FlushCOM(Prt);

   return rt;
}

//--------------------------------------------------------------------------
// Mark time stamp for later comparison
//
void StdFunc MarkTime(void)
{
   TimeStamp = GetTickCount();
}


//--------------------------------------------------------------------------
// Check if timelimit number of ms have elapse from the call to MarkTime
// Return TRUE if the time has elapse else FALSE.
//
int ElapsedTime(long timelimit)
{
   return ((TimeStamp + timelimit) < GetTickCount());
}

//--------------------------------------------------------------------------
//  Description:
//     Delay for at least 'len' ms
//
void msDelay(int len)
{
   Sleep(len);
}

//--------------------------------------------------------------------------
// Set the baud rate on the com port.  The possible baud rates for
// 'new_baud' are:
//
// PARMSET_9600     0x00
// PARMSET_19200    0x02
// PARMSET_57600    0x04
// PARMSET_115200   0x06
//
void SetBaudCOM(int portnum, uchar new_baud)
{
   short fRetVal;
   DCB dcb;
   ulong baud;

   dcb.DCBlength = sizeof(DCB);

   GetCommState(ComID[portnum], &dcb);

   switch(new_baud)
	{
		case PARMSET_9600:
			baud = 9600;
			break;

		case PARMSET_19200:
			baud = 19200;
			break;

		case PARMSET_57600:
			baud = 57600;
			break;

		case PARMSET_115200:
			baud = 115200;
			break;

		default:
			break;
	}

   dcb.BaudRate = baud;                      // current baud rate

   fRetVal = SetCommState(ComID[portnum], &dcb);
}

//--------------------------------------------------------------------------
// Get the current millisecond tick count.  Does not have to represent
// an actual time, it just needs to be an incrementing timer.
//
long msGettick(void)
{
   return GetTickCount();
}