294 lines
9.1 KiB
C++
294 lines
9.1 KiB
C++
/*
|
|
||
|
|
|| @file Keypad.cpp
|
|
|| @version 3.1
|
|
|| @author Mark Stanley, Alexander Brevig
|
|
|| @contact mstanley@technologist.com, alexanderbrevig@gmail.com
|
|
||
|
|
|| @description
|
|
|| | This library provides a simple interface for using matrix
|
|
|| | keypads. It supports multiple keypresses while maintaining
|
|
|| | backwards compatibility with the old single key library.
|
|
|| | It also supports user selectable pins and definable keymaps.
|
|
|| #
|
|
||
|
|
|| @license
|
|
|| | This library is free software; you can redistribute it and/or
|
|
|| | modify it under the terms of the GNU Lesser General Public
|
|
|| | License as published by the Free Software Foundation; version
|
|
|| | 2.1 of the License.
|
|
|| |
|
|
|| | This library is distributed in the hope that it will be useful,
|
|
|| | but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|| | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|| | Lesser General Public License for more details.
|
|
|| |
|
|
|| | You should have received a copy of the GNU Lesser General Public
|
|
|| | License along with this library; if not, write to the Free Software
|
|
|| | Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
|| #
|
|
||
|
|
*/
|
|
#include <Keypad.h>
|
|
|
|
// <<constructor>> Allows custom keymap, pin configuration, and keypad sizes.
|
|
Keypad::Keypad(char *userKeymap, byte *row, byte *col, byte numRows, byte numCols) {
|
|
rowPins = row;
|
|
columnPins = col;
|
|
sizeKpd.rows = numRows;
|
|
sizeKpd.columns = numCols;
|
|
|
|
begin(userKeymap);
|
|
|
|
setDebounceTime(10);
|
|
setHoldTime(500);
|
|
keypadEventListener = 0;
|
|
|
|
startTime = 0;
|
|
single_key = false;
|
|
}
|
|
|
|
// Let the user define a keymap - assume the same row/column count as defined in constructor
|
|
void Keypad::begin(char *userKeymap) {
|
|
keymap = userKeymap;
|
|
}
|
|
|
|
// Returns a single key only. Retained for backwards compatibility.
|
|
char Keypad::getKey() {
|
|
single_key = true;
|
|
|
|
if (getKeys() && key[0].stateChanged && (key[0].kstate==PRESSED))
|
|
return key[0].kchar;
|
|
|
|
single_key = false;
|
|
|
|
return NO_KEY;
|
|
}
|
|
|
|
// Populate the key list.
|
|
bool Keypad::getKeys() {
|
|
bool keyActivity = false;
|
|
|
|
// Limit how often the keypad is scanned. This makes the loop() run 10 times as fast.
|
|
if ( (millis()-startTime)>debounceTime ) {
|
|
scanKeys();
|
|
keyActivity = updateList();
|
|
startTime = millis();
|
|
}
|
|
|
|
return keyActivity;
|
|
}
|
|
|
|
// Private : Hardware scan
|
|
void Keypad::scanKeys() {
|
|
// Re-intialize the row pins. Allows sharing these pins with other hardware.
|
|
for (byte r=0; r<sizeKpd.rows; r++) {
|
|
pin_mode(rowPins[r],INPUT_PULLUP);
|
|
}
|
|
|
|
// bitMap stores ALL the keys that are being pressed.
|
|
for (byte c=0; c<sizeKpd.columns; c++) {
|
|
pin_mode(columnPins[c],OUTPUT);
|
|
pin_write(columnPins[c], LOW); // Begin column pulse output.
|
|
for (byte r=0; r<sizeKpd.rows; r++) {
|
|
bitWrite(bitMap[r], c, !pin_read(rowPins[r])); // keypress is active low so invert to high.
|
|
}
|
|
// Set pin to high impedance input. Effectively ends column pulse.
|
|
pin_write(columnPins[c],HIGH);
|
|
pin_mode(columnPins[c],INPUT);
|
|
}
|
|
}
|
|
|
|
// Manage the list without rearranging the keys. Returns true if any keys on the list changed state.
|
|
bool Keypad::updateList() {
|
|
|
|
bool anyActivity = false;
|
|
|
|
// Delete any IDLE keys
|
|
for (byte i=0; i<LIST_MAX; i++) {
|
|
if (key[i].kstate==IDLE) {
|
|
key[i].kchar = NO_KEY;
|
|
key[i].kcode = -1;
|
|
key[i].stateChanged = false;
|
|
}
|
|
}
|
|
|
|
// Add new keys to empty slots in the key list.
|
|
for (byte r=0; r<sizeKpd.rows; r++) {
|
|
for (byte c=0; c<sizeKpd.columns; c++) {
|
|
boolean button = bitRead(bitMap[r],c);
|
|
char keyChar = keymap[r * sizeKpd.columns + c];
|
|
int keyCode = r * sizeKpd.columns + c;
|
|
int idx = findInList (keyCode);
|
|
// Key is already on the list so set its next state.
|
|
if (idx > -1) {
|
|
nextKeyState(idx, button);
|
|
}
|
|
// Key is NOT on the list so add it.
|
|
if ((idx == -1) && button) {
|
|
for (byte i=0; i<LIST_MAX; i++) {
|
|
if (key[i].kchar==NO_KEY) { // Find an empty slot or don't add key to list.
|
|
key[i].kchar = keyChar;
|
|
key[i].kcode = keyCode;
|
|
key[i].kstate = IDLE; // Keys NOT on the list have an initial state of IDLE.
|
|
nextKeyState (i, button);
|
|
break; // Don't fill all the empty slots with the same key.
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Report if the user changed the state of any key.
|
|
for (byte i=0; i<LIST_MAX; i++) {
|
|
if (key[i].stateChanged) anyActivity = true;
|
|
}
|
|
|
|
return anyActivity;
|
|
}
|
|
|
|
// Private
|
|
// This function is a state machine but is also used for debouncing the keys.
|
|
void Keypad::nextKeyState(byte idx, boolean button) {
|
|
key[idx].stateChanged = false;
|
|
|
|
switch (key[idx].kstate) {
|
|
case IDLE:
|
|
if (button==CLOSED) {
|
|
transitionTo (idx, PRESSED);
|
|
holdTimer = millis(); } // Get ready for next HOLD state.
|
|
break;
|
|
case PRESSED:
|
|
if ((millis()-holdTimer)>holdTime) // Waiting for a key HOLD...
|
|
transitionTo (idx, HOLD);
|
|
else if (button==OPEN) // or for a key to be RELEASED.
|
|
transitionTo (idx, RELEASED);
|
|
break;
|
|
case HOLD:
|
|
if (button==OPEN)
|
|
transitionTo (idx, RELEASED);
|
|
break;
|
|
case RELEASED:
|
|
transitionTo (idx, IDLE);
|
|
break;
|
|
}
|
|
}
|
|
|
|
// New in 2.1
|
|
bool Keypad::isPressed(char keyChar) {
|
|
for (byte i=0; i<LIST_MAX; i++) {
|
|
if ( key[i].kchar == keyChar ) {
|
|
if ( (key[i].kstate == PRESSED) && key[i].stateChanged )
|
|
return true;
|
|
}
|
|
}
|
|
return false; // Not pressed.
|
|
}
|
|
|
|
// Search by character for a key in the list of active keys.
|
|
// Returns -1 if not found or the index into the list of active keys.
|
|
int Keypad::findInList (char keyChar) {
|
|
for (byte i=0; i<LIST_MAX; i++) {
|
|
if (key[i].kchar == keyChar) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
// Search by code for a key in the list of active keys.
|
|
// Returns -1 if not found or the index into the list of active keys.
|
|
int Keypad::findInList (int keyCode) {
|
|
for (byte i=0; i<LIST_MAX; i++) {
|
|
if (key[i].kcode == keyCode) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
// New in 2.0
|
|
char Keypad::waitForKey() {
|
|
char waitKey = NO_KEY;
|
|
while( (waitKey = getKey()) == NO_KEY ); // Block everything while waiting for a keypress.
|
|
return waitKey;
|
|
}
|
|
|
|
// Backwards compatibility function.
|
|
KeyState Keypad::getState() {
|
|
return key[0].kstate;
|
|
}
|
|
|
|
// The end user can test for any changes in state before deciding
|
|
// if any variables, etc. needs to be updated in their code.
|
|
bool Keypad::keyStateChanged() {
|
|
return key[0].stateChanged;
|
|
}
|
|
|
|
// The number of keys on the key list, key[LIST_MAX], equals the number
|
|
// of bytes in the key list divided by the number of bytes in a Key object.
|
|
byte Keypad::numKeys() {
|
|
return sizeof(key)/sizeof(Key);
|
|
}
|
|
|
|
// Minimum debounceTime is 1 mS. Any lower *will* slow down the loop().
|
|
void Keypad::setDebounceTime(uint debounce) {
|
|
debounce<1 ? debounceTime=1 : debounceTime=debounce;
|
|
}
|
|
|
|
void Keypad::setHoldTime(uint hold) {
|
|
holdTime = hold;
|
|
}
|
|
|
|
void Keypad::addEventListener(void (*listener)(char)){
|
|
keypadEventListener = listener;
|
|
}
|
|
|
|
void Keypad::transitionTo(byte idx, KeyState nextState) {
|
|
key[idx].kstate = nextState;
|
|
key[idx].stateChanged = true;
|
|
|
|
// Sketch used the getKey() function.
|
|
// Calls keypadEventListener only when the first key in slot 0 changes state.
|
|
if (single_key) {
|
|
if ( (keypadEventListener!=NULL) && (idx==0) ) {
|
|
keypadEventListener(key[0].kchar);
|
|
}
|
|
}
|
|
// Sketch used the getKeys() function.
|
|
// Calls keypadEventListener on any key that changes state.
|
|
else {
|
|
if (keypadEventListener!=NULL) {
|
|
keypadEventListener(key[idx].kchar);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
|| @changelog
|
|
|| | 3.1 2013-01-15 - Mark Stanley : Fixed missing RELEASED & IDLE status when using a single key.
|
|
|| | 3.0 2012-07-12 - Mark Stanley : Made library multi-keypress by default. (Backwards compatible)
|
|
|| | 3.0 2012-07-12 - Mark Stanley : Modified pin functions to support Keypad_I2C
|
|
|| | 3.0 2012-07-12 - Stanley & Young : Removed static variables. Fix for multiple keypad objects.
|
|
|| | 3.0 2012-07-12 - Mark Stanley : Fixed bug that caused shorted pins when pressing multiple keys.
|
|
|| | 2.0 2011-12-29 - Mark Stanley : Added waitForKey().
|
|
|| | 2.0 2011-12-23 - Mark Stanley : Added the public function keyStateChanged().
|
|
|| | 2.0 2011-12-23 - Mark Stanley : Added the private function scanKeys().
|
|
|| | 2.0 2011-12-23 - Mark Stanley : Moved the Finite State Machine into the function getKeyState().
|
|
|| | 2.0 2011-12-23 - Mark Stanley : Removed the member variable lastUdate. Not needed after rewrite.
|
|
|| | 1.8 2011-11-21 - Mark Stanley : Added decision logic to compile WProgram.h or Arduino.h
|
|
|| | 1.8 2009-07-08 - Alexander Brevig : No longer uses arrays
|
|
|| | 1.7 2009-06-18 - Alexander Brevig : Every time a state changes the keypadEventListener will trigger, if set.
|
|
|| | 1.7 2009-06-18 - Alexander Brevig : Added setDebounceTime. setHoldTime specifies the amount of
|
|
|| | microseconds before a HOLD state triggers
|
|
|| | 1.7 2009-06-18 - Alexander Brevig : Added transitionTo
|
|
|| | 1.6 2009-06-15 - Alexander Brevig : Added getState() and state variable
|
|
|| | 1.5 2009-05-19 - Alexander Brevig : Added setHoldTime()
|
|
|| | 1.4 2009-05-15 - Alexander Brevig : Added addEventListener
|
|
|| | 1.3 2009-05-12 - Alexander Brevig : Added lastUdate, in order to do simple debouncing
|
|
|| | 1.2 2009-05-09 - Alexander Brevig : Changed getKey()
|
|
|| | 1.1 2009-04-28 - Alexander Brevig : Modified API, and made variables private
|
|
|| | 1.0 2007-XX-XX - Mark Stanley : Initial Release
|
|
|| #
|
|
*/
|