stmpe1600_class.h

00001 /**
00002  ******************************************************************************
00003  * @file    stmpe1600_class.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 ChipID_0_7      (uint8_t)0x00
00047 #define CHIP_ID_0_7       (uint8_t)0x00
00048 //#define ChipID_8_15     (uint8_t)0x01
00049 #define CHIP_ID_8_15      (uint8_t)0x01
00050 //#define VersionId       (uint8_t)0x02
00051 #define VERSION_ID        (uint8_t)0x02
00052 #define SYS_CTRL          (uint8_t)0x03
00053 #define IEGPIOR_0_7       (uint8_t)0x08
00054 #define IEGPIOR_8_15      (uint8_t)0x09
00055 #define ISGPIOR_0_7       (uint8_t)0x0A
00056 #define ISGPIOR_8_15      (uint8_t)0x0B
00057 #define GPMR_0_7          (uint8_t)0x10
00058 #define GPMR_8_15         (uint8_t)0x11
00059 #define GPSR_0_7          (uint8_t)0x12
00060 #define GPSR_8_15         (uint8_t)0x13
00061 #define GPDR_0_7          (uint8_t)0x14
00062 #define GPDR_8_15         (uint8_t)0x15
00063 #define GPIR_0_7          (uint8_t)0x16
00064 #define GPIR_8_15         (uint8_t)0x17
00065 
00066 #define SOFT_RESET        (uint8_t)0x80
00067 
00068 typedef enum {
00069     // GPIO Expander pin names
00070     GPIO_0 = 0,
00071     GPIO_1,
00072     GPIO_2,
00073     GPIO_3,
00074     GPIO_4,
00075     GPIO_5,
00076     GPIO_6,
00077     GPIO_7,
00078     GPIO_8,
00079     GPIO_9,
00080     GPIO_10,
00081     GPIO_11,
00082     GPIO_12,
00083     GPIO_13,
00084     GPIO_14,
00085     GPIO_15,
00086     NOT_CON
00087 } ExpGpioPinName;
00088 
00089 typedef enum {
00090     INPUT = 0,
00091     OUTPUT,
00092     NOT_CONNECTED
00093 } ExpGpioPinDirection;
00094 
00095 /* Classes -------------------------------------------------------------------*/
00096 /** Class representing a single stmpe1600 GPIO expander output pin
00097  */
00098 //class STMPE1600DigiOut {
00099 class Stmpe1600DigiOut
00100 {
00101 
00102 public:
00103     /** Constructor
00104      * @param[in] &i2c device I2C to be used for communication
00105      * @param[in] outpinname the desired out pin name to be created
00106      * @param[in] DevAddr the stmpe1600 I2C device address (deft STMPE1600_DEF_DEVICE_ADDRESS)
00107      * @param[in] lvl the default ot pin level
00108      */
00109 //    STMPE1600DigiOut (DevI2C &i2c, ExpGpioPinName outpinname, uint8_t DevAddr=STMPE1600_DEF_DEVICE_ADDRESS, bool lvl=STMPE1600_DEF_DIGIOUT_LVL): dev_i2c(i2c), expdevaddr(DevAddr), exppinname(outpinname)
00110     Stmpe1600DigiOut(DevI2C &i2c, ExpGpioPinName out_pin_name, uint8_t dev_addr = STMPE1600_DEF_DEVICE_ADDRESS,
00111                      bool lvl = STMPE1600_DEF_DIGIOUT_LVL) : dev_i2c(i2c), exp_dev_addr(dev_addr), exp_pin_name(out_pin_name)
00112     {
00113         uint8_t data[2];
00114 
00115         if (exp_pin_name == NOT_CON)
00116             return;
00117         /* set the exp_pin_name as output */
00118         dev_i2c.i2c_read(data, exp_dev_addr, GPDR_0_7, 1);
00119         dev_i2c.i2c_read(&data[1], exp_dev_addr, GPDR_8_15, 1);
00120         * (uint16_t *) data = * (uint16_t *) data | (1 << (uint16_t) exp_pin_name);         // set gpio as out
00121         dev_i2c.i2c_write(data, exp_dev_addr, GPDR_0_7, 1);
00122         dev_i2c.i2c_write(&data[1], exp_dev_addr, GPDR_8_15, 1);
00123         write(lvl);
00124     }
00125 
00126     /**
00127      * @brief       Write on the out pin
00128      * @param[in]   lvl level to write
00129      * @return      0 on Success
00130      */
00131     void write(int lvl)
00132     {
00133         uint8_t data[2];
00134 
00135         if (exp_pin_name == NOT_CON)
00136             return;
00137         /* set the exp_pin_name state to lvl */
00138         dev_i2c.i2c_read(data, exp_dev_addr, GPSR_0_7, 2);
00139         * (uint16_t *) data = * (uint16_t *) data & (uint16_t)(~(1 << (uint16_t) exp_pin_name));               // set pin mask
00140         if (lvl)
00141             * (uint16_t *) data = * (uint16_t *) data | (uint16_t)(1 << (uint16_t) exp_pin_name);
00142         dev_i2c.i2c_write(data, exp_dev_addr, GPSR_0_7, 2);
00143     }
00144 
00145     /**
00146      * @brief       Overload assignement operator
00147      */
00148 //    STMPE1600DigiOut& operator=(int lvl)
00149     Stmpe1600DigiOut &operator= (int lvl)
00150     {
00151         write(lvl);
00152         return *this;
00153     }
00154 
00155 private:
00156     DevI2C &dev_i2c;
00157     uint8_t exp_dev_addr;
00158     ExpGpioPinName exp_pin_name;
00159 };
00160 
00161 /* Classes -------------------------------------------------------------------*/
00162 /** Class representing a single stmpe1600 GPIO expander input pin
00163  */
00164 //class STMPE1600DigiIn
00165 class Stmpe1600DigiIn
00166 {
00167 public:
00168     /** Constructor
00169     * @param[in] &i2c device I2C to be used for communication
00170     * @param[in] inpinname the desired input pin name to be created
00171     * @param[in] DevAddr the stmpe1600 I2C device addres (deft STMPE1600_DEF_DEVICE_ADDRESS)
00172     */
00173 //    STMPE1600DigiIn (DevI2C &i2c, ExpGpioPinName inpinname, uint8_t DevAddr=STMPE1600_DEF_DEVICE_ADDRESS): dev_i2c(i2c), expdevaddr(DevAddr), exppinname(inpinname)
00174     Stmpe1600DigiIn(DevI2C &i2c, ExpGpioPinName in_pin_name,
00175                     uint8_t dev_addr = STMPE1600_DEF_DEVICE_ADDRESS) : dev_i2c(i2c), exp_dev_addr(dev_addr),
00176         exp_pin_name(in_pin_name)
00177     {
00178         uint8_t data[2];
00179 
00180         if (exp_pin_name == NOT_CON)
00181             return;
00182         /* set the exp_pin_name as input pin direction */
00183         dev_i2c.i2c_read(data, exp_dev_addr, GPDR_0_7, 2);
00184         * (uint16_t *) data = * (uint16_t *) data & (uint16_t)(~(1 << (uint16_t) exp_pin_name));               // set gpio as in
00185         dev_i2c.i2c_write(data, exp_dev_addr, GPDR_0_7, 2);
00186     }
00187 
00188     /**
00189      * @brief       Read the input pin
00190      * @return      The pin logical state 0 or 1
00191      */
00192     bool read()
00193     {
00194         uint8_t data[2];
00195 
00196         if (exp_pin_name == NOT_CON)
00197             return false;
00198         /* read the exp_pin_name */
00199         dev_i2c.i2c_read(data, exp_dev_addr, GPMR_0_7, 2);
00200         * (uint16_t *) data = * (uint16_t *) data & (uint16_t)(1 << (uint16_t) exp_pin_name);            // mask the in gpio
00201         if (data[0] || data[1])
00202             return true;
00203         return false;
00204     }
00205 
00206     operator int()
00207     {
00208         return read();
00209     }
00210 
00211 private:
00212     DevI2C &dev_i2c;
00213     uint8_t exp_dev_addr;
00214     ExpGpioPinName exp_pin_name;
00215 };
00216 
00217 /* Classes -------------------------------------------------------------------*/
00218 /** Class representing a whole stmpe1600 component (16 gpio)
00219  */
00220 //class STMPE1600 {
00221 class Stmpe1600
00222 {
00223 
00224 public:
00225     /** Constructor
00226     * @param[in] &i2c device I2C to be used for communication
00227     * @param[in] DevAddr the stmpe1600 I2C device addres (deft STMPE1600_DEF_DEVICE_ADDRESS)
00228     */
00229 //    STMPE1600 (DevI2C &i2c, uint8_t DevAddr=STMPE1600_DEF_DEVICE_ADDRESS ) : dev_i2c(i2c)
00230     Stmpe1600(DevI2C &i2c, uint8_t dev_addr = STMPE1600_DEF_DEVICE_ADDRESS) : dev_i2c(i2c)
00231     {
00232         dev_i2c = i2c;
00233         exp_dev_addr = dev_addr;
00234         write_sys_ctrl(SOFT_RESET);
00235 
00236         gpdr0_15 = (uint16_t) 0;    // gpio dir all IN
00237         write_16bit_reg(GPDR_0_7, &gpdr0_15);
00238         gpsr0_15 = (uint16_t) 0x0ffff;   // gpio status all 1
00239         write_16bit_reg(GPSR_0_7, &gpsr0_15);
00240     }
00241 
00242     /**
00243      * @brief       Write the SYS_CTRL register
00244      * @param[in]   Data to be written (bit fields)
00245      */
00246 //    void writeSYS_CTRL (uint8_t data)     // data = SOFT_RESET reset the device
00247     void write_sys_ctrl(uint8_t data)      // data = SOFT_RESET reset the device
00248     {
00249         dev_i2c.i2c_write(&data, exp_dev_addr, SYS_CTRL, 1);
00250     }
00251 
00252     /**
00253      * @brief       Set the out pin
00254      * @param[in]   The pin name
00255      * @return      0 on Success
00256      */
00257 //  bool setGPIO (ExpGpioPinName PinName)
00258     bool set_gpio(ExpGpioPinName pin_name)
00259     {
00260         if (pin_name == NOT_CON)
00261             return true;
00262         gpsr0_15 = gpsr0_15 | ((uint16_t) 0x0001 << pin_name);
00263         write_16bit_reg(GPSR_0_7, &gpsr0_15);
00264         return false;
00265     }
00266 
00267     /**
00268      * @brief       Clear the out pin
00269      * @param[in]   The pin name
00270      * @return      0 on Success
00271      */
00272 //  bool clrGPIO (ExpGpioPinName PinName)
00273     bool clear_gpio(ExpGpioPinName pin_name)
00274     {
00275         if (pin_name == NOT_CON)
00276             return true;
00277         gpsr0_15 = gpsr0_15 & (~((uint16_t) 0x0001 << pin_name));
00278         write_16bit_reg(GPSR_0_7, &gpsr0_15);
00279         return false;
00280     }
00281 
00282     /**
00283      * @brief       Read the input pin
00284      * @param[in]   The pin name
00285      * @return      The logical pin level
00286      */
00287 //  bool rdGPIO (ExpGpioPinName PinName)
00288     bool read_gpio(ExpGpioPinName pin_name)
00289     {
00290         uint16_t gpmr0_15;
00291         if (pin_name == NOT_CON)
00292             return true;
00293         read_16bit_reg(GPMR_0_7, &gpmr0_15);
00294         gpmr0_15 = gpmr0_15 & ((uint16_t) 0x0001 << pin_name);
00295         if (gpmr0_15)
00296             return true;
00297         return false;
00298     }
00299 
00300     /**
00301      * @brief       Set the pin direction
00302      * @param[in]   The pin name
00303      * @param[in]   The pin direction
00304      * @return      0 on success
00305      */
00306 //  bool setGPIOdir (ExpGpioPinName PinName, ExpGpioPinDirection PinDir)
00307     bool set_gpio_dir(ExpGpioPinName pin_name, ExpGpioPinDirection pin_dir)
00308     {
00309         if (pin_name == NOT_CON || pin_dir == NOT_CONNECTED)
00310             return true;
00311         gpdr0_15 = gpdr0_15 & (~((uint16_t) 0x0001 << pin_name));        // clear the Pin
00312         gpdr0_15 = gpdr0_15 | ((uint16_t) pin_dir << pin_name);
00313         write_16bit_reg(GPDR_0_7, &gpdr0_15);
00314         return false;
00315     }
00316 
00317     /**
00318      * @brief       Read a 16 bits register
00319      * @param[in]   The register address
00320      * @param[in]   The pointer to the read data
00321      */
00322 //    void read16bitReg (uint8_t Reg16Addr, uint16_t *Reg16Data)
00323     void read_16bit_reg(uint8_t reg16_addr, uint16_t *reg16_data)
00324     {
00325         dev_i2c.i2c_read((uint8_t *) reg16_data, exp_dev_addr, reg16_addr, 2);
00326     }
00327 
00328     /**
00329      * @brief       Write a 16 bits register
00330      * @param[in]   The register address
00331      * @param[in]   The pointer to the data to be written
00332      */
00333 //    void write16bitReg (uint8_t Reg16Addr, uint16_t *Reg16Data)
00334     void write_16bit_reg(uint8_t reg16_addr, uint16_t *reg16_data)
00335     {
00336         dev_i2c.i2c_write((uint8_t *) reg16_data, exp_dev_addr, reg16_addr, 2);
00337     }
00338 
00339 private:
00340     DevI2C &dev_i2c;
00341     uint16_t gpdr0_15;  // local copy of bit direction reg
00342     uint16_t gpsr0_15;  // local copy of bit status reg
00343     uint8_t exp_dev_addr; // expander device i2c addr
00344 };
00345 
00346 #endif // __STMPE1600_CLASS
00347 
00348