key 模块，旋钮+按键，两路AD取值

最新推荐文章于 2023-04-26 16:59:25 发布
最新推荐文章于 2023-04-26 16:59:25 发布
阅读量2.3k 收藏 3
点赞数
分类专栏： STM 文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/huan447882949/article/details/78870827
版权

旋钮的处理方式

  1. 正交解码（原理是相位差）：适合精度要求高的场合,测速；
  2. IO读取相位差的高低电平（原理是相位差）：比较浪费资源，精度不是最高；
  3. 硬件配置A、B相高低不同有序电平，读取AD值（不同旋转方向有序电平）：精度差，适合对精度要求不高的场合。
/******************** (C) COPYRIGHT 2011 APTENON ********************
 * File Name          : key.c
 * Author             : edwin kang
 * Version            : V0.0
 * Date               : 11/30/2011
 * Description        : key  file.
 *******************************************************************************/
#define _KEY_C_
#include "includes.h"
/*lint -e830 -e831 -e534 */ //return val
/*lint  -e525 -e725 -e539 */ //shuojin
#define KEY_NULL     0xFF
/*********************************************
Function:       Key_Null
Description:
Write/Modify:   edwin
Time:       2011-12-8
 *********************************************/
static void Key_Null(BYTE uAction)
{
    uAction = uAction;
}

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

static void Key_DVD_Reject(BYTE uAction)
{
    if (uAction == 0)
    {
        //pressed
        //Beep_On();
    }
    else if (uAction == 1)
    {
        //keep
    }
    else if (uAction == 2)
    {
        //bounce
        //  DVD_Fill_OpCmd(DVD_CMD_EJECT);
    }
}


/*
************************************
 KEY_MAP(BYTE action),NAVI
 按键MAP
************************************
*/
void  KEY_MAP(BYTE uAction)
{
    if (uAction == 0)
    {
        //pressed
        //Beep_On();
        //IPC_SendKeyMessage_NAVI(MSG_ACTION_PRESSED);
    }
    else if (uAction == 1)
    {
        //keep
    }
    else if (uAction == 2)
    {
        //bounce
        // GpsSend_CntrCmd(0x92);
        //  IPC_SendKeyMessage_NAVI(MSG_ACTION_PRESSED);
    }

}


/*
************************************
 KEY_Media(BYTE action),car
 按键MAP
************************************
*/
void  KEY_Media(BYTE uAction)
{
    if (uAction == 0)
    {
        //pressed
        //Beep_On();

    }
    else if (uAction == 1)
    {
        //keep
    }
    else if (uAction == 2)
    {
        //bounce
        //IPC_SendKeyMessage_Media_Sw(MSG_ACTION_PRESSED);

    }

}

/*
************************************
 KEY_TEL(BYTE action),bluetooth
 按键MAP
************************************
*/
void  KEY_TEL(BYTE uAction)
{
    if (uAction == 0)
    {
        //pressed
        //Beep_On();

    }
    else if (uAction == 1)
    {
        //keep
    }
    else if (uAction == 2)
    {
        //bounce

        //IPC_SendKeyMessage_Radio(MSG_ACTION_PRESSED);//Millertao20150402

    }

}

/*
************************************
 KEY_Menu(BYTE action),menu
 按键MAP
************************************
*/
void  KEY_Menu(BYTE uAction)
{
    if (uAction == 0)
    {
        //pressed
        //Beep_On();

    }
    else if (uAction == 1)
    {
        //keep
    }
    else if (uAction == 2)
    {
        //bounce
        //printf("\r\n>>>>key_menu ");
        LF_CanBus_SendControlCmd(key_menu);
        //IPC_SendKeyMessage_Menu(MSG_ACTION_PRESSED);
    }

}
/*
************************************
 KEY_Radio(BYTE action),radio
 按键radio,mode
************************************
*/
const BYTE SRC_Mode[6] =
{
    SYSTEM_MODE_IN_CAR_MEDIA,
    SYSTEM_MODE_IN_DVD,
    SYSTEM_MODE_IN_mp5_music,
    SYSTEM_MODE_IN_AUX,
    SYSTEM_MODE_IN_TV,
    SYSTEM_MODE_IN_CARREC,

};
void  KEY_Radio(BYTE uAction)
{
    if (uAction == 0)
    {
        //pressed
        //Beep_On();

    }
    else if (uAction == 1)
    {
        //keep
    }
    else if (uAction == 2)
    {
        //bounce
        //IPC_SendKeyMessage_Radio(MSG_ACTION_PRESSED);//Millertao20150402

    }

}
/*
************************************
 KEY_Enter(BYTE action),radio
 按键MAP
************************************
*/
void  KEY_Enter(BYTE uAction)
{
    if (uAction == 0)
    {
        //pressed
        //Beep_On();

    }
    else if (uAction == 1)
    {
        //keep
    }
    else if (uAction == 2)
    {
        //bounce
        //printf("\r\n>>>>key_enter ");
        LF_CanBus_SendControlCmd(key_enter);
        // IPC_SendKeyMessage_ENTER(MSG_ACTION_BOUNCE);
    }

}
/*
************************************
 KEY_Back(BYTE action),back
 按键MAP
************************************
*/

