function.c

a/d公司8位微控制器aduc812（10路10位adc）应用笔记

      bRet = TII_WriteFrame(DataLength, (unsigned char*)&Data);

         // Write the values just received into the STIM Xdcr Data field.
         //
      if(bRet) STIM_SetXdcrData(ucChan, (unsigned char*)&Data);

         // If transport was aborted, exit FALSE now...
         //
      else     break;

      ucChan++;
   }

   return bRet;
}

boolean DAT_WriteCtrlCmmd(unsigned char ucChNum)
{
   boolean      bRet;
   unsigned int CtrlCmmd;

   bRet = TII_WriteFrame( 2, (unsigned char*)&CtrlCmmd);

   if(bRet)
   {
      switch(CtrlCmmd){
         case(0):        CTRL_NoOp();              break;
         case(1): bRet = CTRL_Reset(ucChNum);      break;
         case(2): bRet = CTRL_SelfTest(ucChNum);   break;
         case(3): bRet = CTRL_Calibrate(ucChNum);  break;
         case(4): bRet = CTRL_Zero(ucChNum);       break;
         default:                                  break;
      }
   }
   return bRet;  
}

boolean DAT_WriteTrigChAddr(void)
{
   boolean       bRet=TRUE;
   unsigned char ucChAddr;

   bRet = TII_WriteFrame( 1, (unsigned char*)&ucChAddr );

   if(bRet) TRIG_SetTrigChanAddr(ucChAddr);

   return (bRet);
}

boolean DAT_WriteIntMask(U8E eMask, unsigned char ucChan)
{
   boolean        bRet=TRUE;
   INTERRUPT_MASK iMask;

   bRet = TII_WriteFrame( 2, (unsigned char*)&iMask );

   if(bRet) INT_SetInterruptMask( eMask, ucChan, iMask );

   return (bRet);
}

boolean DAT_WriteCalibTEDS(void)
{
   // not implemented...
   return FALSE;
}

boolean DAT_WriteCalibIdTEDS(void)
{
   // not implemented...
   return FALSE;
}

boolean DAT_WriteEndUserAppTEDS(void)
{
   // not implemented...
   return FALSE;
}


// Control Functions:
// -----------------

void CTRL_NoOp(void)
{
   return;  
}

boolean CTRL_Reset(unsigned char ucChannel)
{
   boolean bRet = FALSE;
   CHANNEL *pCh = STIM_GetChHandle(ucChannel);

      // a CHANNEL_ZERO reset => all the channels on the STIM must be reset
      //
   if(ucChannel == CHANNEL_ZERO)
   {  
      unsigned char count=NUM_CHANNELS+1;

         // handle CHANNEL_ZERO the same way as all other channels
         //
      while(count--)
      {
         pCh = STIM_GetChHandle(count);
         pCh->StdStatus = 0;  
         pCh->AuxStatus = 0;
         pCh->Data.ChData = 0;
      }
      STIM_SetResetFlag(ucChannel);
   }
   else
   {
      pCh->StdStatus = 0;  
      pCh->AuxStatus = 0;
      pCh->Data.ChData = 0;
   }

   return bRet;
}

boolean CTRL_SelfTest(unsigned char ucChannel)
{
   // this function is not implemented
   return ucChannel;
}

boolean CTRL_Calibrate(unsigned char ucChannel)
{
   // this function is not implemented
   return ucChannel;
}

boolean CTRL_Zero(unsigned char ucChannel)
{
   // this function is not implemented
   return ucChannel;
}



// Interrupt Functions:
// -------------------

INTERRUPT_MASK INT_GetInterruptMask(U8C eFlag, unsigned char ucCh)
{
   if(eFlag==STANDARD)        return STIM_GetChHandle(ucCh)->StdIntMask;
   else if(eFlag==AUXILIARY)  return STIM_GetChHandle(ucCh)->AuxIntMask;
   else                       return NULL;
}

boolean INT_SetInterruptMask(U8C eFlag, unsigned char ucCh, 
                             INTERRUPT_MASK Mask)
{
   boolean bRet=FALSE;

   if(eFlag==STANDARD)
   {  
         // make sure the 'service request' bit is set...
         //
      Mask |= STD_SERVICE_REQUEST;
      STIM_GetChHandle(ucCh)->StdIntMask = Mask;
      bRet = TRUE;
   }
   else if(eFlag==AUXILIARY)
   {
      STIM_GetChHandle(ucCh)->AuxIntMask = Mask;
      bRet = TRUE;
   }

   return bRet;
}

