sacwd32.c

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

      (*pfnUTProc)(gb, MYROMDATA, NULL);
      return gb->romdta;
   }
   else 
   {
      romptr = &(gb->romdta[0]); // point to the first byte of romdta array   
      return(romptr);            // send far pointer back to caller 
   }
//   return (uchar *)RomDta;
}
////////////////////////////////////////////////////////////////////////////////
uchar APIENTRY databyte(uchar data, sa_struct *gb)
{
   DWORD Args[2]; //function has two arguments;
   PVOID TransList[2]; //One pointer needs translation: gb

   if(!Win32s)
      return (gb->setup_ok && gb->accflg) ? DOWByte(data) : data;
   else
   {
      Args[0] = (DWORD) data; //passing two arguments
      Args[1] = (DWORD) gb;
      TransList[0] = &Args[1]; //translate one pointer
      TransList[1] = NULL;    //End translation with NULL
      return (uchar)( (* pfnUTProc)(Args, MYDATABYTE, TransList));
   }
}
///////////////////////////////////////////////////////////////////////////////
uchar APIENTRY databit(uchar tbit, sa_struct *gb)
{
   DWORD Args[2];
   PVOID TransList[2];

   if(!Win32s)
      return (gb->setup_ok && gb->accflg) ? DOWBit(tbit) : tbit;
   else
   {
      Args[0] = (DWORD) tbit;
      Args[1] = (DWORD) gb;
      TransList[0] = &Args[1];
      TransList[1] = NULL;
      return (uchar)( (* pfnUTProc)(Args, MYDATABIT, TransList));
   }
}
///////////////////////////////////////////////////////////////////////////////
uchar APIENTRY setup(uchar pn, sa_struct *gb)
{  
   DWORD Args[2]; //function has one argument;
   PVOID TransList[2]; //One pointer needs translation: gb
               
   if(Win32s)
   {
      Args[0] = (DWORD) pn;     //Passing two parameters
      Args[1] = (DWORD) gb;
      
      TransList[0] = &Args[1];        //One pointer needs to be translated 
      TransList[1] = NULL;            //End translation with NULL  
      return (uchar)( (* pfnUTProc)(Args, MYSETUP, TransList));
   }
   else if(Win95)
   {  
      memset(gb, 0, sizeof(sa_struct));
      
      // Reset RomSearch (first, next) algorithm
      gb->lastone = FALSE;
      gb->ld = 0;
      
      if (pn > 0 && pn < 4)                     // Make sure port number is valid
      {
         // This allows all other functions to execute
         gb->setup_ok = TRUE;
         gb->accflg = TRUE; //(OWPD) 
         // Set base port address
         bpa = pa_vals[pn - 1];
      }
      else
         bpa = pa_vals[0];  // Set to default in case caller ignores FALSE return
      
      return  (uchar)(gb->setup_ok);                          // Return result of setup function
   }
   else if(WinNT)
   {
      // Initialize global flags
      memset(gb, 0, sizeof(sa_struct));
      // Reset RomSearch (first, next) algorithm 
      gb->lastone = FALSE;                             
      gb->ld = 0;                            
      
      // Make sure port number is valid
      if (pn > 0 && pn < 4)           
      {
         // This allows all other functions to execute
         gb->setup_ok = TRUE;            
         gb->accflg = TRUE; //(OWPD) 
         // Assign port number
         gpn = pn;
      }
      else
         gpn = 1; 
      
      // Return result of setup function
      return (uchar)(gb->setup_ok);
   }

   return FALSE;  // (OWPD) get all control paths
}
////////////////////////////////////////////////////////////////////////////////
static 
uchar DOWBit(uchar bit_val)
{
   BOOLEAN BitResult = TRUE;
   if(Win95)
      return CallDriver(DOWBIT,bit_val);
   else if(WinNT)
   {
      if (AuthFlag)
      {
         mch[0] = DO_BIT;  // Tell driver to do a bit 
         mch[1] = bit_val; // Specify bit value 
      
         if (WriteFile(DOWHandle, (LPSTR) mch, 2, &NumTrans, NULL) &&
             ReadFile(DOWHandle, (LPSTR) mch, 1, &NumTrans, NULL))
         {
            BitResult = (BOOLEAN) *mch; 
         }
      } 
      return BitResult;
   }

   return FALSE;  // (OWPD) get all control paths
}
////////////////////////////////////////////////////////////////////////////////
static 
uchar DOWByte(uchar byte_val)
{
   UCHAR ByteResult = byte_val;
   if(Win95)
      return CallDriver(DOWBYTE,byte_val);
   else if(WinNT)
   {
      if (AuthFlag)
      {
         mch[0] = DO_BYTE;  // Tell driver to do a bit 
         mch[1] = byte_val; // Specify bit value 
      
         if (WriteFile(DOWHandle, (LPSTR) mch, 2, &NumTrans, NULL) &&
             ReadFile(DOWHandle, (LPSTR) mch, 1, &NumTrans, NULL))
         {
            ByteResult = *mch;                  
         }
      } 
      
      return ByteResult;
   }

   return FALSE;  // (OWPD) get all control paths
}
////////////////////////////////////////////////////////////////////////////////
//(OWPD) static 
uchar DOWReset()
{
   BOOLEAN ResetResult = FALSE;
   if(Win95)
      return CallDriver(DOWRESET,0);
   else if (WinNT)
   {
      if (AuthFlag)
      {
         mch[0] = DO_RESET; // Tell driver to do a reset 
         mch[1] = gpn;      // Specify a port 
      
         if (WriteFile(DOWHandle, (LPSTR) mch, 2, &NumTrans, NULL) && 
             ReadFile(DOWHandle, (LPSTR) mch, 1, &NumTrans, NULL))
         {
            // Assign result 
            ResetResult = (BOOLEAN) *mch;                     
         }
      } 

      return ResetResult;
   }

   return FALSE;  // (OWPD) get all control paths
}
////////////////////////////////////////////////////////////////////////////////
uchar ToggleOverdrive(void)  // (OWPD)
{
   UCHAR ByteResult = 0;
   if(Win95)
      return CallDriver(DOWTOGGLEOD,0);
   else if(WinNT)
   {
      if (AuthFlag)
      {
         mch[0] = TOGGLE_OVERDRIVE; 
      
         if (WriteFile(DOWHandle, (LPSTR) mch, 2, &NumTrans, NULL) &&
             ReadFile(DOWHandle, (LPSTR) mch, 1, &NumTrans, NULL))
         {
            ByteResult = *mch;                  
         }
      } 
      return ByteResult;
   }

   return FALSE;  // (OWPD) get all control paths
}
////////////////////////////////////////////////////////////////////////////////
void APIENTRY copyromdata(ushort *ip, sa_struct *gb)
{
   short i;
   for (i = 0; i < 8; ++i)
      ip[i] = (int) gb->romdta[i];
}
////////////////////////////////////////////////////////////////////////////////
void APIENTRY copy2romdata(ushort *ip, sa_struct *gb)
{
   short i;
   for (i = 0; i < 8; i++)
      gb->romdta[i] = 0xff & ip[i];
}

