stim.c

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

   ADCI = 0;

      // now return the 12-bit sample
      //
   return (uiSample1 & 0x0FFF);
}

void STIM_SetCh2State(boolean bState)
{
   FAN_CH2 = (bState) ? 1 : 0 ;
}


//
// --------------------
// The 'main' function.
// This function encapsulates the 'STIM kernel' - it is this function
// that essentially controls the operation of the 1451.2 implementation
// --------------------------------------------------------------------
//
void main(void)
{
   //
   // Power On Initialisation Routine:
   // -------------------------------
      // Setup the channel information in RAM. Set default values.
      //
   STIM_InitialReset();
   STIM_InitCh1();
   STIM_InitCh2();

      // Write the TEDS information into the TEDS flash storage area.
      //
   TEDS_InitTEDSFlash();
   TEDS_SetupMetaTEDS();
   TEDS_SetupCh1TEDS();
   TEDS_SetupCh2TEDS();

      // Setup the Interrupt Mask values for this STIM:
      //
      // Set the Standard Interrupt Masks for CHANNEL_ZERO, Ch1 and Ch2...
      //
   INT_SetInterruptMask(STANDARD, CHANNEL_ZERO, STD_SERVICE_REQUEST |
                                                STD_TRIGGER_ACK |
                                                STD_RESET_COMPLETE |
                                                STD_INVALID_COMMAND | 
                                                STD_AUXILIARY_STATUS_AVAILABLE);
   INT_SetInterruptMask(STANDARD, 1, STD_SERVICE_REQUEST |
                                     STD_TRIGGER_ACK |
                                     STD_RESET_COMPLETE |
                                     STD_AUXILIARY_STATUS_AVAILABLE );
   INT_SetInterruptMask(STANDARD, 2, STD_SERVICE_REQUEST    |
                                     STD_TRIGGER_ACK        |
                                     STD_RESET_COMPLETE     |
                                     STD_AUXILIARY_STATUS_AVAILABLE);

      // Set the Auxiliary Interrupt Masks for CHANNEL_ZERO, Ch1 and Ch2...
      // NOTE: the auxiliary interrupt mask in this STIM is 0 for all channels.
      //
   INT_SetInterruptMask(AUXILIARY, CHANNEL_ZERO, 0x0000);
   INT_SetInterruptMask(AUXILIARY, 1,            0x0000);
   INT_SetInterruptMask(AUXILIARY, 2,            0x0000);

      // Setup the TII data-transport interface.
      //
   TII_Initialise();


   // Start Loop:
   // ----------

   do 
   {
      // Has a Reset been requested? (a 'control' request)
      // --------------------------
      {
         U8E eReset = STIM_GetResetFlag();

            // Perform a 'soft' reset - this won't affect interrupt masks
            //
         if(eReset == CHANNEL_ZERO)          STIM_SoftReset();
         else if(eReset != INVALID_CHANNEL)  STIM_ChannelReset(eReset);

         STIM_SetResetFlag(INVALID_CHANNEL);
      }


      // Is the Data Transport Active?
      // ----------------------------

      if( DAT_TransportActive() )
      {
         unsigned char FnAddr=0, ChAddr=0;
         
         TII_SetAbortStatus(FALSE);

            // Data Transport begins by NCAP sending an Address to the STIM:
            //
         if(!TII_GetAbortStatus())   FnAddr = TII_WriteByte();
         if(!TII_GetAbortStatus())   ChAddr = TII_WriteByte();
         
            // The Data Transport has not aborted: continue on to the
            // transport protocol...
            //
         if(!TII_GetAbortStatus())
         {
               // ucRdWr will be FN_READ for a 'read' function, FN_WRITE for 
               // a 'write' function.
               //
            unsigned char ucRdWr = FnAddr & READ_FN;
            FnAddr &= 0x7F;

               // The Transport has requested a READ function:
               //
            if(ucRdWr == READ_FN)
            {
               switch(FnAddr)
               {
                  case(TRANSDUCER_DATA):     DAT_ReadXdcrData(ChAddr);
                  break;

                  case(STANDARD_STATUS):     DAT_ReadStatus(STANDARD, ChAddr);
                  break;

                  case(TRIGGERED_CHANNEL_ADDRESS): 
                                             DAT_ReadTrigChAddr();
                  break;

                  case(AUXILIARY_STATUS):    DAT_ReadStatus(AUXILIARY, ChAddr);
                  break;

                  case(STANDARD_INTERRUPT_MASK):
                                             DAT_ReadIntMask(STANDARD, ChAddr);
                  break;

                  case(AUXILIARY_INTERRUPT_MASK):
                                             DAT_ReadIntMask(AUXILIARY, ChAddr);
                  break;                         

                  case(STIM_VERSION):        DAT_ReadSTIMVersion();
                  break;                         

                  case(META_TEDS | CHANNEL_TEDS):
                        if(ChAddr==CHANNEL_ZERO) DAT_ReadMetaTEDS();
                        else                     DAT_ReadChannelTEDS(ChAddr);
                  break;

                  case(META_ID_TEDS | CHANNEL_ID_TEDS):
                        if(ChAddr==CHANNEL_ZERO) DAT_ReadMetaIdTEDS();
                        else                     DAT_ReadChannelIdTEDS(ChAddr);
                  break;

                  case(CALIBRATION_TEDS):        DAT_ReadCalibrationTEDS();
                  break;

                  case(CALIBRATION_ID_TEDS):     DAT_ReadCalibrationIdTEDS();
                  break;

                  case(USERS_APP_SPECIFIC_TEDS): DAT_ReadEndUserAppTEDS();
                  break;

                  default:    
                  STA_SetStatusBit(STANDARD, STD_INVALID_COMMAND, CHANNEL_ZERO);
                  break;
               }
            }
               // The Transport has requested a WRITE function:
               //
            else
            {
               switch(FnAddr)
               {
                  case(TRANSDUCER_DATA):  DAT_WriteXdcrData(ChAddr);
                  break;

                  case(CONTROL_COMMAND):  DAT_WriteCtrlCmmd(ChAddr);
                  break;

                  case(TRIGGERED_CHANNEL_ADDRESS): 
                                          DAT_WriteTrigChAddr();
                  break;

                  case(STANDARD_INTERRUPT_MASK):   
                                          DAT_WriteIntMask(STANDARD, ChAddr);
                  break;

                  case(AUXILIARY_INTERRUPT_MASK):   
                                          DAT_WriteIntMask(AUXILIARY, ChAddr);
                  break;

                  case(CALIBRATION_TEDS): DAT_WriteCalibTEDS();
                  break;

                  case(CALIBRATION_ID_TEDS):
                                          DAT_WriteCalibIdTEDS();
                  break;

                  case(USERS_APP_SPECIFIC_TEDS):
                                          DAT_WriteEndUserAppTEDS();
                  break;

                  default:
                  STA_SetStatusBit(STANDARD, STD_INVALID_COMMAND, CHANNEL_ZERO);
                  break;
               }
            }
         }

            // Either transport was Aborted, or Transport is finished... 
            // return NACK to it's idle/passive state.
            //
         TII_NegateNACK();
      }

      // Is Trigger Asserted?
      // -------------------

      if(TRIG_PollTrigger())
      {  
         unsigned char ucChAddr = TRIG_GetTrigChanAddr();

         switch( ucChAddr )
         {
            unsigned int  Ch1Sample;
            unsigned char Ch2Data;

            case(CHANNEL_ZERO):
                                 // SENSOR channel, AD590:
            case(1):             // 1. Acquire a data sample
                                 //
                     Ch1Sample=STIM_GetCh1Sample();

                                 // 2. Acknowledge the trigger at acquire time
                                 //
                     TRIG_AckTrigger();

                                 // 3. Store sample into channel data area
                                 //
                     STIM_SetXdcrData( 1, (unsigned char*)&Ch1Sample );

                                 // 4. Remove Acknowledge when trigger has
                                 //    been removed.
                     while(TII_DetectNTRIG())
                        ;
                     TRIG_RemoveTrigAck();
                     
                                 // 5. Acknowledge removed - go back to 
                                 //    'quiescent' state

            if(ucChAddr != CHANNEL_ZERO) 
            break;

            case(2):             // ACTUATOR channel, Fan:
                                 // 1. Assume there is valid data to be written
                                 //
                     STIM_GetXdcrData( 2, &Ch2Data );

                                 //  2. Write the 'data set' to the actuator
                                 //
                     STIM_SetCh2State( Ch2Data );

                                 // 3. Acknowledge trigger - we have just 
                                 //    changed the actuator state
                     TRIG_AckTrigger();

                                 // 4. Wait for the trigger to be removed, 
                                 //    then remove the acknowledge.
                     while(TII_DetectNTRIG())
                        ;
                     TRIG_RemoveTrigAck();

                                 // 5. Acknowledge removed - go back to 
                                 //    'quiescent' state

            if(ucChAddr != CHANNEL_ZERO) 
            break;

            default:
                     // The channel requested does not exist.
                     // Go back to the 'quiescent' state.
            break;
         }
      }

      // Does STIM need to be serviced?
      // -----------------------------
         // If there are requests for service, service them.
         //
      INT_ServiceRequest();
                               
   } while(1);
}