ST Expansion SW Team / X_NUCLEO_53L1A1_mbed

X_Nucleo_53L1A1 Expansion Board Class for VL53L1X Sensor.

Dependencies:   VL53L1X_mbed

Dependents:   HelloWorld_53L1A1_Interrupts 53L1A1_Satellites_MbedOS 53L1A1_Interrupts_MbedOS 53L1A1_Polling_All_MbedOS ... more

X-NUCLEO-53L1A1 Proximity Sensor Expansion Board Firmware Package

Introduction

This firmware package includes Component Device Drivers and the Board Support Package for STMicroelectronics' X-NUCLEO-53L1A1 Proximity sensor expansion board based on VL53L1X.

Firmware Library

Class XNucleo53L1A1 is intended to represent the Proximity sensor expansion board with the same name.

The expansion board provides support for the following components:

  1. on-board VL53L1X proximity sensor,
  2. up to two additional VL53L1X Satellites.

It is intentionally implemented as a singleton because only one X-NUCLEO-VL53L1A1 may be deployed at a time in a HW component stack. In order to get the singleton instance you have to call class method `Instance()`, e.g.:

// Sensors expansion board singleton instance
static XNucleo53L1A1 *board = XNucleo53L1A1::instance(device_i2c, A2, D9, D2);

Example Applications

Components/STMPE1600/stmpe1600_class.h@14:8320b5ff96fa, 2017-08-07 (annotated)

Committer:
johnAlexander
Date:
Mon Aug 07 14:30:21 2017 +0000
Revision:
14:8320b5ff96fa
Parent:
9:367d1f390cb2
Child:
15:44e6c9013bff
Aligned to ARM mbed coding style.

Who changed what in which revision?