////////////////////////////////////////////////////////////////////////////////
uchar CheckOverdrive() // (OWPD) make not static 
{
   uchar ByteResult = 0;

   if(Win95)
   {
      return CallDriver(CHECK_OVERDRIVE,0);//Busy Lines Dropped
   }
   else if(WinNT)
   {
      if (AuthFlag)
      {
         mch[0] = CHECK_OVERDRIVE; 
      
         if (WriteFile(DOWHandle, (LPSTR) mch, 2, &NumTrans, NULL) &&
             ReadFile(DOWHandle, (LPSTR) mch, 1, &NumTrans, NULL))
         {
            ByteResult = mch[0];                  
         }
      } 

      return ByteResult;
   }

   return FALSE;  // (OWPD) get all control paths
}

////////////////////////////////////////////////////////////////////////////////
static 
uchar CheckBusy()
{
   UCHAR ByteResult = 0;
   if(Win95)
      return CallDriver(DOWCHECKBSY,0);//Busy Lines Dropped
   else if(WinNT)
   {
      if (AuthFlag)
      {
         mch[0] = CHECK_BRICK; 
      
         if (WriteFile(DOWHandle, (LPSTR) mch, 2, &NumTrans, NULL) &&
             ReadFile(DOWHandle, (LPSTR) mch, 1, &NumTrans, NULL))
         {
            ByteResult = *mch;                  
         }
      } 
      
      return ByteResult;
   }

   return FALSE;  // (OWPD) get all control paths
}
////////////////////////////////////////////////////////////////////////////////
static
void TogglePassthru(void)
{
   UCHAR i;
   if(Win95)
      CallDriver(DOWTOGGLEPASS,0);
   else if(WinNT)
      for (i = 0; i < 4; i++)
         ToggleOverdrive();
   FastSleep(10);
}
////////////////////////////////////////////////////////////////////////////////
static 
uchar RomSearch(sa_struct *gb)
{
   uchar
         i = 0,
         x = 0,
         ld = gb->ld;
   uchar RomBit, 
         Mask;
   uchar j = 0;
   uchar k = 1;
   uchar lo = 0, nxt = 0;
   if(!Win32s)
   {
      // Reset DOW bus
      if (DOWReset())
         DOWByte(ROMSEARCH);  // Send search command
      else
      {
         gb->ld = 0;
         return FALSE;   // No DOW parts were found on bus
      }
      // While not done and not bus error
      while ((i++ < 64) && (x < 3))
      {
         Mask = 1 << ((i - 1) % 8);
      
         // Get last pass bit
         RomBit = RomDta[(i - 1) >> 3] & Mask ? TRUE : FALSE;
      
         // Send read time slots
         x = DOWBit(TRUE) << 1;
         x |= DOWBit(TRUE);
      
         // Is there a disagreement in this bit position
         if (!x)
         {
            // Stay on old path or pick a new one ?
            if (i >= ld)
               RomBit = (i == ld);         // Send write 1 if at position of ld 
              
            // Save this value as temp last disagreement
            if (!RomBit)
               gb->ld = i;
         }
         else
            RomBit = (x & 1) ^ 1;          // Get lsb of x and flip it
      
         if (RomBit)
            RomDta[(i - 1) >> 3] |= Mask;          // Set bit in Rom Data byte
         else
            RomDta[(i - 1) >> 3] &= (Mask ^ 0xFF); // Clear bit in Rom Data byte
      
         // Send write time slot
         DOWBit(RomBit);
      }
      
      memcpy(&(gb->romdta[0]), &(RomDta[0]), 8);
      Compatl0=gb->ld;
      if (x == 3)
         gb->ld = 0;
      return (x == 3) ? 0 : 1 + (ld == gb->ld);
   }

   return FALSE;  // (OWPD) get all control paths
}