void  KEY_Back(BYTE uAction)
{
    if (uAction == 0)
    {
        //pressed
        //Beep_On();

    }
    else if (uAction == 1)
    {
        //keep
    }
    else if (uAction == 2)
    {
        //bounce
        //printf("\r\n>>>>key_back ");
        LF_CanBus_SendControlCmd(key_back);
    }

}

/*
************************************
 KEY_Option(BYTE action),option
 按键MAP
************************************
*/

void  KEY_Option(BYTE uAction)
{
    if (uAction == 0)
    {
        //pressed
        //Beep_On();

    }
    else if (uAction == 1)
    {
        //keep
    }
    else if (uAction == 2)
    {
        //bounce
        //LF_CanBus_SendControlCmd(BENZE_CMD_KNOB_DN_PRESSED);
        // IPC_SendKeyMessage_DEC(MSG_ACTION_PRESSED);
    }

}


/**************************************************************************/
/*                                                                        */
/**************************************************************************/
/*
************************************
 KEY_Up(BYTE action),key_up
 按键MAP
************************************
*/
void  KEY_Up(BYTE uAction)
{
    if (uAction == 0)
    {
        //pressed
        //Beep_On();

    }
    else if (uAction == 1)
    {
        //keep
    }
    else if (uAction == 2)
    {
        //bounce
        // printf("\r\n>>>>key_up ");
        LF_CanBus_SendControlCmd(key_up);
    }

}
/*
************************************
 KEY_Dn(BYTE action),key_Dn
 按键MAP
************************************
*/
void  KEY_Dn(BYTE uAction)
{
    if (uAction == 0)
    {
        //pressed
        //Beep_On();

    }
    else if (uAction == 1)
    {
        //keep
    }
    else if (uAction == 2)
    {
        //bounce
        // printf("\r\n>>>>key_down ");
        LF_CanBus_SendControlCmd(key_down);
    }

}
/*
************************************
 KEY_Left(BYTE action),key_Left
 按键MAP
************************************
*/
void  KEY_Left(BYTE uAction)
{
    if (uAction == 0)
    {
        //pressed
        //Beep_On();

    }
    else if (uAction == 1)
    {
        //keep
    }
    else if (uAction == 2)
    {
        //bounce
        // printf("\r\n>>>>key_left ");
        LF_CanBus_SendControlCmd(key_left);
    }

}
/*
************************************
 KEY_Right(BYTE action),key_Right
 按键MAP
************************************
*/
void  KEY_Right(BYTE uAction)
{
    if (uAction == 0)
    {
        //pressed
        //Beep_On();

    }
    else if (uAction == 1)
    {
        //keep
    }
    else if (uAction == 2)
    {
        //bounce
        // printf("\r\n>>>>key_right ");
        LF_CanBus_SendControlCmd(key_right);
    }

}




