ATY_LIB/KEY_ATY.c

/**
* @file KEY_ATY.c
*
* @param Project DEVICE_GENERAL_ATY_LIB
*
* @author ATY
*
* @copyright
*       - Copyright 2017 - 2023 MZ-ATY
*       - This code follows:
*           - MZ-ATY Various Contents Joint Statement -
*               <a href="https://mengze.top/MZ-ATY_VCJS">
*                        https://mengze.top/MZ-ATY_VCJS</a>
*           - CC 4.0 BY-NC-SA -
*               <a href="https://creativecommons.org/licenses/by-nc-sa/4.0/">
*                        https://creativecommons.org/licenses/by-nc-sa/4.0/</a>
*       - Your use will be deemed to have accepted the terms of this statement.
*
* @brief functions of keys for all embedded device
*
* @version
*       - 1_01_230514 > ATY
*           -# Preliminary version, first Release
********************************************************************************
*/



#ifndef __KEY_ATY_C
#define __KEY_ATY_C

#include "KEY_ATY.h"

/******************************* For user *************************************/
uint8_t KEY_PIN_GROUP[MAX_KEY_NUMBER] = {0x01 << 7, 0x01 << 6, 0x01 << 5};
uint8_t KEY_PIN_GROUP_AD[MAX_KEY_NUMBER] = {9, 0, 0};

/******************************************************************************/

uint8_t lastKeyType[MAX_KEY_NUMBER] = {0};
uint8_t keyExportType[MAX_KEY_NUMBER] = {0};
uint16_t keyScanCount[MAX_KEY_NUMBER] = {0};
uint16_t keyReleaseCount[MAX_KEY_NUMBER] = {0};

/**
 * @brief   process key state from IO level
 * @param   keyIndex key IO pin to monitor
 * @note    SINGLE and DOUBLE type need key release to response
 */
void KeyStateMachine(uint8_t keyIndex)
{
    // P_SW2 |= 0x80;
    // P2IM0 = 0xE0;
    // P2IM1 = 0xE0;       // high level IT
    // P2INTE = 0xE0;      // 25,26,27 enable IT
    // P_SW2 &= ~0x80;
    // EA = 1;             // enable alla IT

    if((KEY_PORT & KEY_PIN_GROUP[keyIndex]) == 0){      // release
        // key debounce, 20ms miss when state machine put at 1ms cycle
        if(keyReleaseCount[keyIndex] > KEY_RELEASE_DEBOUNCE_TIME){
            // key debounce, 100ms miss when state machine put at 1ms cycle
            if(keyScanCount[keyIndex] >= KEY_PRESS_DEBOUNCE_TIME
                && keyScanCount[keyIndex] < KEY_TYPE_LONG_TIME){
                keyExportType[keyIndex] = KEY_TYPE_SINGLE;
                keyScanCount[keyIndex] = 0;
                keyReleaseCount[keyIndex] = 0;
            }
            else{
                // access new key after use last press until last press release
                if(lastKeyType[keyIndex] == KEY_TYPE_ACCESS_NEW)
                    lastKeyType[keyIndex] = 0;
                keyExportType[keyIndex] = KEY_TYPE_RELASE;
                keyScanCount[keyIndex] = 0;
            }
        }
        if(keyReleaseCount[keyIndex] < KEY_RELEASE_DEBOUNCE_TIME * 2)   // 2 margin
            keyReleaseCount[keyIndex]++;
    }
    else{
        if(keyScanCount[keyIndex] < KEY_TYPE_VLONG_TIME * 1.2)          // 1.2 margin
            keyScanCount[keyIndex]++;
        // 1000ms long press
        if(keyScanCount[keyIndex] >= KEY_TYPE_LONG_TIME
            && keyScanCount[keyIndex] < KEY_TYPE_VLONG_TIME){
            keyExportType[keyIndex] = KEY_TYPE_LONG;
        }
        // 2000ms very long press
        else if(keyScanCount[keyIndex] >= KEY_TYPE_VLONG_TIME){
            keyExportType[keyIndex] = KEY_TYPE_VLONG;
        }
    }

    if(keyExportType[keyIndex] != KEY_TYPE_RELASE
        && lastKeyType[keyIndex] == 0){
        lastKeyType[keyIndex] = keyExportType[keyIndex];
    }
}


float KeyStateMachine_AD(uint8_t keyIndex)
{
    float tempData = ADC_Get(KEY_PIN_GROUP_AD[keyIndex]);
    if(tempData < KEY_AD_Threshold){     // release
        // key debounce, 20ms miss when state machine put at 1ms cycle
        if(keyReleaseCount[keyIndex] > KEY_RELEASE_DEBOUNCE_TIME){
            // key debounce, 100ms miss when state machine put at 1ms cycle
            if(keyScanCount[keyIndex] >= KEY_PRESS_DEBOUNCE_TIME
                && keyScanCount[keyIndex] < KEY_TYPE_LONG_TIME){
                keyExportType[keyIndex] = KEY_TYPE_SINGLE;
                keyScanCount[keyIndex] = 0;
                keyReleaseCount[keyIndex] = 0;
            }
            else{
                // access new key after use last press until last press release
                if(lastKeyType[keyIndex] == KEY_TYPE_ACCESS_NEW)
                    lastKeyType[keyIndex] = 0;
                keyExportType[keyIndex] = KEY_TYPE_RELASE;
                keyScanCount[keyIndex] = 0;
            }
        }
        if(keyReleaseCount[keyIndex] < KEY_RELEASE_DEBOUNCE_TIME * 2)   // 2 margin
            keyReleaseCount[keyIndex]++;
    }
    else{
        if(keyScanCount[keyIndex] < KEY_TYPE_VLONG_TIME * 1.2)          // 1.2 margin
            keyScanCount[keyIndex]++;
        // 1000ms long press
        if(keyScanCount[keyIndex] >= KEY_TYPE_LONG_TIME
            && keyScanCount[keyIndex] < KEY_TYPE_VLONG_TIME){
            keyExportType[keyIndex] = KEY_TYPE_LONG;
        }
        // 2000ms very long press
        else if(keyScanCount[keyIndex] >= KEY_TYPE_VLONG_TIME){
            keyExportType[keyIndex] = KEY_TYPE_VLONG;
        }
    }

    if(keyExportType[keyIndex] != KEY_TYPE_RELASE
        && lastKeyType[keyIndex] == 0){
        lastKeyType[keyIndex] = keyExportType[keyIndex];
    }
    return tempData;
}


#endif /* __KEY_ATY_C */

/******************************** End Of File *********************************/