void SetPortNumber()
{
   UCHAR ByteResult = 0;

   if (AuthFlag)
   {
      mch[0] = SET_PORT; 
      mch[1] = gpn; 

      WriteFile(DOWHandle, (LPSTR) mch, 2, &NumTrans, NULL);
      ReadFile(DOWHandle, (LPSTR) mch, 1, &NumTrans, NULL);
   } 
}

static void MyInt64Add(PLARGE_INTEGER pA, PLARGE_INTEGER pB)
{
   BYTE c = 0;

   if ((pA->LowPart != 0L) && (pB->LowPart != 0L))
      c = ((pA->LowPart + pB->LowPart) < pA->LowPart) ? 1 : 0;

   pA->LowPart  += pB->LowPart;
   pA->HighPart += pB->HighPart + c;
}

//////////////////////////////////////////////////////////////////////////////
//
//   Returns TRUE is A <= B.
//
static BOOL MyInt64LessThanOrEqualTo(PLARGE_INTEGER pA, PLARGE_INTEGER pB)
{
   BOOL CompRes = FALSE;

   if (pA->HighPart < pB->HighPart)
      CompRes = TRUE;
   else  if ((pA->HighPart == pB->HighPart) && (pA->LowPart <= pB->LowPart))
      CompRes = TRUE;

   return CompRes;
}
static void FastSleep(WORD Delay)
{
   LARGE_INTEGER CountsPerSec, CurrentCount, FinalCount, DelayCounts;
   BOOL          UseOldSleep = TRUE;
    
   if (QueryPerformanceFrequency(&CountsPerSec))
   {
      if (CountsPerSec.HighPart == 0L)
      {
         DelayCounts.HighPart = 0;
         DelayCounts.LowPart  = (CountsPerSec.LowPart / 1000L) * Delay;

         if (DelayCounts.LowPart)
         {
            // Get current count value
            QueryPerformanceCounter(&FinalCount);
            // FinalCount += DelayCounts
            MyInt64Add(&FinalCount, &DelayCounts);

            do
            {
               SleepEx(1, FALSE);
               QueryPerformanceCounter(&CurrentCount);   
            }
            while (MyInt64LessThanOrEqualTo(&CurrentCount, &FinalCount));

            UseOldSleep = FALSE;
         }
      }
   }
 
   if (UseOldSleep)
   {
      // Use regular sleep if hardware doesn't support a performance counter
      SleepEx(Delay, FALSE);
   }
}

////////////////////////////////////////////////////////////////////////////////
// sacwd32.c