#if 0//Miller.Tao,20140912
static const KEY_DEFINE KEY_TAB[4][5] =
{
    {
        //KEY0
        {
            0, 100, Key_DVD_Reject
        }
        ,  //    key,
        {
            0, 0, Key_Null
        }
        ,  //    key
        {
            0, 0, Key_Null
        }
        ,  //    key
        {
            0, 0, Key_Null
        }
        ,  //    key
        {
            3300, 3300, Key_Null
        }
        ,  //    key
    }
    ,
    //KEY1
    {
        {
            0, 0, Key_Null
        }
        ,  //    key
        {
            0, 0, Key_Null
        }
        ,  //    key
        {
            0, 0, Key_Null
        }
        ,  //    key
        {
            0, 0, Key_Null
        }
        ,  //    key
        {
            3300, 3300, Key_Null
        }
        ,  //    key
    }
    ,
    //KEY2
    {
        {
            0, 0, Key_Null
        }
        ,  //    key
        {
            0, 0, Key_Null
        }
        ,  //    key
        {
            0, 0, Key_Null
        }
        ,  //    key
        {
            0, 0, Key_Null
        }
        ,  //    key
        {
            3300, 3300, Key_Null
        }
        ,  //    key
    }
    ,
    //KEY3
    {
        {
            0, 0, Key_Null
        }
        ,  //    key
        {
            0, 0, Key_Null
        }
        ,  //    key
        {
            0, 0, Key_Null
        }
        ,  //    key
        {
            0, 0, Key_Null
        }
        ,  //    key
        {
            3300, 3300, Key_Null
        }
        ,  //    key
    }
    ,
};
#else
#define VoltageDeta 100
static const KEY_DEFINE KEY_TAB[4][8] =
{
    {
        //KEY0

        {
            329-VoltageDeta, 329+VoltageDeta, KEY_Up
        }
        ,  //    key,"key_up"
        {
            1716-VoltageDeta, 1716+VoltageDeta, KEY_Dn
        }
        ,  //    key,"key_Dn"
        {
            1043-VoltageDeta, 1043+VoltageDeta, KEY_Left
        }
        ,  //    key,"key_Left"
        {
            2500-VoltageDeta, 2500+VoltageDeta, KEY_Right
        }
        ,  //    key,"key_Right"
        {

            2983-VoltageDeta, 2983+VoltageDeta, KEY_Enter
        }
        ,  //    key,"key_Enter"
        {

            666-VoltageDeta, 666+VoltageDeta, KEY_Menu
        }
        ,  //    key,"key_Menu"
        {

            2144-VoltageDeta, 2144+VoltageDeta, KEY_Back
        }
        ,  //    key,"key_back"

        {
            3300, 3300, Key_Null
        }
        ,  //    key
    }
    ,
    //KEY1
    {
        {
            0, 0, Key_Null
        }
        ,  //    key
        {
            0, 0, Key_Null
        }
        ,  //    key
        {
            0, 0, Key_Null
        }
        ,  //    key
        {
            0, 0, Key_Null
        }
        ,  //    key
        {
            3300, 3300, Key_Null
        }
        ,  //    key
    }
    ,
    //KEY2
    {
        {
            0, 0, Key_Null
        }
        ,  //    key
        {
            0, 0, Key_Null
        }
        ,  //    key
        {
            0, 0, Key_Null
        }
        ,  //    key
        {
            0, 0, Key_Null
        }
        ,  //    key
        {
            3300, 3300, Key_Null
        }
        ,  //    key
    }
    ,
    //KEY3
    {
        {
            0, 0, Key_Null
        }
        ,  //    key
        {
            0, 0, Key_Null
        }
        ,  //    key
        {
            0, 0, Key_Null
        }
        ,  //    key
        {
            0, 0, Key_Null
        }
        ,  //    key
        {
            3300, 3300, Key_Null
        }
        ,  //    key
    }
    ,
};
#endif
static u8 GetKeyPos(u16 keyVoltage, u8 uKeyGroup);
/***************************************KEY START ***********************************/
/*********************************************
Function:       Key_Dispatch
Description:    read opration code
Write/Modify:   edwin
Time:       2011-12-8
 *********************************************/
u16 GetVotFromAD(u16 u16AD)
{
    //u16 int_part,float_part;
    u16 temp;
    temp = u16AD;
    //把采集到的数据转换成电压值
    temp = (u16)((((u32)temp) * 3300) >> 12);
    //int_part   = temp/1000;
    //float_part = temp%1000;
    return temp;
}

/**************************************************************************/
/*                                                                        */
/**************************************************************************/
static u8 GetKeyPos(u16 keyVoltage, u8 uKeyGroup)
{
    u8 i;
    for (i = 0; KEY_TAB[uKeyGroup][i].keyVoltage_high != 3300 &&
         KEY_TAB[uKeyGroup][i].keyVoltage_low != 3300; i++)
    {
        if (keyVoltage >= KEY_TAB[uKeyGroup][i].keyVoltage_low && keyVoltage <=
            KEY_TAB[uKeyGroup][i].keyVoltage_high)
        {
            return i;
        }
    }
    return KEY_NULL;
}

