#!/usr/bin/env python3

import RPi.GPIO as GPIO 
import time
#class Key:Define some of the properties of Key
class Key(object):
	NO_KEY = '\0'
	#Defines the four states of Key
	IDLE = 0
	PRESSED = 1
	HOLD = 2
	RELEASED = 3
	#define OPEN and CLOSED
	OPEN = 0
	CLOSED =1
	#constructor
	def __init__(self):
		self.kchar = self.NO_KEY
		self.kstate = self.IDLE
		self.kcode = -1
		self.stateChanged = False

class Keypad(object):
	NULL = '\0'
	LIST_MAX = 10	#Max number of keys on the active list.
	MAPSIZE = 10	#MAPSIZE is the number of rows (times 16 columns)
	bitMap = [0]*MAPSIZE
	key = [Key()]*LIST_MAX
	holdTime = 500		#key hold time
	holdTimer = 0
	startTime = 0
	#Allows custom keymap, pin configuration, and keypad sizes.
	def __init__(self,usrKeyMap,row_Pins,col_Pins,num_Rows,num_Cols):
		GPIO.setmode(GPIO.BOARD)
		self.rowPins = row_Pins
		self.colPins = col_Pins
		self.numRows = num_Rows
		self.numCols = num_Cols
		
		self.keymap = usrKeyMap
		self.setDebounceTime(10)
	#Returns a single key only. Retained for backwards compatibility.	
	def getKey(self):
		single_key = True
		if(self.getKeys() and self.key[0].stateChanged and (self.key[0].kstate == self.key[0].PRESSED)):
			return self.key[0].kchar
		single_key = False
		return self.key[0].NO_KEY
	#Populate the key list.	
	def getKeys(self):
		keyActivity = False
		#Limit how often the keypad is scanned.
		if((time.time() - self.startTime) > self.debounceTime*0.001):
			self.scanKeys()
			keyActivity = self.updateList()
			self.startTime = time.time()
		return keyActivity
	#Hardware scan ,the result store in bitMap	
	def scanKeys(self):
		#Re-intialize the row pins. Allows sharing these pins with other hardware.
		for pin_r in self.rowPins:
			GPIO.setup(pin_r,GPIO.IN,pull_up_down = GPIO.PUD_UP)
		#bitMap stores ALL the keys that are being pressed.
		for pin_c in self.colPins:
			GPIO.setup(pin_c,GPIO.OUT)
			GPIO.output(pin_c,GPIO.LOW)
			for r in self.rowPins: #keypress is active low so invert to high.
				self.bitMap[self.rowPins.index(r)] = self.bitWrite(self.bitMap[self.rowPins.index(r)],self.colPins.index(pin_c),not GPIO.input(r))
			#Set pin to high impedance input. Effectively ends column pulse.
			GPIO.output(pin_c,GPIO.HIGH)
			GPIO.setup(pin_c,GPIO.IN)
	#Manage the list without rearranging the keys. Returns true if any keys on the list changed state.		
	def updateList(self):
		anyActivity = False
		kk = Key()
		#Delete any IDLE keys
		for i in range(self.LIST_MAX):
			if(self.key[i].kstate == kk.IDLE):
				self.key[i].kchar = kk.NO_KEY
				self.key[i].kcode = -1
				self.key[i].stateChanged = False
		# Add new keys to empty slots in the key list.
		for r in range(self.numRows):
			for c in range(self.numCols):
				button = self.bitRead(self.bitMap[r],c)
				keyChar = self.keymap[r * self.numCols +c]
				keyCode = r * self.numCols +c
				idx = self.findInList(keyCode)
				#Key is already on the list so set its next state.
				if(idx > -1):
					self.nextKeyState(idx,button)
				#Key is NOT on the list so add it.
				if((idx == -1) and button):
					for i in range(self.LIST_MAX):
						if(self.key[i].kchar == kk.NO_KEY):	#Find an empty slot or don't add key to list.
							self.key[i].kchar = keyChar
							self.key[i].kcode = keyCode
							self.key[i].kstate = kk.IDLE	#Keys NOT on the list have an initial state of IDLE.
							self.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 i in range(self.LIST_MAX):
			if(self.key[i].stateChanged):
				anyActivity = True
		return anyActivity		
	#This function is a state machine but is also used for debouncing the keys.	
	def nextKeyState(self,idx, button):
		self.key[idx].stateChanged = False
		kk = Key()
		if(self.key[idx].kstate == kk.IDLE):
			if(button == kk.CLOSED):
				self.transitionTo(idx,kk.PRESSED)
				self.holdTimer = time.time()	#Get ready for next HOLD state.
		elif(self.key[idx].kstate == kk.PRESSED):
			if((time.time() - self.holdTimer) > self.holdTime*0.001):	#Waiting for a key HOLD...	
				self.transitionTo(idx,kk.HOLD)
			elif(button == kk.OPEN):		# or for a key to be RELEASED.
				self.transitionTo(idx,kk.RELEASED)
		elif(self.key[idx].kstate == kk.HOLD):
			if(button == kk.OPEN):
				self.transitionTo(idx,kk.RELEASED)
		elif(self.key[idx].kstate == kk.RELEASED):
			self.transitionTo(idx,kk.IDLE)
			
	def transitionTo(self,idx,nextState):
		self.key[idx].kstate = nextState
		self.key[idx].stateChanged = True
	#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.
	def findInList(self,keyCode):
		for i in range(self.LIST_MAX):
			if(self.key[i].kcode == keyCode):
				return i
		return -1
	#set Debounce Time,	The default is 50ms					
	def setDebounceTime(self,ms):
		self.debounceTime = ms
	#set HoldTime,The default is 500ms
	def setHoldTime(self,ms):
		self.holdTime = ms
	#	
	def isPressed(keyChar):
		for i in range(self.LIST_MAX):
			if(self.key[i].kchar == keyChar):
				if(self.key[i].kstate == self.self.key[i].PRESSED and self.key[i].stateChanged):
					return True
		return False
	#			
	def waitForKey():
		kk = Key()
		waitKey = kk.NO_KEY
		while(waitKey == kk.NO_KEY):
			waitKey = getKey()
		return waitKey
	
	def getState():
		return self.key[0].kstate
	#	
	def keyStateChanged():
		return self.key[0].stateChanged
	
	def bitWrite(self,x,n,b):
		if(b):
			x |= (1<<n)
		else:
			x &=(~(1<<n))
		return x
	def bitRead(self,x,n):
		if((x>>n)&1 == 1):
			return True
		else:
			return False

ROWS = 4
COLS = 4
keys = 	[	'1','2','3','A',
			'4','5','6','B',
			'7','8','9','C',
			'*','0','#','D'		]
rowsPins = [12,16,18,22]
colsPins = [19,15,13,11]	

def loop():
	keypad = Keypad(keys,rowsPins,colsPins,ROWS,COLS)
	keypad.setDebounceTime(50)
	while(True):
		key = keypad.getKey()
		if(key != keypad.NULL):
			print ("You Pressed Key : %c "%(key) )
			
if __name__ == '__main__':     # Program start from here
	print ("Program is starting ... ")
	try:
		loop()
	except KeyboardInterrupt:  # When 'Ctrl+C' is pressed, the child program destroy() will be  executed.
		pass
		GPIO.cleanup()