Stmpe1600.h

00001 /**
00002  ******************************************************************************
00003  * @file    Stmpe1600.h
00004  * @author  AST / EST
00005  * @version V0.0.1
00006  * @date    14-April-2015
00007  * @brief   Header file for component stmpe1600
00008  ******************************************************************************
00009  * @attention
00010  *
00011  * <h2><center>&copy; COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
00012  *
00013  * Redistribution and use in source and binary forms, with or without modification,
00014  * are permitted provided that the following conditions are met:
00015  *   1. Redistributions of source code must retain the above copyright notice,
00016  *      this list of conditions and the following disclaimer.
00017  *   2. Redistributions in binary form must reproduce the above copyright notice,
00018  *      this list of conditions and the following disclaimer in the documentation
00019  *      and/or other materials provided with the distribution.
00020  *   3. Neither the name of STMicroelectronics nor the names of its contributors
00021  *      may be used to endorse or promote products derived from this software
00022  *       without specific prior written permission.
00023  *
00024  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
00025  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
00026  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
00027  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
00028  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
00029  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
00030  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
00031  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
00032  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
00033  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
00034  *
00035  ******************************************************************************
00036 */
00037 #ifndef     __STMPE1600_CLASS
00038 #define     __STMPE1600_CLASS
00039 /* Includes ------------------------------------------------------------------*/
00040 #include    "DevI2C.h"
00041 
00042 #define STMPE1600_DEF_DEVICE_ADDRESS  (uint8_t)0x42*2
00043 #define STMPE1600_DEF_DIGIOUT_LVL      1
00044 
00045 /**  STMPE1600 registr map **/
00046 #define CHIP_ID_0_7       (uint8_t)0x00
00047 #define CHIP_ID_8_15      (uint8_t)0x01
00048 #define VERSION_ID        (uint8_t)0x02
00049 #define SYS_CTRL          (uint8_t)0x03
00050 #define IEGPIOR_0_7       (uint8_t)0x08
00051 #define IEGPIOR_8_15      (uint8_t)0x09
00052 #define ISGPIOR_0_7       (uint8_t)0x0A
00053 #define ISGPIOR_8_15      (uint8_t)0x0B
00054 #define GPMR_0_7          (uint8_t)0x10
00055 #define GPMR_8_15         (uint8_t)0x11
00056 #define GPSR_0_7          (uint8_t)0x12
00057 #define GPSR_8_15         (uint8_t)0x13
00058 #define GPDR_0_7          (uint8_t)0x14
00059 #define GPDR_8_15         (uint8_t)0x15
00060 #define GPIR_0_7          (uint8_t)0x16
00061 #define GPIR_8_15         (uint8_t)0x17
00062 
00063 #define SOFT_RESET        (uint8_t)0x80
00064 
00065 typedef enum {
00066     // GPIO Expander pin names
00067     GPIO_0 = 0,
00068     GPIO_1,
00069     GPIO_2,
00070     GPIO_3,
00071     GPIO_4,
00072     GPIO_5,
00073     GPIO_6,
00074     GPIO_7,
00075     GPIO_8,
00076     GPIO_9,
00077     GPIO_10,
00078     GPIO_11,
00079     GPIO_12,
00080     GPIO_13,
00081     GPIO_14,
00082     GPIO_15,
00083     NOT_CON
00084 } ExpGpioPinName;
00085 
00086 typedef enum {
00087     INPUT = 0,
00088     OUTPUT,
00089     NOT_CONNECTED
00090 } ExpGpioPinDirection;
00091 
00092 /* Classes -------------------------------------------------------------------*/
00093 /** Class representing a single stmpe1600 GPIO expander output pin
00094  */
00095 class Stmpe1600DigiOut
00096 {
00097 
00098 public:
00099     /** Constructor
00100      * @param[in] &i2c device I2C to be used for communication
00101      * @param[in] outpinname the desired out pin name to be created
00102      * @param[in] DevAddr the stmpe1600 I2C device address (deft STMPE1600_DEF_DEVICE_ADDRESS)
00103      * @param[in] lvl the default ot pin level
00104      */
00105     Stmpe1600DigiOut(DevI2C *i2c, ExpGpioPinName out_pin_name, uint8_t dev_addr = STMPE1600_DEF_DEVICE_ADDRESS,
00106                      bool lvl = STMPE1600_DEF_DIGIOUT_LVL) : _dev_i2c(i2c), exp_dev_addr(dev_addr), exp_pin_name(out_pin_name)
00107     {
00108         uint8_t data[2];
00109 
00110         if (exp_pin_name == NOT_CON) {
00111             return;
00112         }
00113         /* set the exp_pin_name as output */
00114         _dev_i2c->i2c_read(data, exp_dev_addr, GPDR_0_7, 1);
00115         _dev_i2c->i2c_read(&data[1], exp_dev_addr, GPDR_8_15, 1);
00116         * (uint16_t *) data = * (uint16_t *) data | (1 << (uint16_t) exp_pin_name);         // set gpio as out
00117         _dev_i2c->i2c_write(data, exp_dev_addr, GPDR_0_7, 1);
00118         _dev_i2c->i2c_write(&data[1], exp_dev_addr, GPDR_8_15, 1);
00119         write(lvl);
00120     }
00121 
00122     /**
00123      * @brief       Write on the out pin
00124      * @param[in]   lvl level to write
00125      * @return      0 on Success
00126      */
00127     void write(int lvl)
00128     {
00129         uint8_t data[2];
00130 
00131         if (exp_pin_name == NOT_CON) {
00132             return;
00133         }
00134         /* set the exp_pin_name state to lvl */
00135         _dev_i2c->i2c_read(data, exp_dev_addr, GPSR_0_7, 2);
00136         * (uint16_t *) data = * (uint16_t *) data & (uint16_t)(~(1 << (uint16_t) exp_pin_name));               // set pin mask
00137         if (lvl) {
00138             * (uint16_t *) data = * (uint16_t *) data | (uint16_t)(1 << (uint16_t) exp_pin_name);
00139         }
00140         _dev_i2c->i2c_write(data, exp_dev_addr, GPSR_0_7, 2);
00141     }
00142 
00143     /**
00144      * @brief       Overload assignement operator
00145      */
00146     Stmpe1600DigiOut &operator= (int lvl)
00147     {
00148         write(lvl);
00149         return *this;
00150     }
00151 
00152 private:
00153     DevI2C *_dev_i2c;
00154     uint8_t exp_dev_addr;
00155     ExpGpioPinName exp_pin_name;
00156 };
00157 
00158 /* Classes -------------------------------------------------------------------*/
00159 /** Class representing a single stmpe1600 GPIO expander input pin
00160  */
00161 class Stmpe1600DigiIn
00162 {
00163 public:
00164     /** Constructor
00165     * @param[in] &i2c device I2C to be used for communication
00166     * @param[in] inpinname the desired input pin name to be created
00167     * @param[in] DevAddr the stmpe1600 I2C device addres (deft STMPE1600_DEF_DEVICE_ADDRESS)
00168     */
00169     Stmpe1600DigiIn(DevI2C *i2c, ExpGpioPinName in_pin_name,
00170                     uint8_t dev_addr = STMPE1600_DEF_DEVICE_ADDRESS) : _dev_i2c(i2c), exp_dev_addr(dev_addr),
00171         exp_pin_name(in_pin_name)
00172     {
00173         uint8_t data[2];
00174 
00175         if (exp_pin_name == NOT_CON) {
00176             return;
00177         }
00178         /* set the exp_pin_name as input pin direction */
00179         _dev_i2c->i2c_read(data, exp_dev_addr, GPDR_0_7, 2);
00180         * (uint16_t *) data = * (uint16_t *) data & (uint16_t)(~(1 << (uint16_t) exp_pin_name));               // set gpio as in
00181         _dev_i2c->i2c_write(data, exp_dev_addr, GPDR_0_7, 2);
00182     }
00183 
00184     /**
00185      * @brief       Read the input pin
00186      * @return      The pin logical state 0 or 1
00187      */
00188     bool read()
00189     {
00190         uint8_t data[2];
00191 
00192         if (exp_pin_name == NOT_CON) {
00193             return false;
00194         }
00195         /* read the exp_pin_name */
00196         _dev_i2c->i2c_read(data, exp_dev_addr, GPMR_0_7, 2);
00197         * (uint16_t *) data = * (uint16_t *) data & (uint16_t)(1 << (uint16_t) exp_pin_name);            // mask the in gpio
00198         if (data[0] || data[1]) {
00199             return true;
00200         }
00201         return false;
00202     }
00203 
00204     operator int()
00205     {
00206         return read();
00207     }
00208 
00209 private:
00210     DevI2C *_dev_i2c;
00211     uint8_t exp_dev_addr;
00212     ExpGpioPinName exp_pin_name;
00213 };
00214 
00215 /* Classes -------------------------------------------------------------------*/
00216 /** Class representing a whole stmpe1600 component (16 gpio)
00217  */
00218 class Stmpe1600
00219 {
00220 
00221 public:
00222     /** Constructor
00223     * @param[in] &i2c device I2C to be used for communication
00224     * @param[in] DevAddr the stmpe1600 I2C device addres (deft STMPE1600_DEF_DEVICE_ADDRESS)
00225     */
00226     Stmpe1600(DevI2C *i2c, uint8_t dev_addr = STMPE1600_DEF_DEVICE_ADDRESS) : _dev_i2c(i2c)
00227     {
00228         exp_dev_addr = dev_addr;
00229         write_sys_ctrl(SOFT_RESET);
00230 
00231         gpdr0_15 = (uint16_t) 0;    // gpio dir all IN
00232         write_16bit_reg(GPDR_0_7, &gpdr0_15);
00233         gpsr0_15 = (uint16_t) 0x0ffff;   // gpio status all 1
00234         write_16bit_reg(GPSR_0_7, &gpsr0_15);
00235     }
00236 
00237     /**
00238      * @brief       Write the SYS_CTRL register
00239      * @param[in]   Data to be written (bit fields)
00240      */
00241     void write_sys_ctrl(uint8_t data)      // data = SOFT_RESET reset the device
00242     {
00243         _dev_i2c->i2c_write(&data, exp_dev_addr, SYS_CTRL, 1);
00244     }
00245 
00246     /**
00247      * @brief       Set the out pin
00248      * @param[in]   The pin name
00249      * @return      0 on Success
00250      */
00251     bool set_gpio(ExpGpioPinName pin_name)
00252     {
00253         if (pin_name == NOT_CON) {
00254             return true;
00255         }
00256         gpsr0_15 = gpsr0_15 | ((uint16_t) 0x0001 << pin_name);
00257         write_16bit_reg(GPSR_0_7, &gpsr0_15);
00258         return false;
00259     }
00260 
00261     /**
00262      * @brief       Clear the out pin
00263      * @param[in]   The pin name
00264      * @return      0 on Success
00265      */
00266     bool clear_gpio(ExpGpioPinName pin_name)
00267     {
00268         if (pin_name == NOT_CON) {
00269             return true;
00270         }
00271         gpsr0_15 = gpsr0_15 & (~((uint16_t) 0x0001 << pin_name));
00272         write_16bit_reg(GPSR_0_7, &gpsr0_15);
00273         return false;
00274     }
00275 
00276     /**
00277      * @brief       Read the input pin
00278      * @param[in]   The pin name
00279      * @return      The logical pin level
00280      */
00281     bool read_gpio(ExpGpioPinName pin_name)
00282     {
00283         uint16_t gpmr0_15;
00284         if (pin_name == NOT_CON) {
00285             return true;
00286         }
00287         read_16bit_reg(GPMR_0_7, &gpmr0_15);
00288         gpmr0_15 = gpmr0_15 & ((uint16_t) 0x0001 << pin_name);
00289         if (gpmr0_15) {
00290             return true;
00291         }
00292         return false;
00293     }
00294 
00295     /**
00296      * @brief       Set the pin direction
00297      * @param[in]   The pin name
00298      * @param[in]   The pin direction
00299      * @return      0 on success
00300      */
00301     bool set_gpio_dir(ExpGpioPinName pin_name, ExpGpioPinDirection pin_dir)
00302     {
00303         if (pin_name == NOT_CON || pin_dir == NOT_CONNECTED) {
00304             return true;
00305         }
00306         gpdr0_15 = gpdr0_15 & (~((uint16_t) 0x0001 << pin_name));        // clear the Pin
00307         gpdr0_15 = gpdr0_15 | ((uint16_t) pin_dir << pin_name);
00308         write_16bit_reg(GPDR_0_7, &gpdr0_15);
00309         return false;
00310     }
00311 
00312     /**
00313      * @brief       Read a 16 bits register
00314      * @param[in]   The register address
00315      * @param[in]   The pointer to the read data
00316      */
00317     void read_16bit_reg(uint8_t reg16_addr, uint16_t *reg16_data)
00318     {
00319         _dev_i2c->i2c_read((uint8_t *) reg16_data, exp_dev_addr, reg16_addr, 2);
00320     }
00321 
00322     /**
00323      * @brief       Write a 16 bits register
00324      * @param[in]   The register address
00325      * @param[in]   The pointer to the data to be written
00326      */
00327     void write_16bit_reg(uint8_t reg16_addr, uint16_t *reg16_data)
00328     {
00329         _dev_i2c->i2c_write((uint8_t *) reg16_data, exp_dev_addr, reg16_addr, 2);
00330     }
00331 
00332 private:
00333     DevI2C *_dev_i2c;
00334     uint16_t gpdr0_15;  // local copy of bit direction reg
00335     uint16_t gpsr0_15;  // local copy of bit status reg
00336     uint8_t exp_dev_addr; // expander device i2c addr
00337 };
00338 
00339 #endif // __STMPE1600_CLASS