/**************************************************************************/
/*                                                                        */
/**************************************************************************/
//u8 u8Key0Pos;
void Key_Dispatch(void)
{
    u8  u8Key1Pos, u8Key2Pos, u8Key3Pos;
    u8 u8Key0Pos;
    /*comment these key if be used */
    //g_stuKEY.KeyAD[1] = 0xFF;
    g_stuKEY.KeyAD[2] = 0xFF;
    g_stuKEY.KeyAD[3] = 0xFF;
    //g_stuKEY.keytest =  GetVotFromAD(g_stuKEY.KeyAD[0]);
    //return;
    switch (g_stuKEY.KeyScanProgress)
    {
        case E_KEY_READ_FIRSR:
            g_stuKEY.keytest =  GetVotFromAD(g_stuKEY.KeyAD[0]);

#if 1
            u8Key0Pos = GetKeyPos(GetVotFromAD(g_stuKEY.KeyAD[0]), 0);
            u8Key1Pos =KEY_NULL;// GetKeyPos(GetVotFromAD(g_stuKEY.KeyAD[1]), 1);
            u8Key2Pos = GetKeyPos(GetVotFromAD(g_stuKEY.KeyAD[2]), 2);
            u8Key3Pos = GetKeyPos(GetVotFromAD(g_stuKEY.KeyAD[3]), 3);
#else
            u8Key0Pos = GetKeyPos(g_stuKEY.KeyAD[0], 0);
            u8Key1Pos = GetKeyPos(g_stuKEY.KeyAD[1], 1);
            u8Key2Pos = GetKeyPos(g_stuKEY.KeyAD[2], 2);
            u8Key3Pos = GetKeyPos(g_stuKEY.KeyAD[3], 3);
#endif
            if (u8Key0Pos != KEY_NULL)
            {
                //
                g_stuKEY.KeyScanProgress = E_KEY_READ_DELAY;
                g_stuKEY.key0Pos = u8Key0Pos;
            }
            if (u8Key1Pos != KEY_NULL)
            {
                //
                g_stuKEY.KeyScanProgress = E_KEY_READ_DELAY;
                g_stuKEY.key1Pos = u8Key1Pos;
            }
            if (u8Key2Pos != KEY_NULL)
            {
                //
                g_stuKEY.KeyScanProgress = E_KEY_READ_DELAY;
                g_stuKEY.key2Pos = u8Key2Pos;
            }
            if (u8Key3Pos != KEY_NULL)
            {
                //
                g_stuKEY.KeyScanProgress = E_KEY_READ_DELAY;
                g_stuKEY.key3Pos = u8Key3Pos;
            }
            break;
        case E_KEY_READ_DELAY:
#if 1
            u8Key0Pos = GetKeyPos(GetVotFromAD(g_stuKEY.KeyAD[0]), 0);
            u8Key1Pos =KEY_NULL;//  GetKeyPos(GetVotFromAD(g_stuKEY.KeyAD[1]), 1);
            u8Key2Pos = GetKeyPos(GetVotFromAD(g_stuKEY.KeyAD[2]), 2);
            u8Key3Pos = GetKeyPos(GetVotFromAD(g_stuKEY.KeyAD[3]), 3);
#else
            u8Key0Pos = GetKeyPos(g_stuKEY.KeyAD[0], 0);
            u8Key1Pos = GetKeyPos(g_stuKEY.KeyAD[1], 1);
            u8Key2Pos = GetKeyPos(g_stuKEY.KeyAD[2], 2);
            u8Key3Pos = GetKeyPos(g_stuKEY.KeyAD[3], 3);
#endif
            if (g_stuKEY.key0Pos != KEY_NULL && g_stuKEY.key0Pos == u8Key0Pos)
            {
                //
                KEY_TAB[0][g_stuKEY.key0Pos].keyfun(0);
                g_stuKEY.KeyScanProgress = E_KEY_KEEP_DELAY;
                g_stuKEY.wKeyKeepDelay = 200;
            }
            else if (g_stuKEY.key1Pos != KEY_NULL && g_stuKEY.key1Pos == u8Key1Pos)
            {
                //
                KEY_TAB[1][g_stuKEY.key2Pos].keyfun(0);
                g_stuKEY.KeyScanProgress = E_KEY_KEEP_DELAY;
                g_stuKEY.wKeyKeepDelay = 200;
            }
            else if (g_stuKEY.key2Pos != KEY_NULL && g_stuKEY.key2Pos == u8Key2Pos)
            {
                //
                KEY_TAB[2][g_stuKEY.key2Pos].keyfun(0);
                g_stuKEY.KeyScanProgress = E_KEY_KEEP_DELAY;
                g_stuKEY.wKeyKeepDelay = 200;
            }
            else if (g_stuKEY.key3Pos != KEY_NULL && g_stuKEY.key3Pos == u8Key3Pos)
            {
                //
                KEY_TAB[3][g_stuKEY.key3Pos].keyfun(0);
                g_stuKEY.KeyScanProgress = E_KEY_KEEP_DELAY;
                g_stuKEY.wKeyKeepDelay = 200;
            }
            else
            {
                g_stuKEY.key0Pos = KEY_NULL;
                g_stuKEY.key1Pos = KEY_NULL;
                g_stuKEY.key2Pos = KEY_NULL;
                g_stuKEY.key3Pos = KEY_NULL;
                g_stuKEY.KeyScanProgress = E_KEY_READ_FIRSR;
            }
            break;
        case E_KEY_KEEP_DELAY:
            if (DecWordToZero(&g_stuKEY.wKeyKeepDelay))
            {
                g_stuKEY.KeyScanProgress = E_KEY_KEEP;
                g_stuKEY.wKeyKeepDelay = KEY_LONGPRESS_BREAK;
            }
            else
            {
#if 1
                u8Key0Pos = GetKeyPos(GetVotFromAD(g_stuKEY.KeyAD[0]), 0);
                u8Key1Pos =KEY_NULL;//  GetKeyPos(GetVotFromAD(g_stuKEY.KeyAD[1]), 1);
                u8Key2Pos = GetKeyPos(GetVotFromAD(g_stuKEY.KeyAD[2]), 2);
                u8Key3Pos = GetKeyPos(GetVotFromAD(g_stuKEY.KeyAD[3]), 3);
#else
                u8Key0Pos = GetKeyPos(g_stuKEY.KeyAD[0], 0);
                u8Key1Pos = GetKeyPos(g_stuKEY.KeyAD[1], 1);
                u8Key2Pos = GetKeyPos(g_stuKEY.KeyAD[2], 2);
                u8Key3Pos = GetKeyPos(g_stuKEY.KeyAD[3], 3);
#endif
                if (g_stuKEY.key0Pos != KEY_NULL && g_stuKEY.key0Pos == u8Key0Pos)
                {
                    //
                }
                else if (g_stuKEY.key1Pos != KEY_NULL && g_stuKEY.key1Pos == u8Key1Pos)
                {
                    //
                }
                else if (g_stuKEY.key2Pos != KEY_NULL && g_stuKEY.key2Pos == u8Key2Pos)
                {
                    //
                }
                else if (g_stuKEY.key3Pos != KEY_NULL && g_stuKEY.key3Pos == u8Key3Pos)
                {
                    //
                }
                else
                {
                    g_stuKEY.KeyScanProgress = E_KEY_BOUNCE;
                }
            }
            break;
        case E_KEY_KEEP:
#if 1
            u8Key0Pos = GetKeyPos(GetVotFromAD(g_stuKEY.KeyAD[0]), 0);
            u8Key1Pos =KEY_NULL;//  GetKeyPos(GetVotFromAD(g_stuKEY.KeyAD[1]), 1);
            u8Key2Pos = GetKeyPos(GetVotFromAD(g_stuKEY.KeyAD[2]), 2);
            u8Key3Pos = GetKeyPos(GetVotFromAD(g_stuKEY.KeyAD[3]), 3);
#else
            u8Key0Pos = GetKeyPos(g_stuKEY.KeyAD[0], 0);
            u8Key1Pos = GetKeyPos(g_stuKEY.KeyAD[1], 1);
            u8Key2Pos = GetKeyPos(g_stuKEY.KeyAD[2], 2);
            u8Key3Pos = GetKeyPos(g_stuKEY.KeyAD[3], 3);
#endif
            if (g_stuKEY.key0Pos != KEY_NULL && g_stuKEY.key0Pos == u8Key0Pos)
            {
                //
                if (DecWordToZero(&g_stuKEY.wKeyKeepDelay))
                {
                    g_stuKEY.wKeyKeepDelay = KEY_LONGPRESS_BREAK;
                    //
                    KEY_TAB[0][g_stuKEY.key0Pos].keyfun(1);
                }
            }
            else if (g_stuKEY.key1Pos != KEY_NULL && g_stuKEY.key1Pos == u8Key1Pos)
            {
                //
                if (DecWordToZero(&g_stuKEY.wKeyKeepDelay))
                {
                    g_stuKEY.wKeyKeepDelay = KEY_LONGPRESS_BREAK;
                    //
                    KEY_TAB[1][g_stuKEY.key1Pos].keyfun(1);
                }
            }
            else if (g_stuKEY.key2Pos != KEY_NULL && g_stuKEY.key2Pos == u8Key2Pos)
            {
                //
                if (DecWordToZero(&g_stuKEY.wKeyKeepDelay))
                {
                    g_stuKEY.wKeyKeepDelay = KEY_LONGPRESS_BREAK;
                    //
                    KEY_TAB[2][g_stuKEY.key2Pos].keyfun(1);
                }
            }
            else if (g_stuKEY.key3Pos != KEY_NULL && g_stuKEY.key3Pos == u8Key3Pos)
            {
                //
                if (DecWordToZero(&g_stuKEY.wKeyKeepDelay))
                {
                    g_stuKEY.wKeyKeepDelay = KEY_LONGPRESS_BREAK;
                    //
                    KEY_TAB[3][g_stuKEY.key3Pos].keyfun(1);
                }
            }
            else
            {
                g_stuKEY.KeyScanProgress = E_KEY_BOUNCE;
            }
            break;
        case E_KEY_BOUNCE:
            if (g_stuKEY.key0Pos != KEY_NULL)
            {
                //
                KEY_TAB[0][g_stuKEY.key0Pos].keyfun(2);
            }
            else if (g_stuKEY.key1Pos != KEY_NULL)
            {
                //
                KEY_TAB[1][g_stuKEY.key1Pos].keyfun(2);
            }
            else if (g_stuKEY.key2Pos != KEY_NULL)
            {
                //
                KEY_TAB[2][g_stuKEY.key2Pos].keyfun(2);
            }
            else if (g_stuKEY.key3Pos != KEY_NULL)
            {
                //
                KEY_TAB[3][g_stuKEY.key3Pos].keyfun(2);
            }
            g_stuKEY.KeyScanProgress = E_KEY_READ_FIRSR;
            g_stuKEY.key0Pos = KEY_NULL;
            g_stuKEY.key1Pos = KEY_NULL;
            g_stuKEY.key2Pos = KEY_NULL;
            g_stuKEY.key3Pos = KEY_NULL;
            break;
    }
}


