STMPE1600.h

00001 #ifndef STMPE1600_H
00002 #define STMPE1600_H
00003 
00004 #include "mbed.h"
00005 
00006 #define STMPE1600_DEF_DEVICE_ADDRESS  (uint8_t)0x42*2   
00007 #define STMPE1600_DEF_DIGIOUT_LVL      1
00008 
00009 /**  STMPE1600 registr map **/
00010 #define ChipID_0_7      (uint8_t)0x00
00011 #define ChipID_8_15     (uint8_t)0x01
00012 #define VersionId       (uint8_t)0x02
00013 #define SYS_CTRL        (uint8_t)0x03
00014 #define IEGPIOR_0_7     (uint8_t)0x08
00015 #define IEGPIOR_8_15      (uint8_t)0x09
00016 #define ISGPIOR_0_7     (uint8_t)0x0A
00017 #define ISGPIOR_8_15      (uint8_t)0x0B
00018 #define GPMR_0_7          (uint8_t)0x10
00019 #define GPMR_8_15         (uint8_t)0x11
00020 #define GPSR_0_7          (uint8_t)0x12
00021 #define GPSR_8_15         (uint8_t)0x13
00022 #define GPDR_0_7          (uint8_t)0x14
00023 #define GPDR_8_15         (uint8_t)0x15
00024 #define GPIR_0_7          (uint8_t)0x16
00025 #define GPIR_8_15         (uint8_t)0x17
00026 
00027 #define SOFT_RESET          (uint8_t)0x80
00028 
00029 
00030 #define STMPE1600_DEFAULT_ID 0x01
00031 
00032 typedef enum {
00033     // GPIO Expander pin names
00034     GPIO_0=  0,
00035     GPIO_1 ,
00036     GPIO_2 ,
00037     GPIO_3 ,            
00038     GPIO_4 ,
00039     GPIO_5 ,
00040     GPIO_6 ,
00041     GPIO_7 ,            
00042     GPIO_8 ,
00043     GPIO_9 ,
00044     GPIO_10 ,
00045     GPIO_11 ,            
00046     GPIO_12 ,
00047     GPIO_13 ,
00048     GPIO_14 ,
00049     GPIO_15 ,
00050     NOT_CON
00051 } exp_gpio_pin_name;   
00052 
00053 typedef enum {
00054     INPUT = 0,
00055     OUTPUT,
00056     NOT_CONNECTED
00057 } exp_gpio_pin_direction;
00058 
00059 
00060 class STMPE1600 {
00061 public: 
00062     /** Constructor
00063     * @param[in] &i2c device I2C to be used for communication
00064     * @param[in] DevAddr the stmpe1600 I2C device addres (deft STMPE1600_DEF_DEVICE_ADDRESS)
00065     */ 
00066     STMPE1600 (I2C *i2c, uint8_t DevAddr=STMPE1600_DEF_DEVICE_ADDRESS );
00067 
00068     /**
00069      * @brief       Write the SYS_CTRL register 
00070      * @param[in]   Data to be written (bit fields)
00071      */     
00072     void write_sys_ctrl (uint8_t data)     // data = SOFT_RESET reset the device
00073     {
00074         // _dev_i2c->i2c_write((uint8_t*)SYS_CTRL, _expdevaddr, data, 1);
00075         write(&data,SYS_CTRL,1);
00076     }
00077       
00078     /**
00079      * @brief       Set the out pin
00080      * @param[in]   The pin name
00081      * @return      0 on Success
00082      */         
00083     bool set_gpio (exp_gpio_pin_name pin_name) 
00084     {
00085           if (pin_name == NOT_CON) return true;         
00086           _gpsro_15 = _gpsro_15 | ((uint16_t)0x0001<<pin_name);
00087           write_16_bit_reg (GPSR_0_7 , &_gpsro_15);
00088           return false;
00089     }
00090     
00091     /**
00092      * @brief       Clear the out pin
00093      * @param[in]   The pin name
00094      * @return      0 on Success
00095      */         
00096     bool clr_gpio (exp_gpio_pin_name pin_name) 
00097     {
00098           if (pin_name == NOT_CON) return true;         
00099           _gpsro_15 = _gpsro_15 & (~((uint16_t)0x0001<<pin_name));
00100           write_16_bit_reg (GPSR_0_7 , &_gpsro_15);
00101           return false;
00102     }       
00103     
00104     /**
00105      * @brief       Read the input pin
00106      * @param[in]   The pin name
00107      * @return      The logical pin level
00108      */                 
00109     bool rd_gpio (exp_gpio_pin_name pin_name) 
00110     {               
00111           uint16_t gpmr0_15;
00112           if (pin_name == NOT_CON) return true;
00113           read_16_bit_reg (GPMR_0_7, &gpmr0_15);
00114           gpmr0_15 = gpmr0_15 & ((uint16_t)0x0001<<pin_name);
00115           if (gpmr0_15) {
00116             return true;
00117         }
00118           return false;         
00119     }
00120     
00121     /**
00122      * @brief       Set the pin direction
00123      * @param[in]   The pin name
00124      * @param[in]   The pin direction    
00125      * @return      0 on success
00126      */
00127     bool set_gpio_dir (exp_gpio_pin_name pin_name, exp_gpio_pin_direction pin_dir) 
00128     {
00129         if (pin_name == NOT_CON || pin_dir == NOT_CONNECTED) {
00130             return true;
00131         }
00132         _gpdro_15 = _gpdro_15 & (~((uint16_t)0x0001<<pin_name));  // clear the Pin
00133         _gpdro_15 = _gpdro_15 | ((uint16_t)pin_dir<<pin_name);
00134         write_16_bit_reg (GPDR_0_7 , &_gpdro_15);
00135         return false;
00136     }
00137 
00138     /**
00139      * @brief       Read a 16 bits register
00140      * @param[in]   The register address
00141      * @param[in]   The pointer to the read data
00142      */ 
00143     void read_16_bit_reg (uint8_t reg_16_addr, uint16_t *reg_16_data)
00144     {
00145         uint8_t data[2];
00146         read(data,reg_16_addr,2);
00147         *reg_16_data = data[1] << 8 | data[0];
00148     }               
00149 
00150     /**
00151      * @brief       Write a 16 bits register
00152      * @param[in]   The register address
00153      * @param[in]   The pointer to the data to be written
00154      */                         
00155     void write_16_bit_reg (uint8_t reg_16_addr, uint16_t *reg_16_data)
00156     {
00157         uint8_t data[2];
00158         data[1] = (*reg_16_data >> 8) & 0xff;
00159         data[0] = *reg_16_data & 0xff; 
00160         write(data,reg_16_addr,2);
00161     }   
00162     
00163     /**
00164      * @brief  Read STMPE1600 device id.
00165      * @return device ID 0x01
00166      */
00167     uint8_t readID();
00168 
00169     /**
00170      * @brief Test the STMPE1600 device whether connect.
00171      * @return [true] connect [false] disconnect. 
00172      */
00173     bool testConnect();
00174 
00175 protected:
00176 
00177     /**
00178      * @brief Init device.
00179      */
00180     void init();
00181 
00182     /**
00183      * @brief       Read data from STMPE1600.
00184      * @param[out]  The pointer to the read data.
00185      * @param[in]   The register address.
00186      * @param[in]   The pointer to the data size.
00187      */                 
00188     void read(uint8_t* pBuffer, uint8_t RegisterAddr, uint16_t NumByteToRead);        
00189 
00190     /**
00191      * @brief       Write data to STMPE1600.
00192      * @param[in]   The data pointer of write. 
00193      * @param[in]   The register address.
00194      * @param[in]   The pointer to the data size.
00195      */                         
00196     void write(uint8_t* pBuffer, uint8_t RegisterAddr, uint16_t NumByteToWrite);
00197 
00198 private:                    
00199     I2C *_dev_i2c;    
00200     uint16_t _gpdro_15;   // local copy of bit direction reg 
00201     uint16_t _gpsro_15;   // local copy of bit status reg 
00202     uint8_t address; // expander device i2c addr
00203 };
00204 
00205 
00206 
00207 
00208 #endif