accelerometer.c

基于MMA7260QR2的跌落检查程序

/*******************************************************************************
*    This function Performs x,y,z measurements compensated
*******************************************************************************/
void doAccelMeasurement(uint8_t axis)
{
  #if ACCEL_ENABLED==TRUE 
    uint16_t i16i;    
    doAccelMeasurementNoCompensation(axis);
    if(axis & X_AXIS) 
    {      
      i16i = doAccelMeasurementBuffer[1] + (COMPENSATED_VALUE - sCalValues.NxOff);
    }
    if(axis & Y_AXIS) 
    {
      i16i = doAccelMeasurementBuffer[1] + (COMPENSATED_VALUE - sCalValues.NyOff);
    }
    if(axis & Z_AXIS) 
    {
      i16i = doAccelMeasurementBuffer[1] + (COMPENSATED_VALUE - sCalValues.NzOff);
    }
    if (i16i > MAX_ADC_VALUE) 
    {
      i16i = MAX_ADC_VALUE;
    }
    if (i16i < MIN_ADC_VALUE) 
    {  
      i16i = MIN_ADC_VALUE;
    }
    doAccelMeasurementBuffer[1] = (uint8_t) i16i;
  #endif
}

/*******************************************************************************
*     This function Performs x,y,z measurements with no compensation
*******************************************************************************/
void doAccelMeasurementNoCompensation(uint8_t axis) 
{
  #if ACCEL_ENABLED==TRUE
    switch(axis)
    {
      case X_AXIS:
        AccelStart_X();                  
      break;
      case Y_AXIS:
        AccelStart_Y();                  
      break;
      case Z_AXIS:
        AccelStart_Z();                 
      break;
      default:
      break;  
    }
    StoreADCValue();
  #endif
}

/*******************************************************************************
*     This function compare the last adc reading with the current adc reading.
*     Return true if the reading change and false if the reading not change.
*******************************************************************************/
uint8_t compareADCReading(uint8_t u8LastReading, uint8_t u8CurrentReading, uint8_t threshold) 
{   
   uint8_t u8MaxReading = 255 - threshold;
   uint8_t u8MinReading = threshold;
   uint8_t u8Upper, u8Lower;
   
   /* check for the boundary conditions of 0 and 255 */
   if (u8CurrentReading < u8MinReading)
      return FALSE;
   
   if (u8CurrentReading > u8MaxReading)
      return FALSE;
   
   u8Upper = u8LastReading + threshold;
   u8Lower = u8LastReading - threshold;
   
   if (u8CurrentReading > u8Upper )
      return TRUE;
   
   if (u8CurrentReading < u8Lower )
      return TRUE;
   
   return FALSE;  
}

/*******************************************************************************
*     This thread of execution occur when gi8AppStatus = XYZ_STATE. When the ADC 
*     detects a change in voltage in X, Y or Z Axis from the accelerometer,
*     an update the App package that will be send to the PC_Radio.
*******************************************************************************/
void TxAccel(void)
{          
  switch (gu8TxAccelState) 
  {
    case 'x':           
      doAccelMeasurement(X_AXIS);
      doAccelMeasurementBuffer[0] = 0x78; /* Set X */
      if (X_VALUE_CHANGE() && TRANSMIT_END()) 
      {                                
        BuildTriaxDataRequest(); 
        u8LastX = TX_msg.pu8Buffer->u8Data[1];
      }       
      gu8TxAccelState = 'y'; 
    break;
  	 
    case 'y':      
      doAccelMeasurement(Y_AXIS);
      doAccelMeasurementBuffer[0] = 0x79; /* Set Y */
      if (Y_VALUE_CHANGE() && TRANSMIT_END()) 
      {                       
        BuildTriaxDataRequest();                  
        u8LastY = TX_msg.pu8Buffer->u8Data[1];                                                                
      }         
      gu8TxAccelState = 'z';
    break;
        
    case 'z':           
      doAccelMeasurement(Z_AXIS);
      doAccelMeasurementBuffer[0] = 0x7A; /* Set Z */
      if (Z_VALUE_CHANGE() && TRANSMIT_END()) 
      {                                
        BuildTriaxDataRequest();
        u8LastZ = TX_msg.pu8Buffer->u8Data[1];                                            
      }         
      gu8TxAccelState = 'x';
    break;

    default:
      /* set the variable to 'x' */
      TX_msg.pu8Buffer->u8Data[0] = 0x78;     
    break;
   }  
}

/*******************************************************************************
*     This application detects a freefall condition.
*     Drop the remote accel board and it will send the condition to the 
*     PC_Radio connected to the PC and turn on LED3.
*******************************************************************************/
void freefall_app(void)
{
  doAccelMeasurement(Z_AXIS);          
  if ((doAccelMeasurementBuffer[1] <= sCalValues.NzOff + 5) && (doAccelMeasurementBuffer[1] >= sCalValues.NzOff - 5)) 
  {
    gu16Events |= PING_FREEFALL; /* Free Falling tell PC Radio */    
    BUZZER_ON();
    LED_TurnOffLed(LED1);    
    DelayMs(200); /* delay 1/2 second */    
  }
  else 
  {
    gu16Events &= ~PING_FREEFALL; /* Clear the Freefall event */
    BUZZER_OFF();
  }
  TX_msg.pu8Buffer->u8Data[1] = doAccelMeasurementBuffer[1];
}