void KeyTask(void)
{

    if (!wKeyScanTimer)
    {
        Key_Dispatch();
        wKeyScanTimer = 20;
        //printf("\r\ng_stuKEY.KeyAD[0] : %d", g_stuKEY.keytest);
    }

}


BYTE encoderA;
BYTE encoderB;
BYTE gEncoder_A_end;//bakeup
BYTE gEncoder_B_end;//bakeup
//BYTE gRemVal_CMD;//

void Init_Encoder(void)
{
    // gEncoder_A_end = GPIO_ReadInputDataBit(KnobENC_ENDA_PORT,KnobENC_ENDA_PIN);
    //gEncoder_B_end = GPIO_ReadInputDataBit(KnobENC_ENDB_PORT,KnobENC_ENDB_PIN);
}

/*
*************************************************
*
*handle encoder
*Author:Miller.Tao20140911
*
*************************************************
*/
#define changed_value 200
#define press_low 0
#define press_mid 1
#define press_hig 2

void EncoderProcess(void)
{
    static BYTE press_statu_count=0;
    static BYTE press_statu=0xff;



    if(g_stuKEY.KeyAD[1]>=(2000-changed_value)&&g_stuKEY.KeyAD[1]<=(2000+200))
    {
        if(press_statu_count<=1)
        {
            //printf("\r\npress_statu :  press_mid  : %d", g_stuKEY.KeyAD[1]);
            press_statu_count++;
        }

        if(press_statu_count>=2)
        {

            press_statu=press_mid;
        }
    }
    else
        press_statu_count=0;

    if(g_stuKEY.KeyAD[1]>=(300-changed_value)&&g_stuKEY.KeyAD[1]<=(300+200))
    {
        if(press_statu==press_mid)
        {
            //printf("\r\nKEY_statu :  key_dec %d", g_stuKEY.KeyAD[1] );
            LF_CanBus_SendControlCmd(key_dec);
        }
        else if(press_statu==press_hig)
        {
            //printf("\r\nKEY_statu :  key_inc %d", g_stuKEY.KeyAD[1] );
            LF_CanBus_SendControlCmd(key_inc);
        }
        //printf("\r\npress_statu :  press_low  : %d", g_stuKEY.KeyAD[1]);
        press_statu=press_low;
    }

    if(g_stuKEY.KeyAD[1]>=(4000-changed_value)&&g_stuKEY.KeyAD[1]<=(4000+200))
    {
        if(press_statu==press_mid)
        {
            //printf("\r\nKEY_statu :  key_inc %d", g_stuKEY.KeyAD[1] );
            LF_CanBus_SendControlCmd(key_inc);
        }
        else if(press_statu==press_low)
        {
            //printf("\r\nKEY_statu :  key_dec %d", g_stuKEY.KeyAD[1] );
            LF_CanBus_SendControlCmd(key_dec);
        }
        //printf("\r\npress_statu :  press_hig  : %d", g_stuKEY.KeyAD[1]);

        press_statu=press_hig;
    }

#if 0
    BYTE temp_A;
    BYTE temp_B;

    temp_A = GPIO_ReadInputDataBit(KnobENC_ENDA_PORT,KnobENC_ENDA_PIN);
    temp_B = GPIO_ReadInputDataBit(KnobENC_ENDB_PORT,KnobENC_ENDB_PIN);

    if(temp_A != temp_B )
    {
        if(temp_A != gEncoder_A_end)
        {

            gRemVal_CMD = 1;
            if(g_stuSYSINFO.uOSDMainMode!=MAIN_OSD_MODE_IN_NAVI)//MillerTao20141125
                LF_CanBus_SendControlCmd(BENZE_CMD_KNOB_TUNEDEC_PRESSED);//Miller.tao20140912
        }
        else if(temp_B != gEncoder_B_end)
        {

            gRemVal_CMD = 0;
            if(g_stuSYSINFO.uOSDMainMode!=MAIN_OSD_MODE_IN_NAVI)//MillerTao20141125
                LF_CanBus_SendControlCmd(BENZE_CMD_KNOB_TUNEINC_PRESSED);
        }

    }
    gEncoder_A_end = temp_A;
    gEncoder_B_end = temp_B;
#endif
}
/***************************************KEY END ***********************************/
#undef _KEY_C_

