Pixart_OTS.cpp

00001 /* PixArt Optical Finger Navigation, OFN, sensor driver.
00002  * By PixArt Imaging Inc.
00003  * Primary Engineer: Hill Chen (PixArt USA)
00004  *
00005  * License: Apache-2.0; http://www.apache.org/licenses/LICENSE-2.0
00006  */
00007  
00008 #include "Pixart_OTS.h"
00009 
00010 #ifdef DEBUG
00011     #define DEBUG_PRINT(...)    m_pc.printf(__VA_ARGS__)
00012 #else
00013     #define DEBUG_PRINT(...)    {}
00014 #endif
00015 
00016 #define ARRAY_REG_SIZE(arr)     (sizeof(arr) / sizeof(arr[0]))
00017 
00018 #define I2C_ADDR (0x75 << 1) //I2C address @ID_SEL=Low (apply to 9125/26/50)
00019 #define PXI_WMI 0x31
00020 
00021 class Pixart_OTS_ComPort : public Pixart_ComPort
00022 {
00023 public:
00024     Pixart_OTS_ComPort(Pixart_ComPort *comPort)
00025         : m_comPort(comPort)
00026     {
00027     }
00028 
00029     virtual void writeRegister(uint8_t addr, uint8_t data)
00030     {
00031         if (addr == 0x7F || addr == 0x06 || addr == 0x03 || addr == 0x2A) {
00032             m_comPort->writeRegister(addr, data);
00033         }
00034 
00035         else {
00036             uint8_t read_value;
00037             do
00038             {
00039                 m_comPort->writeRegister(addr, data);
00040                 read_value = m_comPort->readRegister(addr);
00041             } while (read_value != data);
00042         }
00043     }
00044 
00045     virtual uint8_t readRegister(uint8_t addr)
00046     {
00047         return m_comPort->readRegister(addr);
00048     }
00049 
00050 private:
00051     Pixart_ComPort *m_comPort;
00052 };
00053 
00054 static std::vector<Pixart_OTS_Register> create_registers(const uint8_t setting[][2], size_t setting_len);
00055 
00056 Pixart_OTS::Pixart_OTS(Serial &pc, Pixart_ComPort *comPort, Pixart_OTS_GrabData *grabData, Pixart_OTS_Task *task, const std::vector<Pixart_OTS_Register> &initRegisters, const std::string &model, const std::string &HwVer)
00057     : m_pc(pc)
00058     , m_comPort(new Pixart_OTS_ComPort(comPort))
00059     , m_grabData(grabData)
00060     , m_task(task)
00061     , m_initRegisters(initRegisters)
00062     , m_model(model)
00063     , m_HwVer(HwVer)
00064 {
00065     wait_ms(500);
00066     print_build_info();
00067 }
00068 
00069 bool Pixart_OTS::sensor_init()
00070 {
00071     m_task->reset_task(*m_comPort);
00072     wait_ms(10);
00073     if (m_comPort->readRegister(0x00) != PXI_WMI)
00074     {
00075         DEBUG_PRINT("\r\n << Sensor_Init (Fail), ID = %2X", m_comPort->readRegister(0x00));
00076         return false;
00077     }
00078 
00079     m_totalX = 0;
00080     m_totalY = 0;
00081     
00082     for (size_t i = 0; i < m_initRegisters.size(); ++i)
00083     {
00084         m_comPort->writeRegister(m_initRegisters[i].addr, m_initRegisters[i].value);
00085     }
00086     
00087     m_task->pre_task(*m_comPort);
00088 
00089     return true;
00090 }
00091 
00092 void Pixart_OTS::periodic_callback()
00093 {
00094     m_task->periodic_task(*m_comPort);
00095     
00096     if (m_comPort->readRegister(0x02) & 0x80)
00097     {
00098         Pixart_OTS_OtsData otsData = m_grabData->grab(*m_comPort);
00099         
00100         if ((otsData.x != 0) || (otsData.y != 0))
00101         {
00102             m_totalX += otsData.x;
00103             m_totalY += otsData.y;
00104 
00105             DEBUG_PRINT("deltaX: %d\t\t\tdeltaY: %d\n\r", otsData.x, otsData.y);
00106             DEBUG_PRINT("X-axis Counts: %d\t\tY-axis Counts: %d\n\r", m_totalX, m_totalY);
00107         }
00108     }
00109 }
00110 
00111 int Pixart_OTS::get_default_i2c_slave_address()
00112 {
00113     return I2C_ADDR;
00114 }
00115 
00116 std::string Pixart_OTS::get_model() const
00117 {
00118     return m_model;
00119 }
00120 
00121 std::string Pixart_OTS::get_HwVer() const
00122 {
00123     return m_HwVer;
00124 }
00125 
00126 void Pixart_OTS::print_build_info()
00127 {
00128     DEBUG_PRINT("\r\n\n PixArt Mbed eval code, %s, %s", PRODUCT, get_model().c_str());
00129     DEBUG_PRINT("\r\n Fw version: %s, Hw version: %s, mbed version: %d", FW_VERSION, get_HwVer().c_str(), MBED_VERSION);
00130     DEBUG_PRINT("\r\n Build time: %s  %s\r\n", __TIME__, __DATE__);
00131 }
00132 
00133 Pixart_OTS* create_pixart_ots(Pixart_OTS_Model model, Serial &pc, I2C &i2c)
00134 {   
00135     Pixart_ComPort *com_port = NULL;
00136     Pixart_OTS_GrabData *grabData = NULL;
00137     Pixart_OTS_Task *task = NULL;
00138     std::vector<Pixart_OTS_Register> initRegisters;
00139     std::string modelName;
00140     std::string HwVer;
00141 
00142     switch (model)
00143     {
00144         case PIXART_OTS_MODEL_9125:
00145             {
00146                 com_port = new Pixart_I2cComPort(i2c, Pixart_OTS::get_default_i2c_slave_address());
00147                 grabData = new Pixart_OTS_GrabData_12bitXy();
00148                 task = new Pixart_OTS_Task();
00149                 initRegisters = create_registers(Pixart_OTS_9125_InitSetting, ARRAY_REG_SIZE(Pixart_OTS_9125_InitSetting));
00150                 modelName = "P9125";
00151                 HwVer = "PIX1484-v5.0";
00152             }
00153             break;
00154 
00155         case PIXART_OTS_MODEL_9126:
00156             {
00157                 com_port = new Pixart_I2cComPort(i2c, Pixart_OTS::get_default_i2c_slave_address());
00158                 grabData = new Pixart_OTS_GrabData_12bitXy();
00159                 task = new Pixart_OTS_Task();
00160                 initRegisters = create_registers(Pixart_OTS_9126_InitSetting, ARRAY_REG_SIZE(Pixart_OTS_9126_InitSetting));
00161                 modelName = "P9126";
00162                 HwVer = "PIX1484-v6.0";
00163             }
00164             break;
00165 
00166         case PIXART_OTS_MODEL_9150:
00167             {
00168                 com_port = new Pixart_I2cComPort(i2c, Pixart_OTS::get_default_i2c_slave_address());
00169                 grabData = new Pixart_OTS_GrabData_16bitXOnly();
00170                 task = new Pixart_OTS_Task();
00171                 initRegisters = create_registers(Pixart_OTS_9150_InitSetting, ARRAY_REG_SIZE(Pixart_OTS_9150_InitSetting));
00172                 modelName = "P9150";
00173                 HwVer = "PIX1xxx-vx.0";
00174             }
00175             break;
00176 
00177         default:
00178             return NULL;
00179     }
00180 
00181     return new Pixart_OTS(pc, com_port, grabData, task, initRegisters, modelName, HwVer);
00182 }
00183 
00184 Pixart_OTS* create_pixart_ots(Pixart_OTS_Model model, Serial &pc, SPI &spi, DigitalOut &cs)
00185 {   
00186     Pixart_ComPort *com_port = NULL;
00187     Pixart_OTS_GrabData *grabData = NULL;
00188     Pixart_OTS_Task *task = NULL;
00189     std::vector<Pixart_OTS_Register> initRegisters;
00190     std::string modelName;
00191     std::string HwVer;
00192 
00193     switch (model)
00194     {
00195         case PIXART_OTS_MODEL_9125:
00196             {
00197                 com_port = new Pixart_SpiComPort(spi, cs);
00198                 grabData = new Pixart_OTS_GrabData_12bitXy();
00199                 task = new Pixart_OTS_Task();
00200                 initRegisters = create_registers(Pixart_OTS_9125_InitSetting, ARRAY_REG_SIZE(Pixart_OTS_9125_InitSetting));
00201                 modelName = "P9125";
00202                 HwVer = "PIX1484-v5.0";
00203             }
00204             break;
00205 
00206         case PIXART_OTS_MODEL_9130:
00207             {
00208                 com_port = new Pixart_SpiComPort(spi, cs);
00209                 grabData = new Pixart_OTS_GrabData_16bitXy();
00210                 task = new Pixart_OTS_Task();
00211                 initRegisters = create_registers(Pixart_OTS_9130_InitSetting, ARRAY_REG_SIZE(Pixart_OTS_9130_InitSetting));
00212                 modelName = "P9130";
00213                 HwVer = "PIX1621-v3.0";
00214             }
00215             break;
00216 
00217         case PIXART_OTS_MODEL_5101:
00218             {
00219                 com_port = new Pixart_SpiComPort(spi, cs);
00220                 grabData = new Pixart_OTS_GrabData_16bitXy();
00221                 task = new Pixart_OTS_Task();
00222                 initRegisters = create_registers(Pixart_OTS_5101_InitSetting, ARRAY_REG_SIZE(Pixart_OTS_5101_InitSetting));
00223                 modelName = "P5101";
00224                 HwVer = "PIX1889-v1.0";
00225             }
00226             break;
00227 
00228         default:
00229             return NULL;
00230     }
00231 
00232     return new Pixart_OTS(pc, com_port, grabData, task, initRegisters, modelName, HwVer);
00233 }
00234 
00235 Pixart_OTS* create_pixart_ots(Pixart_OTS_Model model, Serial &pc, SPI &spi, DigitalOut &cs, DigitalOut &ldp_enl_pin)
00236 {   
00237     Pixart_ComPort *com_port = NULL;
00238     Pixart_OTS_GrabData *grabData = NULL;
00239     Pixart_OTS_Task *task = NULL;
00240     std::vector<Pixart_OTS_Register> initRegisters;
00241     std::string modelName;
00242     std::string HwVer;
00243 
00244     switch (model)
00245     {
00246         case PIXART_OTS_MODEL_5101:
00247             {
00248                 com_port = new Pixart_SpiComPort(spi, cs);
00249                 grabData = new Pixart_OTS_GrabData_16bitXy();
00250                 task = new Pixart_OTS_Task_5101(ldp_enl_pin);
00251                 initRegisters = create_registers(Pixart_OTS_5101_InitSetting, ARRAY_REG_SIZE(Pixart_OTS_5101_InitSetting));
00252                 modelName = "P5101";
00253                 HwVer = "PIX1889-v1.0";
00254             }
00255             break;
00256 
00257         default:
00258             return NULL;
00259     }
00260 
00261     return new Pixart_OTS(pc, com_port, grabData, task, initRegisters, modelName, HwVer);
00262 }
00263 
00264 static std::vector<Pixart_OTS_Register> create_registers(const uint8_t setting[][2], size_t setting_len)
00265 {
00266     std::vector<Pixart_OTS_Register> registers;
00267 
00268     for (int i = 0; i < setting_len; ++i)
00269     {
00270         Pixart_OTS_Register reg;
00271         reg.addr = setting[i][0];
00272         reg.value = setting[i][1];
00273         registers.push_back(reg);
00274     }
00275 
00276     return registers;
00277 }