gesture_sensor.py

from machine import I2C
import time

PAJ7620_ADDR_BASE				=0x00

#  REGISTER BANK SELECT
PAJ7620_REGITER_BANK_SEL		= (PAJ7620_ADDR_BASE + 0xEF)	# W

def PAJ7620_VAL(val,maskbit):
    return ( val << maskbit )

#  DEVICE ID
PAJ7620_ID  = 0x73

#  REGISTER BANK 0
PAJ7620_ADDR_SUSPEND_CMD		= (PAJ7620_ADDR_BASE + 0x3)	# W
PAJ7620_ADDR_GES_PS_DET_MASK_0		= (PAJ7620_ADDR_BASE + 0x41)	# RW
PAJ7620_ADDR_GES_PS_DET_MASK_1		= (PAJ7620_ADDR_BASE + 0x42)	# RW
PAJ7620_ADDR_GES_PS_DET_FLAG_0		= (PAJ7620_ADDR_BASE + 0x43)	# R
PAJ7620_ADDR_GES_PS_DET_FLAG_1		= (PAJ7620_ADDR_BASE + 0x44)	# R
PAJ7620_ADDR_STATE_INDICATOR	= (PAJ7620_ADDR_BASE + 0x45)	# R
PAJ7620_ADDR_PS_HIGH_THRESHOLD	= (PAJ7620_ADDR_BASE + 0x69)	# RW
PAJ7620_ADDR_PS_LOW_THRESHOLD	= (PAJ7620_ADDR_BASE + 0x6A)	# RW
PAJ7620_ADDR_PS_APPROACH_STATE	= (PAJ7620_ADDR_BASE + 0x6B)	# R
PAJ7620_ADDR_PS_RAW_DATA		= (PAJ7620_ADDR_BASE + 0x6C)	# R

#  REGISTER BANK 1
PAJ7620_ADDR_PS_GAIN			= (PAJ7620_ADDR_BASE + 0x44)	# RW
PAJ7620_ADDR_IDLE_S1_STEP_0		= (PAJ7620_ADDR_BASE + 0x67)	# RW
PAJ7620_ADDR_IDLE_S1_STEP_1		= (PAJ7620_ADDR_BASE + 0x68)	# RW
PAJ7620_ADDR_IDLE_S2_STEP_0		= (PAJ7620_ADDR_BASE + 0x69)	# RW
PAJ7620_ADDR_IDLE_S2_STEP_1		= (PAJ7620_ADDR_BASE + 0x6A)	# RW
PAJ7620_ADDR_OP_TO_S1_STEP_0	= (PAJ7620_ADDR_BASE + 0x6B)	# RW
PAJ7620_ADDR_OP_TO_S1_STEP_1	= (PAJ7620_ADDR_BASE + 0x6C)	# RW
PAJ7620_ADDR_OP_TO_S2_STEP_0	= (PAJ7620_ADDR_BASE + 0x6D)	# RW
PAJ7620_ADDR_OP_TO_S2_STEP_1	= (PAJ7620_ADDR_BASE + 0x6E)	# RW
PAJ7620_ADDR_OPERATION_ENABLE	= (PAJ7620_ADDR_BASE + 0x72)	# RW

#  PAJ7620_REGITER_BANK_SEL
PAJ7620_BANK0		= PAJ7620_VAL(0,0)
PAJ7620_BANK1	= PAJ7620_VAL(1,0)

#  PAJ7620_ADDR_SUSPEND_CMD
PAJ7620_I2C_WAKEUP	= PAJ7620_VAL(1,0)
PAJ7620_I2C_SUSPEND	= PAJ7620_VAL(0,0)

#  PAJ7620_ADDR_OPERATION_ENABLE
PAJ7620_ENABLE		= PAJ7620_VAL(1,0)
PAJ7620_DISABLE		= PAJ7620_VAL(0,0)
"""
typedef enum [
	BANK0 = 0,
	BANK1,		
] bank_e
"""
GES_RIGHT_FLAG			=	PAJ7620_VAL(1,0)
GES_LEFT_FLAG			=	PAJ7620_VAL(1,1)
GES_UP_FLAG				=	PAJ7620_VAL(1,2)
GES_DOWN_FLAG			=	PAJ7620_VAL(1,3)
GES_FORWARD_FLAG		=	PAJ7620_VAL(1,4)
GES_BACKWARD_FLAG		=	PAJ7620_VAL(1,5)
GES_CLOCKWISE_FLAG		=	PAJ7620_VAL(1,6)
GES_COUNT_CLOCKWISE_FLAG	= PAJ7620_VAL(1,7)
GES_WAVE_FLAG				= PAJ7620_VAL(1,0)

BANK0 = 0
BANK1 = 1

