/************************************************************************************************** Filename: hal_key.c Revised: $Date: 2010-09-15 19:02:45 -0700 (Wed, 15 Sep 2010) $ Revision: $Revision: 23815 $ Description: This file contains the interface to the HAL KEY Service. Copyright 2006-2010 Texas Instruments Incorporated. All rights reserved. IMPORTANT: Your use of this Software is limited to those specific rights granted under the terms of a software license agreement between the user who downloaded the software, his/her employer (which must be your employer) and Texas Instruments Incorporated (the "License"). You may not use this Software unless you agree to abide by the terms of the License. The License limits your use, and you acknowledge, that the Software may not be modified, copied or distributed unless embedded on a Texas Instruments microcontroller or used solely and exclusively in conjunction with a Texas Instruments radio frequency transceiver, which is integrated into your product. Other than for the foregoing purpose, you may not use, reproduce, copy, prepare derivative works of, modify, distribute, perform, display or sell this Software and/or its documentation for any purpose. YOU FURTHER ACKNOWLEDGE AND AGREE THAT THE SOFTWARE AND DOCUMENTATION ARE PROVIDED “AS IS?WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF MERCHANTABILITY, TITLE, NON-INFRINGEMENT AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL TEXAS INSTRUMENTS OR ITS LICENSORS BE LIABLE OR OBLIGATED UNDER CONTRACT, NEGLIGENCE, STRICT LIABILITY, CONTRIBUTION, BREACH OF WARRANTY, OR OTHER LEGAL EQUITABLE THEORY ANY DIRECT OR INDIRECT DAMAGES OR EXPENSES INCLUDING BUT NOT LIMITED TO ANY INCIDENTAL, SPECIAL, INDIRECT, PUNITIVE OR CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF PROCUREMENT OF SUBSTITUTE GOODS, TECHNOLOGY, SERVICES, OR ANY CLAIMS BY THIRD PARTIES (INCLUDING BUT NOT LIMITED TO ANY DEFENSE THEREOF), OR OTHER SIMILAR COSTS. Should you have any questions regarding your right to use this Software, contact Texas Instruments Incorporated at www.TI.com. **************************************************************************************************/ /********************************************************************* NOTE: If polling is used, the hal_driver task schedules the KeyRead() to occur every 100ms. This should be long enough to naturally debounce the keys. The KeyRead() function remembers the key state of the previous poll and will only return a non-zero value if the key state changes. NOTE: If interrupts are used, the KeyRead() function is scheduled 25ms after the interrupt occurs by the ISR. This delay is used for key debouncing. The ISR disables any further Key interrupt until KeyRead() is executed. KeyRead() will re-enable Key interrupts after executing. Unlike polling, when interrupts are enabled, the previous key state is not remembered. This means that KeyRead() will return the current state of the keys (not a change in state of the keys). NOTE: If interrupts are used, the KeyRead() fucntion is scheduled by the ISR. Therefore, the joystick movements will only be detected during a pushbutton interrupt caused by S1 or the center joystick pushbutton. NOTE: When a switch like S1 is pushed, the S1 signal goes from a normally high state to a low state. This transition is typically clean. The duration of the low state is around 200ms. When the signal returns to the high state, there is a high likelihood of signal bounce, which causes a unwanted interrupts. Normally, we would set the interrupt edge to falling edge to generate an interrupt when S1 is pushed, but because of the signal bounce, it is better to set the edge to rising edge to generate an interrupt when S1 is released. The debounce logic can then filter out the signal bounce. The result is that we typically get only 1 interrupt per button push. This mechanism is not totally foolproof because occasionally, signal bound occurs during the falling edge as well. A similar mechanism is used to handle the joystick pushbutton on the DB. For the EB, we do not have independent control of the interrupt edge for the S1 and center joystick pushbutton. As a result, only one or the other pushbuttons work reasonably well with interrupts. The default is the make the S1 switch on the EB work more reliably. *********************************************************************/ /************************************************************************************************** * INCLUDES **************************************************************************************************/ #include "hal_mcu.h" #include "hal_defs.h" #include "hal_types.h" #include "hal_board.h" #include "hal_drivers.h" #include "hal_adc.h" #include "hal_key.h" #include "osal.h" //#include "SampleApp.h" #include "demoapp.h" #if (defined HAL_KEY) && (HAL_KEY == TRUE) /************************************************************************************************** * MACROS **************************************************************************************************/ /************************************************************************************************** * CONSTANTS **************************************************************************************************/ #define HAL_KEY_RISING_EDGE 0 #define HAL_KEY_FALLING_EDGE 1 #define HAL_KEY_DEBOUNCE_VALUE 25 /* CPU port interrupt */ #define HAL_KEY_CPU_PORT_0_IF P0IF #define HAL_KEY_CPU_PORT_2_IF P2IF /* SW_6 is at P0.1 */ #define HAL_KEY_SW_6_PORT P0 #define HAL_KEY_SW_6_BIT BV(1) #define HAL_KEY_SW_5_BIT BV(0) #define HAL_KEY_SW_6_SEL P0SEL #define HAL_KEY_SW_6_DIR P0DIR /* edge interrupt */ #define HAL_KEY_SW_6_EDGEBIT BV(0) #define HAL_KEY_SW_6_EDGE HAL_KEY_FALLING_EDGE /* SW_6 interrupts */ #define HAL_KEY_SW_6_IEN IEN1 /* CPU interrupt mask register */ #define HAL_KEY_SW_6_IENBIT BV(5) /* Mask bit for all of Port_0 */ #define HAL_KEY_SW_6_ICTL P0IEN /* Port Interrupt Control register */ #define HAL_KEY_SW_6_ICTLBIT BV(1) /* P0IEN - P0.1 enable/disable bit */ #define HAL_KEY_SW_5_ICTLBIT BV(0) /* P0IEN - P0.1 enable/disable bit */ #define HAL_KEY_SW_6_PXIFG P0IFG /* Interrupt flag at source */ /* Joy stick move at P2.0 */ #define HAL_KEY_JOY_MOVE_PORT P2 #define HAL_KEY_JOY_MOVE_BIT BV(0) #define HAL_KEY_JOY_MOVE_SEL P2SEL #define HAL_KEY_JOY_MOVE_DIR P2DIR /* edge interrupt */ #define HAL_KEY_JOY_MOVE_EDGEBIT BV(3) #define HAL_KEY_JOY_MOVE_EDGE HAL_KEY_FALLING_EDGE /* Joy move interrupts */ #define HAL_KEY_JOY_MOVE_IEN IEN2 /* CPU interrupt mask register */ #define HAL_KEY_JOY_MOVE_IENBIT BV(1) /* Mask bit for all of Port_2 */ #define HAL_KEY_JOY_MOVE_ICTL P2IEN /* Port Interrupt Control register */ #define HAL_KEY_JOY_MOVE_ICTLBIT BV(0) /* P2IENL - P2.0<->P2.3 enable/disable bit */ #define HAL_KEY_JOY_MOVE_PXIFG P2IFG /* Interrupt flag at source */ #define HAL_KEY_JOY_CHN HAL_ADC_CHANNEL_6 /************************************************************************************************** * TYPEDEFS **************************************************************************************************/ /************************************************************************************************** * GLOBAL VARIABLES **************************************************************************************************/ static uint8 halKeySavedKeys; /* used to store previous key state in polling mode */ static halKeyCBack_t pHalKeyProcessFunction; static uint8 HalKeyConfigured; bool Hal_KeyIntEnable; /* interrupt enable/disable flag */ /************************************************************************************************** * FUNCTIONS - Local **************************************************************************************************/ void halProcessKeyInterrupt(void); uint8 halGetJoyKeyInput(void); /************************************************************************************************** * FUNCTIONS - API **************************************************************************************************/ /************************************************************************************************** * @fn HalKeyInit * * @brief Initilize Key Service * * @param none * * @return None **************************************************************************************************/ void HalKeyInit( void ) { /* Initialize previous key to 0 */ halKeySavedKeys = 0; HAL_KEY_SW_6_SEL &= ~(HAL_KEY_SW_6_BIT); /* Set pin function to GPIO */ HAL_KEY_SW_6_DIR &= ~(HAL_KEY_SW_6_BIT); /* Set pin direction to Input */ HAL_KEY_SW_6_SEL &= ~(HAL_KEY_SW_5_BIT); /* Set pin function to GPIO */ HAL_KEY_SW_6_DIR &= ~(HAL_KEY_SW_5_BIT); /* Set pin direction to Input */ HAL_KEY_JOY_MOVE_SEL &= ~(HAL_KEY_JOY_MOVE_BIT); /* Set pin function to GPIO */ HAL_KEY_JOY_MOVE_DIR &= ~(HAL_KEY_JOY_MOVE_BIT); /* Set pin direction to Input */ /* Initialize callback function */ pHalKeyProcessFunction = NULL; /* Start with key is not configured */ HalKeyConfigured = FALSE; } /************************************************************************************************** * @fn HalKeyConfig * * @brief Configure the Key serivce * * @param interruptEnable - TRUE/FALSE, enable/disable interrupt * cback - pointer to the CallBack function * * @return None **************************************************************************************************/ void HalKeyConfig (bool interruptEnable, halKeyCBack_t cback) { /* Enable/Disable Interrupt or */ Hal_KeyIntEnable = interruptEnable; /* Register the callback fucntion */ pHalKeyProcessFunction = cback; /* Determine if interrupt is enable or not */ if (Hal_KeyIntEnable) { /* Rising/Falling edge configuratinn */ PICTL &= ~(HAL_KEY_SW_6_EDGEBIT); /* Clear the edge bit */ /* For falling edge, the bit must be set. */ #if (HAL_KEY_SW_6_EDGE == HAL_KEY_FALLING_EDGE) PICTL |= HAL_KEY_SW_6_EDGEBIT; #endif /* Interrupt configuration: * - Enable interrupt generation at the port * - Enable CPU interrupt * - Clear any pending interrupt */ HAL_KEY_SW_6_ICTL |= HAL_KEY_SW_6_ICTLBIT; HAL_KEY_SW_6_ICTL |= HAL_KEY_SW_5_ICTLBIT; HAL_KEY_SW_6_IEN |= HAL_KEY_SW_6_IENBIT; HAL_KEY_SW_6_PXIFG = ~(HAL_KEY_SW_6_BIT); HAL_KEY_SW_6_PXIFG = ~(HAL_KEY_SW_5_BIT); /* Rising/Falling edge configuratinn */ HAL_KEY_JOY_MOVE_ICTL &= ~(HAL_KEY_JOY_MOVE_EDGEBIT); /* Clear the edge bit */ /* For falling edge, the bit must be set. */ #if (HAL_KEY_JOY_MOVE_EDGE == HAL_KEY_FALLING_EDGE) HAL_KEY_JOY_MOVE_ICTL |= HAL_KEY_JOY_MOVE_EDGEBIT; #endif /* Interrupt configuration: * - Enable interrupt generation at the port * - Enable CPU interrupt * - Clear any pending interrupt */ HAL_KEY_JOY_MOVE_ICTL |= HAL_KEY_JOY_MOVE_ICTLBIT; HAL_KEY_JOY_MOVE_IEN |= HAL_KEY_JOY_MOVE_IENBIT; HAL_KEY_JOY_MOVE_PXIFG = ~(HAL_KEY_JOY_MOVE_BIT); /* Do this only after the hal_key is configured - to work with sleep stuff */ if (HalKeyConfigured == TRUE) { osal_stop_timerEx(Hal_TaskID, HAL_KEY_EVENT); /* Cancel polling if active */ } } else /* Interrupts NOT enabled */ { HAL_KEY_SW_6_ICTL &= ~(HAL_KEY_SW_6_ICTLBIT); /* don't generate interrupt */ HAL_KEY_SW_6_ICTL &= ~(HAL_KEY_SW_5_ICTLBIT); /* don't generate interrupt */ HAL_KEY_SW_6_IEN &= ~(HAL_KEY_SW_6_IENBIT); /* Clear interrupt enable bit */ osal_set_event(Hal_TaskID, HAL_KEY_EVENT); } /* Key now is configured */ HalKeyConfigured = TRUE; } /************************************************************************************************** * @fn HalKeyRead * * @brief Read the current value of a key * * @param None * * @return keys - current keys status **************************************************************************************************/ uint8 HalKeyRead ( void ) { uint8 keys = 0; if (HAL_PUSH_BUTTON1()) { keys |= HAL_KEY_SW_6; } if ((HAL_KEY_JOY_MOVE_PORT & HAL_KEY_JOY_MOVE_BIT)) /* Key is active low */ { keys |= halGetJoyKeyInput(); } return keys; } /************************************************************************************************** * @fn HalKeyPoll * * @brief Called by hal_driver to poll the keys * * @param None * * @return None **************************************************************************************************/ void HalKeyPoll (void) { uint8 keys = 0; if ((HAL_KEY_JOY_MOVE_PORT & HAL_KEY_JOY_MOVE_BIT)) /* Key is active HIGH */ { keys = halGetJoyKeyInput(); } /* If interrupts are not enabled, previous key status and current key status * are compared to find out if a key has changed status. */ if (!Hal_KeyIntEnable) { if (keys == halKeySavedKeys) { /* Exit - since no keys have changed */ return; } /* Store the current keys for comparation next time */ halKeySavedKeys = keys; } else { /* Key interrupt handled here */ } if (HAL_PUSH_BUTTON1()) { keys |= HAL_KEY_SW_6; } /* Invoke Callback if new keys were depressed */ if (keys && (pHalKeyProcessFunction)) { (pHalKeyProcessFunction) (keys, HAL_KEY_STATE_NORMAL); } } /************************************************************************************************** * @fn halGetJoyKeyInput * * @brief Map the ADC value to its corresponding key. * * @param None * * @return keys - current joy key status **************************************************************************************************/ uint8 halGetJoyKeyInput(void) { /* The joystick control is encoded as an analog voltage. * Read the JOY_LEVEL analog value and map it to joy movement. */ uint8 adc; uint8 ksave0 = 0; uint8 ksave1; /* Keep on reading the ADC until two consecutive key decisions are the same. */ do { ksave1 = ksave0; /* save previouse key reading */ adc = HalAdcRead (HAL_KEY_JOY_CHN, HAL_ADC_RESOLUTION_8); if ((adc >= 2) && (adc <= 38)) { ksave0 |= HAL_KEY_UP; } else if ((adc >= 74) && (adc <= 88)) { ksave0 |= HAL_KEY_RIGHT; } else if ((adc >= 60) && (adc <= 73)) { ksave0 |= HAL_KEY_LEFT; } else if ((adc >= 39) && (adc <= 59)) { ksave0 |= HAL_KEY_DOWN; } else if ((adc >= 89) && (adc <= 100)) { ksave0 |= HAL_KEY_CENTER; } } while (ksave0 != ksave1); return ksave0; } /************************************************************************************************** * @fn halProcessKeyInterrupt * * @brief Checks to see if it's a valid key interrupt, saves interrupt driven key states for * processing by HalKeyRead(), and debounces keys by scheduling HalKeyRead() 25ms later. * * @param * * @return **************************************************************************************************/ void halProcessKeyInterrupt (void) { bool valid=FALSE; if (HAL_KEY_SW_6_PXIFG & HAL_KEY_SW_6_BIT) /* Interrupt Flag has been set */ { HAL_KEY_SW_6_PXIFG = ~(HAL_KEY_SW_6_BIT); /* Clear Interrupt Flag */ valid = TRUE; } if (HAL_KEY_SW_6_PXIFG & HAL_KEY_SW_5_BIT) /* Interrupt Flag has been set */ { HAL_KEY_SW_6_PXIFG = ~(HAL_KEY_SW_5_BIT); /* Clear Interrupt Flag */ valid = TRUE; } if (HAL_KEY_JOY_MOVE_PXIFG & HAL_KEY_JOY_MOVE_BIT) /* Interrupt Flag has been set */ { HAL_KEY_JOY_MOVE_PXIFG = ~(HAL_KEY_JOY_MOVE_BIT); /* Clear Interrupt Flag */ valid = TRUE; } if (valid) { osal_start_timerEx (Hal_TaskID, HAL_KEY_EVENT, HAL_KEY_DEBOUNCE_VALUE); } } /************************************************************************************************** * @fn HalKeyEnterSleep * * @brief - Get called to enter sleep mode * * @param * * @return **************************************************************************************************/ void HalKeyEnterSleep ( void ) { } /************************************************************************************************** * @fn HalKeyExitSleep * * @brief - Get called when sleep is over * * @param * * @return - return saved keys **************************************************************************************************/ uint8 HalKeyExitSleep ( void ) { /* Wake up and read keys */ return ( HalKeyRead () ); } /*************************************************************************************************** * INTERRUPT SERVICE ROUTINE ***************************************************************************************************/ /************************************************************************************************** * @fn halKeyPort0Isr * * @brief Port0 ISR * * @param * * @return **************************************************************************************************/ HAL_ISR_FUNCTION( halKeyPort0Isr, P0INT_VECTOR ) { HAL_ENTER_ISR(); if (HAL_KEY_SW_6_PXIFG & HAL_KEY_SW_6_BIT) { //halProcessKeyInterrupt(); osal_set_event(my_TaskID,DEMO_KEYBOARD_2); } if (HAL_KEY_SW_6_PXIFG & HAL_KEY_SW_5_BIT) { //halProcessKeyInterrupt(); osal_set_event(my_TaskID,DEMO_KEYBOARD_1); } /* Clear the CPU interrupt flag for Port_0 PxIFG has to be cleared before PxIF */ HAL_KEY_SW_6_PXIFG = 0; HAL_KEY_CPU_PORT_0_IF = 0; CLEAR_SLEEP_MODE(); HAL_EXIT_ISR(); } /************************************************************************************************** * @fn halKeyPort2Isr * * @brief Port2 ISR * * @param * * @return **************************************************************************************************/ HAL_ISR_FUNCTION( halKeyPort2Isr, P2INT_VECTOR ) { HAL_ENTER_ISR(); if (HAL_KEY_JOY_MOVE_PXIFG & HAL_KEY_JOY_MOVE_BIT) { halProcessKeyInterrupt(); } /* Clear the CPU interrupt flag for Port_2 PxIFG has to be cleared before PxIF Notes: P2_1 and P2_2 are debug lines. */ HAL_KEY_JOY_MOVE_PXIFG = 0; HAL_KEY_CPU_PORT_2_IF = 0; CLEAR_SLEEP_MODE(); HAL_EXIT_ISR(); } #else void HalKeyInit(void){} void HalKeyConfig(bool interruptEnable, halKeyCBack_t cback){} uint8 HalKeyRead(void){ return 0;} void HalKeyPoll(void){} #endif /* HAL_KEY */ /************************************************************************************************** **************************************************************************************************/