boolean INT_ServiceRequest(void)
{
   unsigned char count;
   boolean bServiceReqd = FALSE;

   STD_STATUS_REGISTER  StdChannelsORed=0;
   AUX_STATUS_REGISTER  AuxChannelsORed=0;
   STATUS_REGISTER      Std, Aux;

   CHANNEL *pChZero = STIM_GetChHandle(CHANNEL_ZERO);
   CHANNEL *pCh     = NULL;

      // Set the 'service request' bits for each channel (excluding 
      // CHANNEL_ZERO) if a 'status' or 'auxiliary' service bit has been set.
      //
   for(count=NUM_CHANNELS; count>CHANNEL_ZERO; count--)
   {
      pCh = STIM_GetChHandle(count);

      if( Std = (pCh->StdStatus & pCh->StdIntMask) )
      {
         STA_SetStatusBit(STANDARD, STD_SERVICE_REQUEST, count);
         bServiceReqd=TRUE;
         StdChannelsORed |= Std;
      }
      if( Aux = (pCh->AuxStatus & pCh->AuxIntMask) )
      {
         STA_SetStatusBit(STANDARD, STD_SERVICE_REQUEST, count);
         bServiceReqd=TRUE;
         AuxChannelsORed |= Aux;
      }
   }
   
      // Now set the CHANNEL_ZERO status bits that need setting
      //
   pChZero->AuxStatus = AuxChannelsORed & (AUX_CHANNEL_OUT_OF_RANGE |
                                           AUX_CHANNEL_CONSUMABLES_EXHAUSTED |
                                           AUX_FAILED_CALIBRATION |
                                           AUX_CHANNEL_BUSY );

   pChZero->StdStatus = (StdChannelsORed & STD_AUXILIARY_STATUS_AVAILABLE) |
                        (pChZero->StdStatus & ( STD_TRIGGER_ACK     |
                                                STD_RESET_COMPLETE  |
                                                STD_INVALID_COMMAND |
                                                STD_OPERATIONAL ) );

   if( pChZero->StdStatus & pChZero->StdIntMask ) 
   {
      STA_SetStatusBit(STANDARD, STD_SERVICE_REQUEST, CHANNEL_ZERO);
      bServiceReqd=TRUE;
   }
   if( pChZero->AuxStatus & pChZero->AuxIntMask ) 
   {
      STA_SetStatusBit(STANDARD, STD_SERVICE_REQUEST, CHANNEL_ZERO);
      bServiceReqd=TRUE;
   }

   INT_ToggleInterrupt(bServiceReqd);

   return bServiceReqd;
}

void INT_ToggleInterrupt(boolean bSet)
{
   if(bSet) TII_AssertNINT();
   else     TII_NegateNINT();
}


// Status Functions:
// ----------------

boolean STA_SetStatusBit(U8E eReg, unsigned int uiBit, unsigned char ucChannel)
{
   boolean bRet=TRUE;

   if(uiBit)
   {
      CHANNEL *pCh = STIM_GetChHandle(ucChannel);

      if(eReg==STANDARD)
         pCh->StdStatus |= (uiBit&STD_IMPLEMENTED);

      else if(eReg==AUXILIARY)
      {
         pCh->AuxStatus |= (uiBit&AUX_IMPLEMENTED);
         pCh->StdStatus |= STD_AUXILIARY_STATUS_AVAILABLE;
      }

      else bRet=FALSE;
   }
   else bRet=FALSE;

   return bRet;   
}

boolean STA_ClearStatusBit(U8E eReg,unsigned int uiBit,unsigned char ucChannel)
{
   boolean bRet=TRUE;

   if(uiBit)
   {
      CHANNEL *pCh = STIM_GetChHandle(ucChannel);

      if(eReg==STANDARD)
         pCh->StdStatus &= ~(uiBit&STD_IMPLEMENTED);

      else if(eReg==AUXILIARY)
      {
         pCh->AuxStatus &= ~(uiBit&AUX_IMPLEMENTED);
         if(pCh->AuxStatus == 0)
            pCh->StdStatus &= ~STD_AUXILIARY_STATUS_AVAILABLE;
      }

      else bRet=FALSE;
   }
   else bRet=FALSE;

   return bRet;   
}

STATUS_REGISTER STA_GetStdStatus(unsigned char ucChannel)
{
      // Get a handle on the channel, then read it's standard status register
      //
   CHANNEL *pCh           = STIM_GetChHandle(ucChannel);
   STATUS_REGISTER  StReg = pCh->StdStatus;

      // Clear all of the Implemented bits from the status register:
      //
   if( STA_ClearStatusBit(STANDARD, STD_IMPLEMENTED, ucChannel) )
      return StReg;
   else
      return NULL;
}

STATUS_REGISTER STA_GetAuxStatus(unsigned char ucChannel)
{
      // Get a handle on the channel, then read its auxiliary status register
      //
   CHANNEL *pCh          = STIM_GetChHandle(ucChannel);
   STATUS_REGISTER StReg = pCh->AuxStatus;

      // Clear all of the Implemented bits from the status register:
      //
   if( STA_ClearStatusBit(AUXILIARY, AUX_IMPLEMENTED, ucChannel) )
      return StReg;
   else
      return NULL;
}

boolean STA_ClearStdStatus(unsigned char ucChannel, STATUS_REGISTER StReg)
{
   CHANNEL *pCh               = STIM_GetChHandle(ucChannel);
   STATUS_REGISTER NegatedReg = ~StReg;

   if(StReg) pCh->StdStatus &= NegatedReg;

   return ((pCh->StdStatus & StReg)==0); 
}

boolean STA_ClearAuxStatus(unsigned char ucChannel, STATUS_REGISTER StReg)
{
   CHANNEL *pCh                = STIM_GetChHandle(ucChannel);
   STATUS_REGISTER  NegatedReg = ~StReg;

   if(StReg)             pCh->AuxStatus &= NegatedReg;
   if(pCh->AuxStatus==0) pCh->StdStatus &= ~STD_AUXILIARY_STATUS_AVAILABLE;

   return ((pCh->AuxStatus & StReg)==0); 
}



// Triggering Functions:
// --------------------

boolean TRIG_SetTrigChanAddr(unsigned char ucChAddr)
{
   mucTrigChanAddr = ucChAddr;
   return TRUE;
}

unsigned char TRIG_GetTrigChanAddr(void)
{
   return mucTrigChanAddr;
}

void TRIG_AckTrigger(void)
{
      // assert the NACK line
      //
   TII_AssertNACK();

      // set the 'trigger acknowledged' bit in the channel's status register
      //
   STA_SetStatusBit(STANDARD, STD_TRIGGER_ACK, mucTrigChanAddr);
}

void TRIG_RemoveTrigAck(void)
{
   TII_NegateNACK();
}

boolean TRIG_PollTrigger(void)
{
      // return TRUE if asserted, FALSE if not asserted
      //
   return TII_DetectNTRIG();
}