#Registers' initialization data 
initRegisterArray = (
    [0xEF,0x00],
	[0x32,0x29],
	[0x33,0x01],
	[0x34,0x00],
	[0x35,0x01],
	[0x36,0x00],
	[0x37,0x07],
	[0x38,0x17],
	[0x39,0x06],
	[0x3A,0x12],
	[0x3F,0x00],
	[0x40,0x02],
	[0x41,0xFF],
	[0x42,0x01],
	[0x46,0x2D],
	[0x47,0x0F],
	[0x48,0x3C],
	[0x49,0x00],
	[0x4A,0x1E],
	[0x4B,0x00],
	[0x4C,0x20],
	[0x4D,0x00],
	[0x4E,0x1A],
	[0x4F,0x14],
	[0x50,0x00],
	[0x51,0x10],
	[0x52,0x00],
	[0x5C,0x02],
	[0x5D,0x00],
	[0x5E,0x10],
	[0x5F,0x3F],
	[0x60,0x27],
	[0x61,0x28],
	[0x62,0x00],
	[0x63,0x03],
	[0x64,0xF7],
	[0x65,0x03],
	[0x66,0xD9],
	[0x67,0x03],
	[0x68,0x01],
	[0x69,0xC8],
	[0x6A,0x40],
	[0x6D,0x04],
	[0x6E,0x00],
	[0x6F,0x00],
	[0x70,0x80],
	[0x71,0x00],
	[0x72,0x00],
	[0x73,0x00],
	[0x74,0xF0],
	[0x75,0x00],
	[0x80,0x42],
	[0x81,0x44],
	[0x82,0x04],
	[0x83,0x20],
	[0x84,0x20],
	[0x85,0x00],
	[0x86,0x10],
	[0x87,0x00],
	[0x88,0x05],
	[0x89,0x18],
	[0x8A,0x10],
	[0x8B,0x01],
	[0x8C,0x37],
	[0x8D,0x00],
	[0x8E,0xF0],
	[0x8F,0x81],
	[0x90,0x06],
	[0x91,0x06],
	[0x92,0x1E],
	[0x93,0x0D],
	[0x94,0x0A],
	[0x95,0x0A],
	[0x96,0x0C],
	[0x97,0x05],
	[0x98,0x0A],
	[0x99,0x41],
	[0x9A,0x14],
	[0x9B,0x0A],
	[0x9C,0x3F],
	[0x9D,0x33],
	[0x9E,0xAE],
	[0x9F,0xF9],
	[0xA0,0x48],
	[0xA1,0x13],
	[0xA2,0x10],
	[0xA3,0x08],
	[0xA4,0x30],
	[0xA5,0x19],
	[0xA6,0x10],
	[0xA7,0x08],
	[0xA8,0x24],
	[0xA9,0x04],
	[0xAA,0x1E],
	[0xAB,0x1E],
	[0xCC,0x19],
	[0xCD,0x0B],
	[0xCE,0x13],
	[0xCF,0x64],
	[0xD0,0x21],
	[0xD1,0x0F],
	[0xD2,0x88],
	[0xE0,0x01],
	[0xE1,0x04],
	[0xE2,0x41],
	[0xE3,0xD6],
	[0xE4,0x00],
	[0xE5,0x0C],
	[0xE6,0x0A],
	[0xE7,0x00],
	[0xE8,0x00],
	[0xE9,0x00],
	[0xEE,0x07],
	[0xEF,0x01],
	[0x00,0x1E],
	[0x01,0x1E],
	[0x02,0x0F],
	[0x03,0x10],
	[0x04,0x02],
	[0x05,0x00],
	[0x06,0xB0],
	[0x07,0x04],
	[0x08,0x0D],
	[0x09,0x0E],
	[0x0A,0x9C],
	[0x0B,0x04],
	[0x0C,0x05],
	[0x0D,0x0F],
	[0x0E,0x02],
	[0x0F,0x12],
	[0x10,0x02],
	[0x11,0x02],
	[0x12,0x00],
	[0x13,0x01],
	[0x14,0x05],
	[0x15,0x07],
	[0x16,0x05],
	[0x17,0x07],
	[0x18,0x01],
	[0x19,0x04],
	[0x1A,0x05],
	[0x1B,0x0C],
	[0x1C,0x2A],
	[0x1D,0x01],
	[0x1E,0x00],
	[0x21,0x00],
	[0x22,0x00],
	[0x23,0x00],
	[0x25,0x01],
	[0x26,0x00],
	[0x27,0x39],
	[0x28,0x7F],
	[0x29,0x08],
	[0x30,0x03],
	[0x31,0x00],
	[0x32,0x1A],
	[0x33,0x1A],
	[0x34,0x07],
	[0x35,0x07],
	[0x36,0x01],
	[0x37,0xFF],
	[0x38,0x36],
	[0x39,0x07],
	[0x3A,0x00],
	[0x3E,0xFF],
	[0x3F,0x00],
	[0x40,0x77],
	[0x41,0x40],
	[0x42,0x00],
	[0x43,0x30],
	[0x44,0xA0],
	[0x45,0x5C],
	[0x46,0x00],
	[0x47,0x00],
	[0x48,0x58],
	[0x4A,0x1E],
	[0x4B,0x1E],
	[0x4C,0x00],
	[0x4D,0x00],
	[0x4E,0xA0],
	[0x4F,0x80],
	[0x50,0x00],
	[0x51,0x00],
	[0x52,0x00],
	[0x53,0x00],
	[0x54,0x00],
	[0x57,0x80],
	[0x59,0x10],
	[0x5A,0x08],
	[0x5B,0x94],
	[0x5C,0xE8],
	[0x5D,0x08],
	[0x5E,0x3D],
	[0x5F,0x99],
	[0x60,0x45],
	[0x61,0x40],
	[0x63,0x2D],
	[0x64,0x02],
	[0x65,0x96],
	[0x66,0x00],
	[0x67,0x97],
	[0x68,0x01],
	[0x69,0xCD],
	[0x6A,0x01],
	[0x6B,0xB0],
	[0x6C,0x04],
	[0x6D,0x2C],
	[0x6E,0x01],
	[0x6F,0x32],
	[0x71,0x00],
	[0x72,0x01],
	[0x73,0x35],
	[0x74,0x00],
	[0x75,0x33],
	[0x76,0x31],
	[0x77,0x01],
	[0x7C,0x84],
	[0x7D,0x03],
	[0x7E,0x01])