UserRevisionLine numberNew contents of line
johnAlexander 0:c523920bcc09 1 /**
johnAlexander 0:c523920bcc09 2 ******************************************************************************
johnAlexander 0:c523920bcc09 3 * @file stmpe1600_class.h
johnAlexander 0:c523920bcc09 4 * @author AST / EST
johnAlexander 0:c523920bcc09 5 * @version V0.0.1
johnAlexander 0:c523920bcc09 6 * @date 14-April-2015
johnAlexander 0:c523920bcc09 7 * @brief Header file for component stmpe1600
johnAlexander 0:c523920bcc09 8 ******************************************************************************
johnAlexander 0:c523920bcc09 9 * @attention
johnAlexander 0:c523920bcc09 10 *
johnAlexander 0:c523920bcc09 11 * <h2><center>&copy; COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
johnAlexander 0:c523920bcc09 12 *
johnAlexander 0:c523920bcc09 13 * Redistribution and use in source and binary forms, with or without modification,
johnAlexander 0:c523920bcc09 14 * are permitted provided that the following conditions are met:
johnAlexander 0:c523920bcc09 15 * 1. Redistributions of source code must retain the above copyright notice,
johnAlexander 0:c523920bcc09 16 * this list of conditions and the following disclaimer.
johnAlexander 0:c523920bcc09 17 * 2. Redistributions in binary form must reproduce the above copyright notice,
johnAlexander 0:c523920bcc09 18 * this list of conditions and the following disclaimer in the documentation
johnAlexander 0:c523920bcc09 19 * and/or other materials provided with the distribution.
johnAlexander 0:c523920bcc09 20 * 3. Neither the name of STMicroelectronics nor the names of its contributors
johnAlexander 0:c523920bcc09 21 * may be used to endorse or promote products derived from this software
johnAlexander 0:c523920bcc09 22 * without specific prior written permission.
johnAlexander 0:c523920bcc09 23 *
johnAlexander 0:c523920bcc09 24 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
johnAlexander 0:c523920bcc09 25 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
johnAlexander 0:c523920bcc09 26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
johnAlexander 0:c523920bcc09 27 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
johnAlexander 0:c523920bcc09 28 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
johnAlexander 0:c523920bcc09 29 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
johnAlexander 0:c523920bcc09 30 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
johnAlexander 0:c523920bcc09 31 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
johnAlexander 0:c523920bcc09 32 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
johnAlexander 0:c523920bcc09 33 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
johnAlexander 0:c523920bcc09 34 *
johnAlexander 0:c523920bcc09 35 ******************************************************************************
johnAlexander 0:c523920bcc09 36 */
johnAlexander 0:c523920bcc09 37 #ifndef __STMPE1600_CLASS
johnAlexander 0:c523920bcc09 38 #define __STMPE1600_CLASS
johnAlexander 0:c523920bcc09 39 /* Includes ------------------------------------------------------------------*/
johnAlexander 0:c523920bcc09 40 #include "DevI2C.h"
johnAlexander 0:c523920bcc09 41
johnAlexander 14:8320b5ff96fa 42 #define STMPE1600_DEF_DEVICE_ADDRESS (uint8_t)0x42*2
johnAlexander 0:c523920bcc09 43 #define STMPE1600_DEF_DIGIOUT_LVL 1
johnAlexander 0:c523920bcc09 44
johnAlexander 0:c523920bcc09 45 /** STMPE1600 registr map **/
johnAlexander 14:8320b5ff96fa 46 #define CHIP_ID_0_7 (uint8_t)0x00
johnAlexander 14:8320b5ff96fa 47 #define CHIP_ID_8_15 (uint8_t)0x01
johnAlexander 14:8320b5ff96fa 48 #define VERSION_ID (uint8_t)0x02
johnAlexander 14:8320b5ff96fa 49 #define SYS_CTRL (uint8_t)0x03
johnAlexander 14:8320b5ff96fa 50 #define IEGPIOR_0_7 (uint8_t)0x08
johnAlexander 0:c523920bcc09 51 #define IEGPIOR_8_15 (uint8_t)0x09
johnAlexander 14:8320b5ff96fa 52 #define ISGPIOR_0_7 (uint8_t)0x0A
johnAlexander 0:c523920bcc09 53 #define ISGPIOR_8_15 (uint8_t)0x0B
johnAlexander 0:c523920bcc09 54 #define GPMR_0_7 (uint8_t)0x10
johnAlexander 0:c523920bcc09 55 #define GPMR_8_15 (uint8_t)0x11
johnAlexander 0:c523920bcc09 56 #define GPSR_0_7 (uint8_t)0x12
johnAlexander 0:c523920bcc09 57 #define GPSR_8_15 (uint8_t)0x13
johnAlexander 0:c523920bcc09 58 #define GPDR_0_7 (uint8_t)0x14
johnAlexander 0:c523920bcc09 59 #define GPDR_8_15 (uint8_t)0x15
johnAlexander 0:c523920bcc09 60 #define GPIR_0_7 (uint8_t)0x16
johnAlexander 0:c523920bcc09 61 #define GPIR_8_15 (uint8_t)0x17
johnAlexander 0:c523920bcc09 62
johnAlexander 14:8320b5ff96fa 63 #define SOFT_RESET (uint8_t)0x80
johnAlexander 0:c523920bcc09 64
johnAlexander 14:8320b5ff96fa 65 typedef enum {
johnAlexander 0:c523920bcc09 66 // GPIO Expander pin names
johnAlexander 14:8320b5ff96fa 67 GPIO_0 = 0,
johnAlexander 0:c523920bcc09 68 GPIO_1,
johnAlexander 0:c523920bcc09 69 GPIO_2,
johnAlexander 14:8320b5ff96fa 70 GPIO_3,
johnAlexander 0:c523920bcc09 71 GPIO_4,
johnAlexander 0:c523920bcc09 72 GPIO_5,
johnAlexander 0:c523920bcc09 73 GPIO_6,
johnAlexander 14:8320b5ff96fa 74 GPIO_7,
johnAlexander 0:c523920bcc09 75 GPIO_8,
johnAlexander 0:c523920bcc09 76 GPIO_9,
johnAlexander 0:c523920bcc09 77 GPIO_10,
johnAlexander 14:8320b5ff96fa 78 GPIO_11,
johnAlexander 0:c523920bcc09 79 GPIO_12,
johnAlexander 0:c523920bcc09 80 GPIO_13,
johnAlexander 0:c523920bcc09 81 GPIO_14,
johnAlexander 0:c523920bcc09 82 GPIO_15,
johnAlexander 14:8320b5ff96fa 83 NOT_CON
johnAlexander 14:8320b5ff96fa 84 } ExpGpioPinName;
johnAlexander 0:c523920bcc09 85
johnAlexander 0:c523920bcc09 86 typedef enum {
johnAlexander 0:c523920bcc09 87 INPUT = 0,
johnAlexander 0:c523920bcc09 88 OUTPUT,
johnAlexander 0:c523920bcc09 89 NOT_CONNECTED
johnAlexander 14:8320b5ff96fa 90 } ExpGpioPinDirection;
johnAlexander 0:c523920bcc09 91
johnAlexander 0:c523920bcc09 92 /* Classes -------------------------------------------------------------------*/
johnAlexander 0:c523920bcc09 93 /** Class representing a single stmpe1600 GPIO expander output pin
johnAlexander 0:c523920bcc09 94 */
johnAlexander 14:8320b5ff96fa 95 class Stmpe1600DigiOut
johnAlexander 14:8320b5ff96fa 96 {
johnAlexander 14:8320b5ff96fa 97
johnAlexander 14:8320b5ff96fa 98 public:
johnAlexander 0:c523920bcc09 99 /** Constructor
johnAlexander 0:c523920bcc09 100 * @param[in] &i2c device I2C to be used for communication
johnAlexander 0:c523920bcc09 101 * @param[in] outpinname the desired out pin name to be created
johnAlexander 14:8320b5ff96fa 102 * @param[in] DevAddr the stmpe1600 I2C device address (deft STMPE1600_DEF_DEVICE_ADDRESS)
johnAlexander 14:8320b5ff96fa 103 * @param[in] lvl the default ot pin level
johnAlexander 14:8320b5ff96fa 104 */
johnAlexander 14:8320b5ff96fa 105 Stmpe1600DigiOut(DevI2C &i2c, ExpGpioPinName out_pin_name, uint8_t dev_addr = STMPE1600_DEF_DEVICE_ADDRESS,
johnAlexander 14:8320b5ff96fa 106 bool lvl = STMPE1600_DEF_DIGIOUT_LVL) : dev_i2c(i2c), exp_dev_addr(dev_addr), exp_pin_name(out_pin_name)
johnAlexander 0:c523920bcc09 107 {
johnAlexander 14:8320b5ff96fa 108 uint8_t data[2];
johnAlexander 0:c523920bcc09 109
johnAlexander 14:8320b5ff96fa 110 if (exp_pin_name == NOT_CON)
johnAlexander 14:8320b5ff96fa 111 return;
johnAlexander 14:8320b5ff96fa 112 /* set the exp_pin_name as output */
johnAlexander 14:8320b5ff96fa 113 dev_i2c.i2c_read(data, exp_dev_addr, GPDR_0_7, 1);
johnAlexander 14:8320b5ff96fa 114 dev_i2c.i2c_read(&data[1], exp_dev_addr, GPDR_8_15, 1);
johnAlexander 14:8320b5ff96fa 115 * (uint16_t *) data = * (uint16_t *) data | (1 << (uint16_t) exp_pin_name); // set gpio as out
johnAlexander 14:8320b5ff96fa 116 dev_i2c.i2c_write(data, exp_dev_addr, GPDR_0_7, 1);
johnAlexander 14:8320b5ff96fa 117 dev_i2c.i2c_write(&data[1], exp_dev_addr, GPDR_8_15, 1);
johnAlexander 14:8320b5ff96fa 118 write(lvl);
johnAlexander 0:c523920bcc09 119 }
johnAlexander 0:c523920bcc09 120
johnAlexander 14:8320b5ff96fa 121 /**
johnAlexander 14:8320b5ff96fa 122 * @brief Write on the out pin
johnAlexander 14:8320b5ff96fa 123 * @param[in] lvl level to write
johnAlexander 14:8320b5ff96fa 124 * @return 0 on Success
johnAlexander 14:8320b5ff96fa 125 */
johnAlexander 14:8320b5ff96fa 126 void write(int lvl)
johnAlexander 0:c523920bcc09 127 {
johnAlexander 14:8320b5ff96fa 128 uint8_t data[2];
johnAlexander 14:8320b5ff96fa 129
johnAlexander 14:8320b5ff96fa 130 if (exp_pin_name == NOT_CON)
johnAlexander 14:8320b5ff96fa 131 return;
johnAlexander 14:8320b5ff96fa 132 /* set the exp_pin_name state to lvl */
johnAlexander 14:8320b5ff96fa 133 dev_i2c.i2c_read(data, exp_dev_addr, GPSR_0_7, 2);
johnAlexander 14:8320b5ff96fa 134 * (uint16_t *) data = * (uint16_t *) data & (uint16_t)(~(1 << (uint16_t) exp_pin_name)); // set pin mask
johnAlexander 14:8320b5ff96fa 135 if (lvl)
johnAlexander 14:8320b5ff96fa 136 * (uint16_t *) data = * (uint16_t *) data | (uint16_t)(1 << (uint16_t) exp_pin_name);
johnAlexander 14:8320b5ff96fa 137 dev_i2c.i2c_write(data, exp_dev_addr, GPSR_0_7, 2);
johnAlexander 14:8320b5ff96fa 138 }
johnAlexander 14:8320b5ff96fa 139
johnAlexander 14:8320b5ff96fa 140 /**
johnAlexander 14:8320b5ff96fa 141 * @brief Overload assignement operator
johnAlexander 14:8320b5ff96fa 142 */
johnAlexander 14:8320b5ff96fa 143 Stmpe1600DigiOut &operator= (int lvl)
johnAlexander 14:8320b5ff96fa 144 {
johnAlexander 14:8320b5ff96fa 145 write(lvl);
johnAlexander 14:8320b5ff96fa 146 return *this;
johnAlexander 14:8320b5ff96fa 147 }
johnAlexander 14:8320b5ff96fa 148
johnAlexander 14:8320b5ff96fa 149 private:
johnAlexander 14:8320b5ff96fa 150 DevI2C &dev_i2c;
johnAlexander 14:8320b5ff96fa 151 uint8_t exp_dev_addr;
johnAlexander 14:8320b5ff96fa 152 ExpGpioPinName exp_pin_name;
johnAlexander 0:c523920bcc09 153 };
johnAlexander 0:c523920bcc09 154
johnAlexander 0:c523920bcc09 155 /* Classes -------------------------------------------------------------------*/
johnAlexander 0:c523920bcc09 156 /** Class representing a single stmpe1600 GPIO expander input pin
johnAlexander 0:c523920bcc09 157 */
johnAlexander 14:8320b5ff96fa 158 class Stmpe1600DigiIn
johnAlexander 14:8320b5ff96fa 159 {
johnAlexander 14:8320b5ff96fa 160 public:
johnAlexander 14:8320b5ff96fa 161 /** Constructor
johnAlexander 14:8320b5ff96fa 162 * @param[in] &i2c device I2C to be used for communication
johnAlexander 14:8320b5ff96fa 163 * @param[in] inpinname the desired input pin name to be created
johnAlexander 14:8320b5ff96fa 164 * @param[in] DevAddr the stmpe1600 I2C device addres (deft STMPE1600_DEF_DEVICE_ADDRESS)
johnAlexander 14:8320b5ff96fa 165 */
johnAlexander 14:8320b5ff96fa 166 Stmpe1600DigiIn(DevI2C &i2c, ExpGpioPinName in_pin_name,
johnAlexander 14:8320b5ff96fa 167 uint8_t dev_addr = STMPE1600_DEF_DEVICE_ADDRESS) : dev_i2c(i2c), exp_dev_addr(dev_addr),
johnAlexander 14:8320b5ff96fa 168 exp_pin_name(in_pin_name)
johnAlexander 0:c523920bcc09 169 {
johnAlexander 14:8320b5ff96fa 170 uint8_t data[2];
johnAlexander 14:8320b5ff96fa 171
johnAlexander 14:8320b5ff96fa 172 if (exp_pin_name == NOT_CON)
johnAlexander 14:8320b5ff96fa 173 return;
johnAlexander 14:8320b5ff96fa 174 /* set the exp_pin_name as input pin direction */
johnAlexander 14:8320b5ff96fa 175 dev_i2c.i2c_read(data, exp_dev_addr, GPDR_0_7, 2);
johnAlexander 14:8320b5ff96fa 176 * (uint16_t *) data = * (uint16_t *) data & (uint16_t)(~(1 << (uint16_t) exp_pin_name)); // set gpio as in
johnAlexander 14:8320b5ff96fa 177 dev_i2c.i2c_write(data, exp_dev_addr, GPDR_0_7, 2);
johnAlexander 14:8320b5ff96fa 178 }
johnAlexander 0:c523920bcc09 179
johnAlexander 14:8320b5ff96fa 180 /**
johnAlexander 14:8320b5ff96fa 181 * @brief Read the input pin
johnAlexander 14:8320b5ff96fa 182 * @return The pin logical state 0 or 1
johnAlexander 14:8320b5ff96fa 183 */
johnAlexander 14:8320b5ff96fa 184 bool read()
johnAlexander 0:c523920bcc09 185 {
johnAlexander 14:8320b5ff96fa 186 uint8_t data[2];
johnAlexander 14:8320b5ff96fa 187
johnAlexander 14:8320b5ff96fa 188 if (exp_pin_name == NOT_CON)
johnAlexander 14:8320b5ff96fa 189 return false;
johnAlexander 14:8320b5ff96fa 190 /* read the exp_pin_name */
johnAlexander 14:8320b5ff96fa 191 dev_i2c.i2c_read(data, exp_dev_addr, GPMR_0_7, 2);
johnAlexander 14:8320b5ff96fa 192 * (uint16_t *) data = * (uint16_t *) data & (uint16_t)(1 << (uint16_t) exp_pin_name); // mask the in gpio
johnAlexander 14:8320b5ff96fa 193 if (data[0] || data[1])
johnAlexander 14:8320b5ff96fa 194 return true;
johnAlexander 14:8320b5ff96fa 195 return false;
johnAlexander 0:c523920bcc09 196 }
johnAlexander 14:8320b5ff96fa 197
johnAlexander 14:8320b5ff96fa 198 operator int()
johnAlexander 14:8320b5ff96fa 199 {
johnAlexander 14:8320b5ff96fa 200 return read();
johnAlexander 14:8320b5ff96fa 201 }
johnAlexander 14:8320b5ff96fa 202
johnAlexander 14:8320b5ff96fa 203 private:
johnAlexander 14:8320b5ff96fa 204 DevI2C &dev_i2c;
johnAlexander 14:8320b5ff96fa 205 uint8_t exp_dev_addr;
johnAlexander 14:8320b5ff96fa 206 ExpGpioPinName exp_pin_name;
johnAlexander 0:c523920bcc09 207 };
johnAlexander 0:c523920bcc09 208
johnAlexander 0:c523920bcc09 209 /* Classes -------------------------------------------------------------------*/
johnAlexander 0:c523920bcc09 210 /** Class representing a whole stmpe1600 component (16 gpio)
johnAlexander 0:c523920bcc09 211 */
johnAlexander 14:8320b5ff96fa 212 class Stmpe1600
johnAlexander 14:8320b5ff96fa 213 {
johnAlexander 14:8320b5ff96fa 214
johnAlexander 14:8320b5ff96fa 215 public:
johnAlexander 0:c523920bcc09 216 /** Constructor
johnAlexander 0:c523920bcc09 217 * @param[in] &i2c device I2C to be used for communication
johnAlexander 0:c523920bcc09 218 * @param[in] DevAddr the stmpe1600 I2C device addres (deft STMPE1600_DEF_DEVICE_ADDRESS)
johnAlexander 14:8320b5ff96fa 219 */
johnAlexander 14:8320b5ff96fa 220 Stmpe1600(DevI2C &i2c, uint8_t dev_addr = STMPE1600_DEF_DEVICE_ADDRESS) : dev_i2c(i2c)
johnAlexander 14:8320b5ff96fa 221 {
johnAlexander 14:8320b5ff96fa 222 dev_i2c = i2c;
johnAlexander 14:8320b5ff96fa 223 exp_dev_addr = dev_addr;
johnAlexander 14:8320b5ff96fa 224 write_sys_ctrl(SOFT_RESET);
johnAlexander 14:8320b5ff96fa 225
johnAlexander 14:8320b5ff96fa 226 gpdr0_15 = (uint16_t) 0; // gpio dir all IN
johnAlexander 14:8320b5ff96fa 227 write_16bit_reg(GPDR_0_7, &gpdr0_15);
johnAlexander 14:8320b5ff96fa 228 gpsr0_15 = (uint16_t) 0x0ffff; // gpio status all 1
johnAlexander 14:8320b5ff96fa 229 write_16bit_reg(GPSR_0_7, &gpsr0_15);
johnAlexander 14:8320b5ff96fa 230 }
johnAlexander 14:8320b5ff96fa 231
johnAlexander 14:8320b5ff96fa 232 /**
johnAlexander 14:8320b5ff96fa 233 * @brief Write the SYS_CTRL register
johnAlexander 14:8320b5ff96fa 234 * @param[in] Data to be written (bit fields)
johnAlexander 14:8320b5ff96fa 235 */
johnAlexander 14:8320b5ff96fa 236 void write_sys_ctrl(uint8_t data) // data = SOFT_RESET reset the device
johnAlexander 14:8320b5ff96fa 237 {
johnAlexander 14:8320b5ff96fa 238 dev_i2c.i2c_write(&data, exp_dev_addr, SYS_CTRL, 1);
johnAlexander 14:8320b5ff96fa 239 }
johnAlexander 14:8320b5ff96fa 240
johnAlexander 14:8320b5ff96fa 241 /**
johnAlexander 14:8320b5ff96fa 242 * @brief Set the out pin
johnAlexander 14:8320b5ff96fa 243 * @param[in] The pin name
johnAlexander 14:8320b5ff96fa 244 * @return 0 on Success
johnAlexander 14:8320b5ff96fa 245 */
johnAlexander 14:8320b5ff96fa 246 bool set_gpio(ExpGpioPinName pin_name)
johnAlexander 14:8320b5ff96fa 247 {
johnAlexander 14:8320b5ff96fa 248 if (pin_name == NOT_CON)
johnAlexander 14:8320b5ff96fa 249 return true;
johnAlexander 14:8320b5ff96fa 250 gpsr0_15 = gpsr0_15 | ((uint16_t) 0x0001 << pin_name);
johnAlexander 14:8320b5ff96fa 251 write_16bit_reg(GPSR_0_7, &gpsr0_15);
johnAlexander 14:8320b5ff96fa 252 return false;
johnAlexander 14:8320b5ff96fa 253 }
johnAlexander 14:8320b5ff96fa 254
johnAlexander 14:8320b5ff96fa 255 /**
johnAlexander 14:8320b5ff96fa 256 * @brief Clear the out pin
johnAlexander 14:8320b5ff96fa 257 * @param[in] The pin name
johnAlexander 14:8320b5ff96fa 258 * @return 0 on Success
johnAlexander 14:8320b5ff96fa 259 */
johnAlexander 14:8320b5ff96fa 260 bool clear_gpio(ExpGpioPinName pin_name)
johnAlexander 14:8320b5ff96fa 261 {
johnAlexander 14:8320b5ff96fa 262 if (pin_name == NOT_CON)
johnAlexander 14:8320b5ff96fa 263 return true;
johnAlexander 14:8320b5ff96fa 264 gpsr0_15 = gpsr0_15 & (~((uint16_t) 0x0001 << pin_name));
johnAlexander 14:8320b5ff96fa 265 write_16bit_reg(GPSR_0_7, &gpsr0_15);
johnAlexander 14:8320b5ff96fa 266 return false;
johnAlexander 0:c523920bcc09 267 }
johnAlexander 0:c523920bcc09 268
johnAlexander 14:8320b5ff96fa 269 /**
johnAlexander 14:8320b5ff96fa 270 * @brief Read the input pin
johnAlexander 14:8320b5ff96fa 271 * @param[in] The pin name
johnAlexander 14:8320b5ff96fa 272 * @return The logical pin level
johnAlexander 14:8320b5ff96fa 273 */
johnAlexander 14:8320b5ff96fa 274 bool read_gpio(ExpGpioPinName pin_name)
johnAlexander 0:c523920bcc09 275 {
johnAlexander 14:8320b5ff96fa 276 uint16_t gpmr0_15;
johnAlexander 14:8320b5ff96fa 277 if (pin_name == NOT_CON)
johnAlexander 14:8320b5ff96fa 278 return true;
johnAlexander 14:8320b5ff96fa 279 read_16bit_reg(GPMR_0_7, &gpmr0_15);
johnAlexander 14:8320b5ff96fa 280 gpmr0_15 = gpmr0_15 & ((uint16_t) 0x0001 << pin_name);
johnAlexander 14:8320b5ff96fa 281 if (gpmr0_15)
johnAlexander 14:8320b5ff96fa 282 return true;
johnAlexander 14:8320b5ff96fa 283 return false;
johnAlexander 0:c523920bcc09 284 }
johnAlexander 14:8320b5ff96fa 285
johnAlexander 14:8320b5ff96fa 286 /**
johnAlexander 14:8320b5ff96fa 287 * @brief Set the pin direction
johnAlexander 14:8320b5ff96fa 288 * @param[in] The pin name
johnAlexander 14:8320b5ff96fa 289 * @param[in] The pin direction
johnAlexander 14:8320b5ff96fa 290 * @return 0 on success
johnAlexander 14:8320b5ff96fa 291 */
johnAlexander 14:8320b5ff96fa 292 bool set_gpio_dir(ExpGpioPinName pin_name, ExpGpioPinDirection pin_dir)
johnAlexander 14:8320b5ff96fa 293 {
johnAlexander 14:8320b5ff96fa 294 if (pin_name == NOT_CON || pin_dir == NOT_CONNECTED)
johnAlexander 14:8320b5ff96fa 295 return true;
johnAlexander 14:8320b5ff96fa 296 gpdr0_15 = gpdr0_15 & (~((uint16_t) 0x0001 << pin_name)); // clear the Pin
johnAlexander 14:8320b5ff96fa 297 gpdr0_15 = gpdr0_15 | ((uint16_t) pin_dir << pin_name);
johnAlexander 14:8320b5ff96fa 298 write_16bit_reg(GPDR_0_7, &gpdr0_15);
johnAlexander 14:8320b5ff96fa 299 return false;
johnAlexander 14:8320b5ff96fa 300 }
johnAlexander 0:c523920bcc09 301
johnAlexander 14:8320b5ff96fa 302 /**
johnAlexander 14:8320b5ff96fa 303 * @brief Read a 16 bits register
johnAlexander 14:8320b5ff96fa 304 * @param[in] The register address
johnAlexander 14:8320b5ff96fa 305 * @param[in] The pointer to the read data
johnAlexander 14:8320b5ff96fa 306 */
johnAlexander 14:8320b5ff96fa 307 void read_16bit_reg(uint8_t reg16_addr, uint16_t *reg16_data)
johnAlexander 0:c523920bcc09 308 {
johnAlexander 14:8320b5ff96fa 309 dev_i2c.i2c_read((uint8_t *) reg16_data, exp_dev_addr, reg16_addr, 2);
johnAlexander 14:8320b5ff96fa 310 }
johnAlexander 0:c523920bcc09 311
johnAlexander 14:8320b5ff96fa 312 /**
johnAlexander 14:8320b5ff96fa 313 * @brief Write a 16 bits register
johnAlexander 14:8320b5ff96fa 314 * @param[in] The register address
johnAlexander 14:8320b5ff96fa 315 * @param[in] The pointer to the data to be written
johnAlexander 14:8320b5ff96fa 316 */
johnAlexander 14:8320b5ff96fa 317 void write_16bit_reg(uint8_t reg16_addr, uint16_t *reg16_data)
johnAlexander 0:c523920bcc09 318 {
johnAlexander 14:8320b5ff96fa 319 dev_i2c.i2c_write((uint8_t *) reg16_data, exp_dev_addr, reg16_addr, 2);
johnAlexander 14:8320b5ff96fa 320 }
johnAlexander 0:c523920bcc09 321
johnAlexander 14:8320b5ff96fa 322 private:
johnAlexander 14:8320b5ff96fa 323 DevI2C &dev_i2c;
johnAlexander 14:8320b5ff96fa 324 uint16_t gpdr0_15; // local copy of bit direction reg
johnAlexander 14:8320b5ff96fa 325 uint16_t gpsr0_15; // local copy of bit status reg
johnAlexander 14:8320b5ff96fa 326 uint8_t exp_dev_addr; // expander device i2c addr
johnAlexander 0:c523920bcc09 327 };
johnAlexander 0:c523920bcc09 328
johnAlexander 0:c523920bcc09 329 #endif // __STMPE1600_CLASS
johnAlexander 0:c523920bcc09 330
johnAlexander 0:c523920bcc09 331