Gesture.cpp

00001 #include "mbed.h"
00002 #include "PAC7620_30Set.h"
00003 #include "Gesture.h"
00004 
00005 
00006 
00007 #define PAC7620_30_ADDR     (0xE6) //PAC7620 address shift 1-bit
00008 #define I2C_ADDR PAC7620_30_ADDR
00009 #define PXI_WMI 0x20
00010 #define ID_7620 0x01
00011 #define ID_7630 0x00
00012 #define GestureRegAddrL  0x43
00013 #define GestureRegAddrH  0x44
00014 #define DebounceT 300       //debounce time, unit:ms
00015 
00016 
00017 Pixart_Gesture::Pixart_Gesture(I2C *i2c, int Period,GestureCallback callback,bool &Result)
00018 {    
00019     m_i2c = i2c;
00020     m_GestureCallback = callback;
00021     //m_pc = pc;
00022     m_Period = Period;
00023     
00024     
00025     Result=PAC7620_30_init();    
00026 }
00027 
00028 
00029 
00030 bool Pixart_Gesture::PAC7620_30_init()
00031 {   uint8_t q;
00032 
00033     readRegister(0x00);
00034     wait_ms(50);
00035 
00036     if(readRegister(0x00) == PXI_WMI)
00037         ;//m_pc->printf("I2C Link Successful!\n\r");
00038     else{
00039         //m_pc->printf(" I2C Link Fail!\n\r");
00040         return false;
00041     }
00042     
00043     if(readRegister(0x02) == ID_7620)
00044     {
00045        // m_pc->printf("PAC7620 detected.\n\r");
00046         
00047         writeRegister(0xff, 0x00);  //wakeup
00048         wait_ms(10);                //make a delay
00049         for(q=0;q<INIT_Ges7620_REG_ARRAY_SIZE;q++)
00050             writeRegister(init_ges7620_register_array[q][0], init_ges7620_register_array[q][1]);
00051         
00052         wait_ms(DebounceT);  //debounce, clean data
00053         readRegister(GestureRegAddrH); readRegister(GestureRegAddrL);
00054         Flag_7630 = 0;
00055     }
00056     else if(readRegister(0x02) == ID_7630)
00057     {
00058         //m_pc->printf("PAC7630 detected.\n\r");
00059         
00060         writeRegister(0xff, 0x00);  //wakeup
00061         wait_ms(10);                //make a delay
00062         for(q=0;q<INIT_Ges7630_REG_ARRAY_SIZE;q++)
00063             writeRegister(init_ges7630_register_array[q][0], init_ges7630_register_array[q][1]);
00064         
00065         wait_ms(DebounceT);  //debounce, clean data
00066         readRegister(GestureRegAddrH); readRegister(GestureRegAddrL);
00067         
00068         Flag_7630 = 1;
00069     }
00070     else
00071        ;// m_pc->printf("Device not support.\n\r");
00072     
00073     m_ticker.attach_us(this,&Pixart_Gesture::periodicCallback, m_Period*1000);
00074     
00075     //m_pc->printf("\n\r~~~Start Real-time Gesture Demo~~~ \n\r");
00076     
00077     return true;
00078 }
00079 
00080 void Pixart_Gesture::periodicCallback(void)
00081 {
00082      uint16_t gesture_code;
00083 
00084      gesture_code = (readRegister(GestureRegAddrH)<<8) + readRegister(GestureRegAddrL);
00085      //pc.printf("Gesture Code: 0x %4X\n\r", gesture_code);
00086     //UP,DOWN,LEFT,RIGHT,PUSH,POLL,CLOCKWISE,COUNTER_CLOCKWISE,WAVE};  
00087      if(gesture_code != 0) 
00088      {            
00089          switch (gesture_code) 
00090          {
00091                 case 0x01: // up
00092                     if(Flag_7630 == 0)
00093                         m_GestureCallback(DOWN);
00094                     else
00095                         m_GestureCallback(LEFT);
00096                         
00097                     //m_pc->printf("up 0x%4X\n\r", gesture_code);
00098                     break;
00099                 case 0x02: // down
00100                     if(Flag_7630 == 0)
00101                         m_GestureCallback(UP);
00102                     else
00103                         m_GestureCallback(RIGHT);
00104                     
00105                     //m_pc->printf("down 0x%4X\n\r", gesture_code);
00106                     break;
00107                 case 0x04: // left
00108                     if(Flag_7630 == 0)
00109                         m_GestureCallback(RIGHT);
00110                     else
00111                         m_GestureCallback(DOWN);
00112                     //m_pc->printf("left 0x%4X\n\r", gesture_code);
00113                     break;
00114                 case 0x08: // right
00115                     if(Flag_7630 == 0)
00116                         m_GestureCallback(LEFT);
00117                     else
00118                         m_GestureCallback(UP);
00119                     //m_pc->printf("right 0x%4X\n\r", gesture_code);
00120                     break;
00121                 case 0x10: // push
00122                     m_GestureCallback(PUSH);
00123                     //m_pc->printf("push 0x%4X\n\r", gesture_code);
00124                     break;
00125                 case 0x20: // pop
00126                     m_GestureCallback(POLL);
00127                     //m_pc->printf("pop 0x%4X\n\r", gesture_code);
00128                     break;
00129                 case 0x40: // rotate right
00130                     m_GestureCallback(CLOCKWISE);
00131                     //m_pc->printf("rotate right 0x%4X\n\r", gesture_code);
00132                     break;
00133                 case 0x80: // rotate left
00134                     m_GestureCallback(COUNTER_CLOCKWISE);
00135                     //m_pc->printf("rotate left 0x%4X\n\r", gesture_code);
00136                     break;
00137                 case 0x100:// wave
00138                     m_GestureCallback(WAVE);
00139                     //m_pc->printf("wave 0x%4X\n\r", gesture_code);
00140                     break;
00141             }
00142             readRegister(GestureRegAddrH); readRegister(GestureRegAddrL);
00143     }
00144 }
00145 
00146 
00147 
00148 void Pixart_Gesture::writeRegister(uint8_t addr, uint8_t data)
00149 {
00150     char data_write[2];
00151     
00152     data_write[0] = addr;
00153     data_write[1] = data;
00154     m_i2c->write(I2C_ADDR, data_write, 2, 0);
00155 }
00156 uint8_t Pixart_Gesture::readRegister(uint8_t addr)
00157 {
00158     char data_write[2];
00159     char data_read[2];
00160     
00161     data_write[0] = addr;
00162     m_i2c->write(I2C_ADDR, data_write, 1, 0);
00163     m_i2c->read(I2C_ADDR, data_read, 1, 0);
00164     return data_read[0];
00165 }