class GestureSensor(object):
    def __init__(self, addr=PAJ7620_ID):
        self.i2c_device = I2C(I2C.I2C0, freq=100000, scl=30, sda=31)
        time.sleep(0.01)

    def write(self, buf=None):
        if buf is not None:
            self.i2c_device.writeto(PAJ7620_ID, buf)

    def paj7620WriteReg(self, addr, cmd):
        if cmd is not None:
            self.i2c_device.writeto_mem(PAJ7620_ID, addr, cmd & 0xFF, mem_size=8)

    def paj7620ReadReg(self, addr,  qty):
        dta_send = bytearray([addr])
        self.write(dta_send)
        time.sleep(.001)
        num = qty
        bytes=self.i2c_device.readfrom(PAJ7620_ID, num)
        for _b in bytes:
            value = int(_b)
        return value

    def paj7620SelectBank(self, bank):
        if (bank == BANK0):
            self.paj7620WriteReg(PAJ7620_REGITER_BANK_SEL, PAJ7620_BANK0)
        if (bank == BANK1):
            self.paj7620WriteReg(PAJ7620_REGITER_BANK_SEL, PAJ7620_BANK1)

    def paj7620Init(self): 
        # Near_normal_mode_V5_6.15mm_121017 for 940nm
        i = 0 
        data0 = 0
        data1 = 0 
        # wakeup the sensor
        time.sleep_us(700)

        self.paj7620SelectBank(BANK0) 
        self.paj7620SelectBank(BANK0) 

        data0 = self.paj7620ReadReg(0, 1) 
        data1 = self.paj7620ReadReg(1, 1) 

        if ( (data0 is not 0x20 ) or (data1 is not 0x76) ):
            return 0xff 
        if ( data0 == 0x20 ):
            pass
            #print("wake-up finish.")

        for i in range(len(initRegisterArray)): 
            self.paj7620WriteReg(initRegisterArray[i][0], initRegisterArray[i][1])
        #print("Set up gaming mode.") 
        self.paj7620SelectBank(BANK1)   # gesture flage reg in Bank1
        #  paj7620WriteReg(0x65, 0xB7)  #  far mode 120 fps
        self.paj7620WriteReg(0x65, 0x12)   #  near mode 240 fps

        self.paj7620SelectBank(BANK0)   # gesture flage reg in Bank0
        
        #print("Paj7620 initialize register finished.") 
        return 0
        
    def getGestureValue(self, addr, opt):
        GestureValue = {
        'GES_RIGHT_FLAG':GES_RIGHT_FLAG,
        'GES_LEFT_FLAG':GES_LEFT_FLAG,
        'GES_UP_FLAG':GES_UP_FLAG,
        'GES_DOWN_FLAG':GES_DOWN_FLAG,
        'GES_FORWARD_FLAG':GES_FORWARD_FLAG,
        'GES_BACKWARD_FLAG':GES_BACKWARD_FLAG,
        'GES_CLOCKWISE_FLAG':GES_CLOCKWISE_FLAG,
        'GES_COUNT_CLOCKWISE_FLAG':GES_COUNT_CLOCKWISE_FLAG,
        'GES_WAVE_FLAG':GES_WAVE_FLAG}
        while 1:
            data = self.paj7620ReadReg(addr, 1)
            #print(data)
            if(data is not 0):
                return data == GestureValue[opt]

"""
Gesture = GestureSensor()  
Gesture.paj7620Init()
while True:
    time.sleep_ms(500)
    Gesture.getGestureValue(0x43,'GES_RIGHT_FLAG')
"""