/*******************************************************************************
*     This application chirps LED3:
*     - once for x movement.
*     - twice for y movement.
*     - thrice for z movement.
*******************************************************************************/
void shockDetect_app(void)
{
  switch (gu8TxAccelState) 
  {
    case 'x':
          doAccelMeasurement(X_AXIS);          
          if (SHOCKDETECT_X_VALUE_CHANGE())
          {            
            u8LastX = doAccelMeasurementBuffer[1];            
            appEventPacket(X_AXIS, 3);            
            SoundsBuzzerOnce(LED1,40,40);
          }
          gu8TxAccelState = 'y';
    break;
      	 
    case 'y':
          doAccelMeasurement(Y_AXIS);
          if (SHOCKDETECT_Y_VALUE_CHANGE()) 
          {             
             u8LastY = doAccelMeasurementBuffer[1];                             
             appEventPacket(Y_AXIS, 3);
             SoundsBuzzerTwice(LED1,40); 
          }          
          gu8TxAccelState = 'z';
    break;
          
    case 'z':           
          doAccelMeasurement(Z_AXIS);
          if (SHOCKDETECT_Z_VALUE_CHANGE()) 
          {             
             u8LastZ = doAccelMeasurementBuffer[1];             
             appEventPacket(Z_AXIS, 3);  
             SoundsBuzzerThrice(LED1,40);
          }
          gu8TxAccelState = 'x';
    break;
    
    default:
    break;
  }
}

/*******************************************************************************
*     This application detects a tilt condition and 
*     Turn on LED3 while the tilt condition exists.
*******************************************************************************/
void antiTheft_app(void)
{
  uint16_t u16thresh;
   
  doAccelMeasurement(X_AXIS);          
  /* Check X-Axis for 16% grade */
  u16thresh = (sCalValues.NxMax - sCalValues.NxOff);
  u16thresh <<= 4;
  u16thresh /= 100;
  if (ANTITHEFT_VALUE_CHANGE()) 
  {
    u8LastX = doAccelMeasurementBuffer[1];             
    BUZZER_ON();    
    appEventPacket(X_AXIS, 3);
    return;
  }          
  
  doAccelMeasurement(Y_AXIS);
  u16thresh = (sCalValues.NyMax - sCalValues.NyOff);
  u16thresh <<= 4;
  u16thresh /= 100;           
  /* Moving Case - update the Last moved variable */
  if (ANTITHEFT_VALUE_CHANGE()) 
  {
    u8LastY = doAccelMeasurementBuffer[1];             
    BUZZER_ON();    
    appEventPacket(Y_AXIS, 3);     
    return;
  } 

  /* Both X and y are within threshold.  Turn Off Buzzer */          
  BUZZER_OFF(); 
}

/*******************************************************************************
*     If the remote accel board is still for more than 5 seconds
*     without movement the PC_radio board will turn off LED3 and 
*     blink the accel LEDs.
*******************************************************************************/
void batterySave_app(void)
{
  switch (gu8TxAccelState) 
  {
    case 'x':
      doAccelMeasurement(X_AXIS);         
      if (BATTERYSAVE_X_VALUE_CHANGE()) 
      {
        u8LastX = doAccelMeasurementBuffer[1];
        ClearTimerEvent();
      }
      gu8TxAccelState = 'y';
    break;
      	 
    case 'y':
      doAccelMeasurement(Y_AXIS);
      if (BATTERYSAVE_Y_VALUE_CHANGE()) 
      {
        u8LastY = doAccelMeasurementBuffer[1];
        ClearTimerEvent();        
      }
      gu8TxAccelState = 'z';
    break;          
    
    case 'z':
      doAccelMeasurement(Z_AXIS);
      if (BATTERYSAVE_Z_VALUE_CHANGE()) 
      {
        u8LastZ = doAccelMeasurementBuffer[1];
        ClearTimerEvent();
      }
      gu8TxAccelState = 'x';
    break;
   
    default:  
    break;
  }  
}

/*******************************************************************************
*     This is the callback function for when a valid packet has been
*     decoded by the radio.  The valid packet is passed to the app
*     via this MCPS_data_indication callback function.  All the data
*     resides in the RX_msg.
*     This routine is in the interrupt processing call stack. It
*     is not recommended to call other radio functions here.
*******************************************************************************/
void data_indication_execute(void) 
{
   if((TRUE == gbDataIndicationFlag) && 
      (MSG_RX_ACTION_COMPLETE_SUCCESS == RX_msg.u8Status.msg_state))
    {
      gbDataIndicationFlag = FALSE;        
#if OTAP_ENABLED == TRUE
      OTAP_data_indication_execute();   
      if(!gbOtapExecute)
#endif
      {
        switch (RX_msg.pu8Buffer->u8Data[1]) 
        {
          case 'x':
            gua8sciString[1] = RX_msg.pu8Buffer->u8Data[2];
            LED_ToggleLed(LED1);        
          break;
          case 'y':
            gua8sciString[3] = RX_msg.pu8Buffer->u8Data[2];
            LED_ToggleLed(LED1);          
          break;
          case 'z':
            gua8sciString[5] = RX_msg.pu8Buffer->u8Data[2];    	        
            LED_ToggleLed(LED1);
          break;    	        
          case 'P':
            LED_ToggleLed(LED2);        
            LED_TurnOffLed(LED1);        
            if (RX_msg.pu8Buffer->u8Data[3] == PING_NO_OPTIONS) 
            {
              LED_TurnOffLed(LED4);           
              BUZZER_OFF();   
            }     	        
            if (RX_msg.pu8Buffer->u8Data[3] == PING_BATTERYSAVE_BUZZER_ON) 
            {    	  
              SoundsBuzzerOnce(LED4, 120, 0);     	  
            } 
            if (RX_msg.pu8Buffer->u8Data[3] == PING_BATTERYSAVE_BUZZER_OFF) 
            {
              LED_TurnOffLed(LED4);          
              BUZZER_OFF();  
            }     	        
            if ((RX_msg.pu8Buffer->u8Data[2] == FREEFALL_STATE) &&