/*
main()
{
KeyTask();//key 按键
}
void SysTick_Handler(void)
{
    EncoderProcess();

    if(wKeyScanTimer != 0)wKeyScanTimer--;//Key SCAN DELAY
}

*/
/* 这份源代码文件已被未注册的SourceFormatX格式化过 */
/* 如果您想不再添加此类信息，请您注册这个共享软件  */
/* 更多相关信息请访问网站: http://cn.textrush.com  */

/******************** (C) COPYRIGHT 2011  ********************
 * File Name          : key.h
 * Author             : edwin kang
 * Version            : V0.0
 * Date               : 09/8/2011
 * Description        : key.c head file.
 *******************************************************************************/
#ifndef _KEY_H_
#define _KEY_H_
#ifdef _KEY_C_
#define _KEY_EXT_
#else
#define _KEY_EXT_  extern
#endif
#define KEY_LONGPRESS_DELAY_TIMR         50 //10ms
#define KEY_LONGPRESS_BREAK         10 //10ms

#define I2C_KEY_SCAN_FIRST_TIMER    20// 1 ms
#define I2C_KEY_SCAN_SECOND_TIMER   20// 1 ms
#define I2C_KEY_SCAN_ACTION_TIMER   20// 1 ms

typedef enum
{
    E_KEY_READ_FIRSR, E_KEY_READ_DELAY, E_KEY_KEEP_DELAY, E_KEY_KEEP,
    E_KEY_BOUNCE
} E_KEY_SCAN_STATUS;
typedef void(*KeyCallBack)(BYTE);
typedef struct
{
    u16 KeyAD[4];
    E_KEY_SCAN_STATUS KeyScanProgress;
    u16 wKeyKeepDelay;
    u8 key0Pos;
    u8 key1Pos;
    u8 key2Pos;
    u8 key3Pos;
    u16 keytest;



} KEY;
typedef struct
{
    u16 keyVoltage_low;
    u16 keyVoltage_high;
    KeyCallBack keyfun;
} KEY_DEFINE;
_KEY_EXT_ KEY g_stuKEY;
_KEY_EXT_ vu16 wKeyScanTimer;
_KEY_EXT_ BYTE gModeIndex;//millertao20150625

