keypad.cpp

00001 #include "mbed.h"
00002 #include "keypad.h"
00003 
00004 GPIO_InitTypeDef keypadInit;
00005 volatile uint32_t Index = 0xFF;
00006 volatile uint32_t new_key = 0;
00007 
00008 
00009 void EXTI9_5_IRQHandler(void) {
00010     HAL_NVIC_DisableIRQ(EXTI9_5_IRQn);
00011     if (__HAL_GPIO_EXTI_GET_IT(GPIO_PIN_5) != 0) {
00012         __HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_5);
00013         HAL_GPIO_EXTI_Callback(0);
00014     } else if (__HAL_GPIO_EXTI_GET_IT(GPIO_PIN_6) != 0) {
00015         __HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_6);
00016         HAL_GPIO_EXTI_Callback(1);
00017     } else if (__HAL_GPIO_EXTI_GET_IT(GPIO_PIN_7) != 0) {
00018         __HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_7);
00019         HAL_GPIO_EXTI_Callback(4);
00020     } else if (__HAL_GPIO_EXTI_GET_IT(GPIO_PIN_8) != 0) {
00021         __HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_8);
00022         HAL_GPIO_EXTI_Callback(2);
00023     } else if (__HAL_GPIO_EXTI_GET_IT(GPIO_PIN_9) != 0) {
00024         __HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_9);
00025         HAL_GPIO_EXTI_Callback(3);
00026     }
00027     HAL_GPIO_WritePin(GPIOC, cols[0] | cols[1] | cols[2], GPIO_PIN_RESET);  // All cols are driven Low for resume IRQ operation
00028     HAL_NVIC_ClearPendingIRQ(EXTI9_5_IRQn);
00029 }
00030 
00031 void HAL_GPIO_EXTI_Callback(uint16_t pin) {
00032     int col;
00033     int temp;
00034 
00035     keypadInit.Pin = rows[0] | rows[1] | rows[2] | rows[3];
00036     keypadInit.Mode = GPIO_MODE_INPUT;
00037     keypadInit.Pull = GPIO_PULLUP;
00038     HAL_GPIO_Init(GPIOC, &keypadInit);
00039     for (col = 0; col < ncols; col++) {
00040         HAL_GPIO_WritePin(GPIOC, cols[0] | cols[1] | cols[2], GPIO_PIN_SET);  // All cols are driven High
00041         HAL_GPIO_WritePin(GPIOC, cols[col], GPIO_PIN_RESET);                  // 1 col is driven Low
00042         wait_ms(25);
00043         temp = (GPIOC->IDR & 0x0360);
00044         switch (temp) {
00045             case 0x0340: Index = col;
00046                          break;
00047             case 0x0320: Index = 4 + col;
00048                          break;
00049             case 0x0260: Index = 8 + col;
00050                          break;
00051             case 0x0160: Index = 12 + col;
00052                          break;
00053             default:     Index = 0xFF;
00054                          break;
00055         }
00056         if (Index != 0xFF) {
00057             break;
00058         }
00059     }
00060     // Wait for the release of the key
00061     while ((GPIOC->IDR & 0x0360) != 0x0360) {}
00062     new_key++;
00063 }
00064 
00065 void Init_keypad(void) {
00066     __GPIOC_CLK_ENABLE();
00067     keypadInit.Pin = cols[0] | cols[1] | cols[2];
00068     keypadInit.Mode = GPIO_MODE_OUTPUT_OD;
00069     keypadInit.Pull = GPIO_NOPULL;
00070     keypadInit.Speed = GPIO_SPEED_MEDIUM;
00071     HAL_GPIO_Init(GPIOC, &keypadInit);
00072 
00073     HAL_GPIO_WritePin(GPIOC, cols[0] | cols[1] | cols[2], GPIO_PIN_SET);
00074     HAL_GPIO_WritePin(GPIOC, cols[2], GPIO_PIN_RESET);
00075 
00076     keypadInit.Pin = rows[0] | rows[1] | rows[2] | rows[3];
00077     keypadInit.Mode = GPIO_MODE_INPUT;
00078     keypadInit.Pull = GPIO_PULLUP;
00079     HAL_GPIO_Init(GPIOC, &keypadInit);
00080     keypadInit.Pin = rows[3];
00081     keypadInit.Mode = GPIO_MODE_IT_FALLING;
00082     keypadInit.Pull = GPIO_PULLUP;
00083     HAL_GPIO_Init(GPIOC, &keypadInit);
00084     NVIC_SetVector(EXTI9_5_IRQn, (uint32_t)EXTI9_5_IRQHandler);
00085     HAL_NVIC_EnableIRQ(EXTI9_5_IRQn);
00086 }
00087 
00088 int Poll_keypad_vert(void) {
00089     int temp;
00090     int retval = 0xFF;
00091 
00092     keypadInit.Pin = rows[0] | rows[1] | rows[2] | rows[3];
00093     keypadInit.Mode = GPIO_MODE_INPUT;
00094     keypadInit.Pull = GPIO_PULLUP;
00095     HAL_GPIO_Init(GPIOC, &keypadInit);
00096     //Poll the keys
00097     while (retval == 0xFF) {
00098         HAL_GPIO_WritePin(GPIOC, cols[0] | cols[1] | cols[2], GPIO_PIN_SET);
00099         HAL_GPIO_WritePin(GPIOC, cols[1], GPIO_PIN_RESET);
00100         wait_ms(25);
00101         temp = (GPIOC->IDR & 0x0360);
00102         switch (temp) {
00103             case 0x0340: retval = 0x01;
00104                          break;
00105             case 0x0320: retval = 0x05;
00106                          break;
00107             case 0x0260: retval = 0x09;
00108                          break;
00109             case 0x0160: retval = 0x0D;
00110                          break;
00111             default:     retval = 0xFF;
00112                          break;
00113         }
00114         HAL_GPIO_WritePin(GPIOC, cols[0] | cols[1] | cols[2], GPIO_PIN_SET);
00115         HAL_GPIO_WritePin(GPIOC, cols[2], GPIO_PIN_RESET);
00116         wait_ms(25);
00117         temp = (GPIOC->IDR & 0x0360);
00118         if (temp == 0x0160) {retval = 0x0E;}
00119     }
00120     // Wait for the release of the key
00121     HAL_GPIO_WritePin(GPIOC, cols[0] | cols[1] | cols[2], GPIO_PIN_SET);
00122     if (retval < 0x0E) {
00123         HAL_GPIO_WritePin(GPIOC, cols[1], GPIO_PIN_RESET);
00124     } else {
00125         HAL_GPIO_WritePin(GPIOC, cols[2], GPIO_PIN_RESET);
00126     }
00127     while ((GPIOC->IDR & 0x0360) != 0x0360) {}
00128     return retval;
00129 }
00130 
00131 int Poll_keypad_yesno(void) {
00132     int retval = 0xFF;
00133 
00134     keypadInit.Pin = rows[0] | rows[1] | rows[2] | rows[3];
00135     keypadInit.Mode = GPIO_MODE_INPUT;
00136     keypadInit.Pull = GPIO_PULLUP;
00137     HAL_GPIO_Init(GPIOC, &keypadInit);
00138 
00139     while (retval == 0xFF) {
00140         HAL_GPIO_WritePin(GPIOC, cols[0] | cols[1] | cols[2], GPIO_PIN_SET);
00141         HAL_GPIO_WritePin(GPIOC, cols[0], GPIO_PIN_RESET);
00142         wait_ms(25);
00143         if ((GPIOC->IDR & 0x0200) == 0x0000) retval = 0x0C;
00144         HAL_GPIO_WritePin(GPIOC, cols[0] | cols[1] | cols[2], GPIO_PIN_SET);
00145         HAL_GPIO_WritePin(GPIOC, cols[2], GPIO_PIN_RESET);
00146         wait_ms(25);
00147         if ((GPIOC->IDR & 0x0200) == 0x0000) retval = 0x0E;
00148     }
00149     // Wait for the release of the key
00150     HAL_GPIO_WritePin(GPIOC, cols[0] | cols[1] | cols[2], GPIO_PIN_SET);
00151     if (retval == 0x0C) {
00152         HAL_GPIO_WritePin(GPIOC, cols[0], GPIO_PIN_RESET);
00153     } else {
00154         HAL_GPIO_WritePin(GPIOC, cols[2], GPIO_PIN_RESET);
00155     }
00156     while ((GPIOC->IDR & 0x0360) != 0x0360) {}
00157     return retval;
00158 }
00159 
00160 int Poll_keypad_full(void) {
00161     int col, temp;
00162     int retval = 0xFF;
00163 
00164     keypadInit.Pin = rows[0] | rows[1] | rows[2] | rows[3];
00165     keypadInit.Mode = GPIO_MODE_INPUT;
00166     keypadInit.Pull = GPIO_PULLUP;
00167     HAL_GPIO_Init(GPIOC, &keypadInit);
00168     //Poll the keys
00169     while (retval == 0xFF) {
00170         for (col = 0; col < ncols; col++) {
00171             HAL_GPIO_WritePin(GPIOC, cols[0] | cols[1] | cols[2], GPIO_PIN_SET);  // All cols are driven High
00172             HAL_GPIO_WritePin(GPIOC, cols[col], GPIO_PIN_RESET);                  // 1 col is driven Low
00173             wait_ms(25);
00174             temp = (GPIOC->IDR & 0x0360);
00175             switch (temp) {
00176                 case 0x0340: retval = col;
00177                              break;
00178                 case 0x0320: retval = 4 + col;
00179                              break;
00180                 case 0x0260: retval = 8 + col;
00181                              break;
00182                 case 0x0160: retval = 12 + col;
00183                              break;
00184                 default:     retval = 0xFF;
00185                              break;
00186             }
00187             if (retval != 0xFF) {
00188                 break;
00189             }
00190         }
00191     }
00192     // Wait for the release of the key
00193     while ((GPIOC->IDR & 0x0360) != 0x0360) {}
00194     return Keytable[retval];
00195 }