mems.c

Go to the documentation of this file.

/****************** COPYRIGHT (C) 2007-2013 KEOLABS S.A.S. ********************/
/******************************************************************************/

/* Includes ------------------------------------------------------------------*/
#include "circle.h"


/* Private define ------------------------------------------------------------*/
//~ #define MEMS_TESTING_DIVIDER  101
#define MARGIN                500
#define DELAY_REACT           20
#define MIN_REACT             15
#define DIV_REACT             10
#define GRAD_SHOCK            350000


/* Private variables ---------------------------------------------------------*/
tMEMS_Info                          MEMS_Info                        = {0};   // structure definition in circle.h
s32                                 TestingActive                    = 0;
s32                                 StartingFromResetOrShockCounter  = 1000;
s32                                 TimeCounterForDoubleClick        = 0;
s32                                 TimeLastShock                    = 0;
u32                                 Gradient2;

// Gradient
s32                                 GradX                            = 0;
s32                                 GradY                            = 0;
s32                                 GradZ                            = 0;

coord_t XInit = 0;
coord_t YInit = 0;
coord_t ZInit = 0;

/* Private function prototypes -----------------------------------------------*/
void MEMS_ChipSelect( u8 State );
u8   MEMS_SendByte( u8 byte );
u32  MEMS_ReadOutXY( void );
void MEMS_WakeUp( void );

/* Private functions ---------------------------------------------------------*/


/* Public functions for CircleOS ---------------------------------------------*/


/*******************************************************************************
*
*                                MEMS_Handler
*
*******************************************************************************/
/******************************************************************************/
IRQ void MEMS_Handler( void )
{
    static s32 delta_time_ms = 0;

    if ( StartingFromResetOrShockCounter )
    {
        StartingFromResetOrShockCounter--;
    }
    TimeCounterForDoubleClick++;

    MEMS_ReadOutXY();

    // Evaluate gradients
    GradX = ( MEMS_Info.OutX_F16 >> 4 ) - MEMS_Info.OutX;
    GradY = ( MEMS_Info.OutY_F16 >> 4 ) - MEMS_Info.OutY;
    GradZ = ( MEMS_Info.OutZ_F16 >> 4 ) - MEMS_Info.OutZ;

    Gradient2 = ( s32 )GradX * ( s32 )GradX + ( s32 )GradY * ( s32 )GradY + ( s32 )GradZ * ( s32 )GradZ;

    Gradient2 *= freqTIM2[CurrentSpeed] ;
    Gradient2 /= freqTIM2[SPEED_MEDIUM] ;


    // MEMS is shocked, let's beep!
    if (( Gradient2 > GRAD_SHOCK ) && ( BUZZER_GetMode() == BUZZER_OFF ) && ( StartingFromResetOrShockCounter == 0 ) )
    {
        MEMS_Info.Shocked++;
        /*FL071007       = 1;
        Suggested by Bob Seabrook:  a further possiblity is to increment Shocked rather than just setting it
        So it can still be tested for non zero as before but one can  get more
        info from the s32 without extra cost. */

#define DELAY_BETWEEN_TWO_SHOCK     200
#define MAX_DELAY_FOR_DOUBLECLICK   800

        delta_time_ms = (( TimeCounterForDoubleClick - TimeLastShock ) * 1000 ) / freqTIM2[CurrentSpeed];

        if ( delta_time_ms > DELAY_BETWEEN_TWO_SHOCK )
        {
            if ( delta_time_ms < MAX_DELAY_FOR_DOUBLECLICK )
            {
                MEMS_Info.DoubleClick++;
//               TimeLastShock = TimeCounterForDoubleClick;    // YRT20090304
                BUZZER_SetMode( BUZZER_SHORTBEEP );
                StartingFromResetOrShockCounter = freqTIM2[CurrentSpeed]; //1s off
            }
            else
            {
//                TimeLastShock = TimeCounterForDoubleClick;   // YRT20090304
                delta_time_ms  = 0;
                StartingFromResetOrShockCounter = 0;
            }
            TimeLastShock = TimeCounterForDoubleClick;         // YRT20090304
        }
        else
        {
            ;//TimeLastShock = TimeCounterForDoubleClick;
        }
    }
}


/* Public functions ----------------------------------------------------------*/

/*******************************************************************************
*
*                                MEMS_GetPosition
*
*******************************************************************************/
/******************************************************************************/
void MEMS_GetPosition( coord_t* pX, coord_t* pY )
{
    *pX = MEMS_Info.OutX - XInit;
    *pY = MEMS_Info.OutY - YInit;
}

/*******************************************************************************
*
*                                MEMS_GetRotation
*
*******************************************************************************/
/******************************************************************************/
void MEMS_GetRotation( Rotate_H12_V_Match_TypeDef* pH12 )
{
    s16 sX = MEMS_Info.OutX;
    s16 sY = MEMS_Info.OutY;

    if ((( sX <= -MARGIN ) && ( sY <= 0 ) && ( sX <= sY ) ) ||
            (( sX <= - MARGIN ) && ( sY > 0 ) && ( sX <= ( -sY ) ) ) )
    {
        // 1st case: x<0, |x|>y => H12 = V9
        *pH12 = V9;
    }
    else if ((( sY <= -MARGIN ) && ( sX <= 0 ) && ( sY <= sX ) ) ||
             (( sY <= -MARGIN ) && ( sX > 0 ) && ( sY <= ( -sX ) ) ) )
    {
        // 2nd case: y<0, |y|>x => H12 = V12
        *pH12 = V12;
    }
    else if ((( sX >= MARGIN ) && ( sY <= 0 ) && ( sX >= ( -sY ) ) ) ||
             (( sX >= MARGIN ) && ( sY > 0 ) && ( sX >= sY ) ) )
    {
        // 3rd case: x>0, |x|>y => H12=V3
        *pH12 = V3;
    }
    else if ((( sY >= MARGIN ) && ( sX <= 0 ) && ( sY >= ( -sX ) ) ) ||
             (( sY >= MARGIN ) && ( sX > 0 ) && ( sY >= sX ) ) )
    {
        // 4th case: y>0,  |y|>x => H12=V6
        *pH12 = V6;
    }
}

/*******************************************************************************
*
*                                MEMS_SetNeutral
*
*******************************************************************************/
/******************************************************************************/
void MEMS_SetNeutral( void )
{
    // Set Neutral position.
    MEMS_GetPosition( &XInit, &YInit );
}

/*******************************************************************************
*
*                                MEMS_GetInfo
*
*******************************************************************************/
/******************************************************************************/
tMEMS_Info* MEMS_GetInfo( void )
{
    return &MEMS_Info;
}