_KEY_EXT_ void Key_Dispatch(void);
_KEY_EXT_ void KeyTask(void);
_KEY_EXT_ u16 GetVotFromAD(u16 u16AD);
_KEY_EXT_ void Key_Q3_KeyBoardScan_Task(void);

_KEY_EXT_ void Init_Encoder(void);

_KEY_EXT_ void EncoderProcess(void);

#endif
Leo-Lian
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
杰理蓝牙AC692N按键调试
10-18 2399
1、首先在sdk_cfg.hl里打开#define __DEBUG，用于串口打印 2、在key.h打开KEY_AD_VDDIO_EN,采用AD按键，比KEY IO可以节约很多IO口 /*按键类型定义*/ #define KEY_AD_RTCVDD_EN 0 ///<采用RTCVDD电源的AD按键使能 #define KEY_AD_VDDIO_EN 1 ///<采用VDDIO电源的AD按键使能 #define KEY_IO_EN 0 ...
【物尽其用】ADKEY多按键制作与经验分享
热门推荐
qq_31247231的博客
07-12 1万+
在开发中，如果需要使用多个按键时，使用ADKEY，往往可以节省很多IO口，可以节省资源。下面，简单介绍一下ADKEY的使用与经验分享。ADKEY原理：通过不同的电阻进行分压，使每个key按下时，IO口读到电压值不同，来确认是KEYn。ADKEY原理图：如上图，当启动KEY按下时，上拉电阻10K通过3K电阻与GND导通，ADKEY读到电压0.76V（理论值）。从而确认为启动按键按下。程序设计经验分享...
ADKEY多按键制作阻值选择
最新发布
anlog的专栏
04-26 1458
(10条消息) 【物尽其用】ADKEY多按键制作与经验分享_SimpleJY的博客-CSDN博客。可以看到波动非常大，尤其最后几个按键的ad采样值差值很小。最小的差值已经只有12个字。推荐此种组合，后续再优化上拉电阻R5的阻值。由此可见，阻值按照等比例比较合适。可以看到最小差值也有38个字。其中的阻值选择经过仿真电路。阻值优化后的仿真电路。2023年4月26日。
【杰理AC692X】ADKEY复用LED指示灯注意事项
xx842678的博客
11-29 2067
ADKEY复用LED指示灯按原厂给的方法，在ADC通道扫描的时候来回切换IO口的方向，在即将扫描设置的ADKEY通道前把AD口设为输入，扫描其他AD通道时设为输出，但原厂给的例子是针对PR口且使用内部上拉的ADKEY，如果换成使用外部VDDIO上拉且不一定是PR口的情况下需要注意几点。 1、使用的是外部上拉，扫描AD口前设置为输入这里上拉要记得关掉，不然会导致按键AD值不稳定。 2、因为默认的A...
linux键值KEY_MENU映射qt,Qt应用开发常见问题
weixin_35089891的博客
05-14 565
Qt判断当前操作系统？可使用宏判断，例如：#ifdef Q_OS_MAC //mac...#endif#ifdef Q_OS_LINUX //linux...#endif#ifdef Q_OS_WIN32 //win...#endif#ifdef __arm__ //arm...#endifQt实现应用程序关闭和重启？//关机按钮-点击槽函数void SystemD::on_shutdownBut...
key_filter_按键消抖模块_
09-30
"key_filter_按键消抖模块_"是一个专为解决这一问题设计的硬件模块，它通常由Verilog（一种硬件描述语言）编写，文件名为`key_filter.v`。在FPGA设计中，Verilog用于描述数字电路的逻辑功能，便于计算机自动综合成...
launchpad-Key-detection-based-on-AD.rar_AD key_AD按键_Launchpad
09-22
【标签】"ad_key" 强调了项目的核心——使用AD转换来读取按键。"ad按键"可能是指那些依赖于模拟信号变化的特殊按键，或者是指使用AD技术的键盘接口。"launchpad"则指的是开发平台，通常指的是Texas Instruments的MSP...
sample-key.tar.gz_ad_key_key tar_t-kernel_按键
09-23
5. **按键映射与事件处理**：根据"ad_key"标签，源代码中可能包含按键的物理位置到逻辑功能的映射，以及对应的事件处理函数。这涉及到用户接口的设计，确保正确解析和响应不同按键组合。 压缩包中的"sample"文件...
key board 键盘模块AD设计 Altium设计 硬件原理图+PCB文件.rar
03-21
key board 键盘模块AD设计 Altium设计 硬件原理图+PCB文件,2层板设计，Altium Designer 设计的工程文件，包括完整的原理图及PCB文件，可以用Altium(AD)软件打开或修改，可作为你产品设计的参考。
ad-key.rar_AD key_ad_key
09-22
综上所述，"ad-key.rar_AD key_ad_key"的内容可能涵盖了多路复用技术、AD转换原理、信号处理、硬件优化以及软件配合等多个方面的知识，对于理解和实现基于一路AD转换器的多键检测系统具有指导意义。通过阅读"ad key....
AD键盘检测键值
04-28
自己写的 AD 键盘检测键值的程序 仅供参考
三个接口25个按键的AD键盘
09-29
三个接口 25个 按键 AD键盘好使的 使用ad处理
linux键值KEY_MENU映射qt,matrix_keypad.c矩阵键盘和QT映射的问题，求各路大神援助
weixin_34947914的博客
05-14 523
我在AM3359上运行的是linux系统，然后做了一个3*3的矩阵键盘。下面是测试函数：#define NOKEY 0#define KEY_ENTER 28#define KEY_F1 59#define KEY_F2 60#define KEY_F3 61#define KEY_F4 62#define KEY_UP 103#define KEY_LEFT 105#define KEY_RIG...
【杰理AC696X】ADKEY复用指示灯不定时出现灯不亮或按键失灵的问题
xx842678的博客
06-20 1070
测试SDK版本：《ac696n_soundbox_sdk_v1.5.0-20211217》ADKEY复用指示灯的做法多用于蓝牙小音箱，IC引脚越来越少，复用也就用的越多了，不过，在使用前应评估好功能，因为复用的做法，肯定会牺牲点东西的，如果体验感啥的。 比如这个图，（V-）按键按下时，LED是会一直导通发光的，按不同阻值的按键还有亮度不一致的问题，这样的问题有的客户是不接受的，这就要另寻他法了。某天调好案子，放在一边测试时，发现指示灯不亮了，按键也不起作用，想起之前AC692系列也有类似的问题，很快就定位到
Android 虚拟按键上报
FANG_YISHAO的博客
10-09 713
概述 本文主要讲述触摸屏上可能用到的虚拟按键menu、home、return，底层驱动的实现和相关实现原理，其中和上层有联系的只是概述。 两种实现方式 对于触摸按键的发送可以分为两种方法：一是android提供的 virtualkey's 架构方法，一种是直接报告key event的方法。 报告keyevent方法 在驱动中添加所支持的按键类型，报告支持事件类型 __set_bit(EV_SYN, input_dev->evbit); //同步事件 ...
杰理之如何修改 ad_key 连接的引脚？【篇】
u013820168的博客
06-08 482
设置 spi 从机参数从机 spi 设备读取接收到的数据。example: 具体示例代码详见 apps/common/example/peripheral/spi/spi_slave/main.c
使用国产KT148A语音芯片sop8封装，用户可以自己更换声音，低成本，高秒数
qiqiwowo2的博客
07-28 734
刚拿到一款新的语音芯片KT148A，国产的，是深圳市清月电子的最新产品，和以前我们用过的OTP语音芯片来对比，还是相当有特色的，比起那些动则2块钱的SOP8封装的语音芯片，KT148A只卖1.5的价格还是比较有优势 同时以前使用OTP的语音芯片，开发起来就很痛苦，而这些痛点都被KT148A给解决了...
杰理之如何修改 ad_key 连接的引脚【篇】
u013820168的博客
03-18 804
答：参考一下配置，ad_channel 和 adkey_pin 是一一对应的。PB01 脚对应的是通道3。 #define AD_CH_PA07 (0x0) #define AD_CH_PA08 (0x1) #define AD_CH_PA10 (0x2) #define AD_CH_PB01 (0x3) #define AD_CH_PB06 (0x4) #define AD_CH_PB07 (0x5) #define AD_CH_PC00 (0x6) #defin
stm32 key按键按下切换两个界面怎么写
04-23
在中断服务程序中，您需要编写代码来实现您的要求，即切换两个界面。具体实现方式视您的具体应用而定。 需要注意的是，由于 STM32 系列芯片的不同，具体的实现方式也有所不同。因此，您需要查看您所使用的芯片的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值