DPM Team / ADS1015

A library for ADS1015 and ADS1115 from Texas Instruments.

Fork of ADS1015 by Arve Seljebu

Adafruit_ADS1015.cpp@7:72e307987683, 2018-07-24 (annotated)

Committer:
cgoyette
Date:
Tue Jul 24 16:53:15 2018 +0000
Revision:
7:72e307987683
Parent:
6:4c38bb36099c 
removed debug messages.

Who changed what in which revision?

UserRevisionLine numberNew contents of line
arve0 0:8174d9ceeca1 1 /**************************************************************************/
arve0 0:8174d9ceeca1 2 /*!
arve0 0:8174d9ceeca1 3 @file Adafruit_ADS1015.cpp
arve0 0:8174d9ceeca1 4 @author K.Townsend (Adafruit Industries)
arve0 0:8174d9ceeca1 5 @license BSD (see LICENSE.txt)
arve0 0:8174d9ceeca1 6
arve0 0:8174d9ceeca1 7 Ported to mbed by Arve Seljebu - arve0.github.io
arve0 0:8174d9ceeca1 8
arve0 0:8174d9ceeca1 9 Driver for the ADS1015/ADS1115 ADC
arve0 0:8174d9ceeca1 10
arve0 0:8174d9ceeca1 11 This is a library for the Adafruit MPL115A2 breakout
arve0 0:8174d9ceeca1 12 ----> https://www.adafruit.com/products/1083
arve0 0:8174d9ceeca1 13
arve0 0:8174d9ceeca1 14 Adafruit invests time and resources providing this open source code,
arve0 0:8174d9ceeca1 15 please support Adafruit and open-source hardware by purchasing
arve0 0:8174d9ceeca1 16 products from Adafruit!
arve0 0:8174d9ceeca1 17
arve0 0:8174d9ceeca1 18 @section HISTORY
arve0 0:8174d9ceeca1 19
arve0 0:8174d9ceeca1 20 v1.0 - First release
arve0 0:8174d9ceeca1 21 v1.1.1 - Ported to mbed
arve0 0:8174d9ceeca1 22 */
arve0 0:8174d9ceeca1 23 /**************************************************************************/
arve0 0:8174d9ceeca1 24
arve0 0:8174d9ceeca1 25 #include <mbed.h>
arve0 0:8174d9ceeca1 26 #include "Adafruit_ADS1015.h"
arve0 0:8174d9ceeca1 27
arve0 0:8174d9ceeca1 28 /**************************************************************************/
arve0 0:8174d9ceeca1 29 /*!
arve0 0:8174d9ceeca1 30 @brief Writes 16-bits to the specified destination register
arve0 0:8174d9ceeca1 31 */
arve0 0:8174d9ceeca1 32 /**************************************************************************/
arve0 3:fb735fb343de 33 void Adafruit_ADS1015::writeRegister(uint8_t i2cAddress, uint8_t reg, uint16_t value)
arve0 3:fb735fb343de 34 {
cgoyette 7:72e307987683 35 //printf("ADC-wr1\r\n");
arve0 3:fb735fb343de 36 char cmd[3];
arve0 3:fb735fb343de 37 cmd[0] = (char)reg;
cgoyette 7:72e307987683 38 //printf("ADC-wr cmd0=%i\r\n", cmd[0]);
cgoyette 7:72e307987683 39 //printf("ADC-wr2\r\n");
arve0 3:fb735fb343de 40 cmd[1] = (char)(value>>8);
cgoyette 7:72e307987683 41 //printf("ADC-wr cmd1=%i\r\n", cmd[1]);
cgoyette 7:72e307987683 42 //printf("ADC-wr3\r\n");
arve0 3:fb735fb343de 43 cmd[2] = (char)(value & 0xFF);
cgoyette 7:72e307987683 44 //printf("ADC-wr cmd2=%i\r\n", cmd[2]);
cgoyette 7:72e307987683 45 //printf("ADC-wr4\r\n");
cgoyette 7:72e307987683 46 //printf("i2c-Write return = %i\r\n", m_i2c->write(i2cAddress, cmd, 3));
arve0 3:fb735fb343de 47 m_i2c->write(i2cAddress, cmd, 3);
cgoyette 7:72e307987683 48 //printf("ADC-wr5\r\n");
arve0 0:8174d9ceeca1 49 }
arve0 0:8174d9ceeca1 50
arve0 0:8174d9ceeca1 51 /**************************************************************************/
arve0 0:8174d9ceeca1 52 /*!
arve0 0:8174d9ceeca1 53 @brief Reads 16-bits from the specified register
arve0 0:8174d9ceeca1 54 */
arve0 0:8174d9ceeca1 55 /**************************************************************************/
arve0 3:fb735fb343de 56 uint16_t Adafruit_ADS1015::readRegister(uint8_t i2cAddress, uint8_t reg)
arve0 3:fb735fb343de 57 {
cgoyette 7:72e307987683 58 //printf("ADC-RR1\r\n");
arve0 3:fb735fb343de 59 char data[2];
cgoyette 7:72e307987683 60 //printf("ADC-RR2\r\n");
arve0 3:fb735fb343de 61 data[0] = reg; // temporary use this to send address to conversion register
cgoyette 7:72e307987683 62 //printf("ADC-RR3\r\n");
arve0 3:fb735fb343de 63 m_i2c->write(i2cAddress, data, 1);
cgoyette 7:72e307987683 64 //printf("ADC-RR4\r\n");
arve0 3:fb735fb343de 65 m_i2c->read(i2cAddress, data, 2);
cgoyette 7:72e307987683 66 //printf("ADC-RR5\r\n");
arve0 3:fb735fb343de 67 return (data[0] << 8 | data [1]);
arve0 0:8174d9ceeca1 68 }
arve0 0:8174d9ceeca1 69
arve0 0:8174d9ceeca1 70 /**************************************************************************/
arve0 0:8174d9ceeca1 71 /*!
arve0 0:8174d9ceeca1 72 @brief Instantiates a new ADS1015 class w/appropriate properties
arve0 0:8174d9ceeca1 73 */
arve0 0:8174d9ceeca1 74 /**************************************************************************/
arve0 3:fb735fb343de 75 Adafruit_ADS1015::Adafruit_ADS1015(I2C* i2c, uint8_t i2cAddress)
arve0 0:8174d9ceeca1 76 {
arve0 3:fb735fb343de 77 // shift 7 bit address 1 left: read expects 8 bit address, see I2C.h
arve0 3:fb735fb343de 78 m_i2cAddress = i2cAddress << 1;
arve0 3:fb735fb343de 79 m_conversionDelay = ADS1015_CONVERSIONDELAY;
arve0 3:fb735fb343de 80 m_bitShift = 4;
arve0 3:fb735fb343de 81 m_gain = GAIN_TWOTHIRDS; /* +/- 6.144V range (limited to VDD +0.3V max!) */
arve0 3:fb735fb343de 82 m_i2c = i2c;
arve0 0:8174d9ceeca1 83 }
arve0 0:8174d9ceeca1 84
arve0 0:8174d9ceeca1 85 /**************************************************************************/
arve0 0:8174d9ceeca1 86 /*!
arve0 0:8174d9ceeca1 87 @brief Instantiates a new ADS1115 class w/appropriate properties
arve0 0:8174d9ceeca1 88 */
arve0 0:8174d9ceeca1 89 /**************************************************************************/
arve0 0:8174d9ceeca1 90 Adafruit_ADS1115::Adafruit_ADS1115(I2C* i2c, uint8_t i2cAddress)
arve0 0:8174d9ceeca1 91 {
arve0 3:fb735fb343de 92 // shift 7 bit address 1 left: read expects 8 bit address, see mbed's I2C.h
arve0 3:fb735fb343de 93 m_i2cAddress = i2cAddress << 1;
cgoyette 7:72e307987683 94 //printf("12c-address=%i\r\n", m_i2cAddress);
arve0 3:fb735fb343de 95 m_conversionDelay = ADS1115_CONVERSIONDELAY;
arve0 3:fb735fb343de 96 m_bitShift = 0;
arve0 3:fb735fb343de 97 m_gain = GAIN_TWOTHIRDS; /* +/- 6.144V range (limited to VDD +0.3V max!) */
arve0 3:fb735fb343de 98 m_i2c = i2c;
arve0 0:8174d9ceeca1 99 }
arve0 0:8174d9ceeca1 100
arve0 0:8174d9ceeca1 101 /**************************************************************************/
arve0 0:8174d9ceeca1 102 /*!
arve0 0:8174d9ceeca1 103 @brief Sets the gain and input voltage range
arve0 0:8174d9ceeca1 104 */
arve0 0:8174d9ceeca1 105 /**************************************************************************/
arve0 0:8174d9ceeca1 106 void Adafruit_ADS1015::setGain(adsGain_t gain)
arve0 0:8174d9ceeca1 107 {
arve0 3:fb735fb343de 108 m_gain = gain;
arve0 0:8174d9ceeca1 109 }
arve0 0:8174d9ceeca1 110
arve0 0:8174d9ceeca1 111 /**************************************************************************/
arve0 0:8174d9ceeca1 112 /*!
arve0 0:8174d9ceeca1 113 @brief Gets a gain and input voltage range
arve0 0:8174d9ceeca1 114 */
arve0 0:8174d9ceeca1 115 /**************************************************************************/
arve0 0:8174d9ceeca1 116 adsGain_t Adafruit_ADS1015::getGain()
arve0 0:8174d9ceeca1 117 {
arve0 3:fb735fb343de 118 return m_gain;
arve0 0:8174d9ceeca1 119 }
arve0 0:8174d9ceeca1 120
arve0 0:8174d9ceeca1 121 /**************************************************************************/
arve0 0:8174d9ceeca1 122 /*!
arve0 0:8174d9ceeca1 123 @brief Gets a single-ended ADC reading from the specified channel
arve0 0:8174d9ceeca1 124 */
arve0 0:8174d9ceeca1 125 /**************************************************************************/
arve0 3:fb735fb343de 126 uint16_t Adafruit_ADS1015::readADC_SingleEnded(uint8_t channel)
arve0 3:fb735fb343de 127 {
cgoyette 7:72e307987683 128 //printf("ADC1\r\n");
cgoyette 7:72e307987683 129 //printf("channel = %i\r\n", channel);
arve0 3:fb735fb343de 130 if (channel > 3) {
cgoyette 7:72e307987683 131 //printf("ADC2\r\n");
arve0 3:fb735fb343de 132 return 0;
arve0 3:fb735fb343de 133 }
cgoyette 7:72e307987683 134 //printf("ADC3\r\n");
arve0 3:fb735fb343de 135 // Start with default values
arve0 3:fb735fb343de 136 uint16_t config = ADS1015_REG_CONFIG_CQUE_NONE | // Disable the comparator (default val)
arve0 3:fb735fb343de 137 ADS1015_REG_CONFIG_CLAT_NONLAT | // Non-latching (default val)
arve0 3:fb735fb343de 138 ADS1015_REG_CONFIG_CPOL_ACTVLOW | // Alert/Rdy active low (default val)
arve0 3:fb735fb343de 139 ADS1015_REG_CONFIG_CMODE_TRAD | // Traditional comparator (default val)
arve0 4:6445a678d458 140 ADS1015_REG_CONFIG_DR_1600SPS | // 1600(ADS1015) or 250(ADS1115) samples per second (default)
arve0 3:fb735fb343de 141 ADS1015_REG_CONFIG_MODE_SINGLE; // Single-shot mode (default)
arve0 3:fb735fb343de 142
arve0 3:fb735fb343de 143 // Set PGA/voltage range
cgoyette 7:72e307987683 144 //printf("ADC4\r\n");
arve0 3:fb735fb343de 145 config |= m_gain;
cgoyette 7:72e307987683 146 //printf("ADC5\r\n");
arve0 3:fb735fb343de 147 // Set single-ended input channel
arve0 3:fb735fb343de 148 switch (channel) {
arve0 3:fb735fb343de 149 case (0):
cgoyette 7:72e307987683 150 //printf("ADC6\r\n");
arve0 3:fb735fb343de 151 config |= ADS1015_REG_CONFIG_MUX_SINGLE_0;
cgoyette 7:72e307987683 152 //printf("ADC7\r\n");
arve0 3:fb735fb343de 153 break;
arve0 3:fb735fb343de 154 case (1):
cgoyette 7:72e307987683 155 //printf("ADC8\r\n");
arve0 3:fb735fb343de 156 config |= ADS1015_REG_CONFIG_MUX_SINGLE_1;
cgoyette 7:72e307987683 157 //printf("ADC9\r\n");
arve0 3:fb735fb343de 158 break;
arve0 3:fb735fb343de 159 case (2):
cgoyette 7:72e307987683 160 //printf("ADC10\r\n");
arve0 3:fb735fb343de 161 config |= ADS1015_REG_CONFIG_MUX_SINGLE_2;
cgoyette 7:72e307987683 162 //printf("ADC11\r\n");
arve0 3:fb735fb343de 163 break;
arve0 3:fb735fb343de 164 case (3):
cgoyette 7:72e307987683 165 //printf("ADC12\r\n");
arve0 3:fb735fb343de 166 config |= ADS1015_REG_CONFIG_MUX_SINGLE_3;
cgoyette 7:72e307987683 167 //printf("ADC13\r\n");
arve0 3:fb735fb343de 168 break;
arve0 3:fb735fb343de 169 }
arve0 0:8174d9ceeca1 170
arve0 3:fb735fb343de 171 // Set 'start single-conversion' bit
cgoyette 7:72e307987683 172 //printf("ADC14\r\n");
arve0 3:fb735fb343de 173 config |= ADS1015_REG_CONFIG_OS_SINGLE;
arve0 0:8174d9ceeca1 174
arve0 3:fb735fb343de 175 // Write config register to the ADC
cgoyette 7:72e307987683 176 //printf("ADC15\r\n");
arve0 3:fb735fb343de 177 writeRegister(m_i2cAddress, ADS1015_REG_POINTER_CONFIG, config);
arve0 0:8174d9ceeca1 178
arve0 3:fb735fb343de 179 // Wait for the conversion to complete
cgoyette 7:72e307987683 180 //printf("ADC16\r\n");
arve0 3:fb735fb343de 181 wait_ms(m_conversionDelay);
arve0 0:8174d9ceeca1 182
arve0 3:fb735fb343de 183 // Read the conversion results
arve0 3:fb735fb343de 184 // Shift 12-bit results right 4 bits for the ADS1015
cgoyette 7:72e307987683 185 //printf("ADC17\r\n");
arve0 3:fb735fb343de 186 return readRegister(m_i2cAddress, ADS1015_REG_POINTER_CONVERT) >> m_bitShift;
arve0 0:8174d9ceeca1 187 }
arve0 0:8174d9ceeca1 188
arve0 0:8174d9ceeca1 189 /**************************************************************************/
arve0 3:fb735fb343de 190 /*!
arve0 0:8174d9ceeca1 191 @brief Reads the conversion results, measuring the voltage
arve0 0:8174d9ceeca1 192 difference between the P (AIN0) and N (AIN1) input. Generates
arve0 0:8174d9ceeca1 193 a signed value since the difference can be either
arve0 0:8174d9ceeca1 194 positive or negative.
arve0 0:8174d9ceeca1 195 */
arve0 0:8174d9ceeca1 196 /**************************************************************************/
arve0 3:fb735fb343de 197 int16_t Adafruit_ADS1015::readADC_Differential_0_1()
arve0 3:fb735fb343de 198 {
arve0 3:fb735fb343de 199 // Start with default values
arve0 3:fb735fb343de 200 uint16_t config = ADS1015_REG_CONFIG_CQUE_NONE | // Disable the comparator (default val)
arve0 3:fb735fb343de 201 ADS1015_REG_CONFIG_CLAT_NONLAT | // Non-latching (default val)
arve0 3:fb735fb343de 202 ADS1015_REG_CONFIG_CPOL_ACTVLOW | // Alert/Rdy active low (default val)
arve0 3:fb735fb343de 203 ADS1015_REG_CONFIG_CMODE_TRAD | // Traditional comparator (default val)
arve0 4:6445a678d458 204 ADS1015_REG_CONFIG_DR_1600SPS | // 1600(ADS1015) or 250(ADS1115) samples per second (default)
arve0 3:fb735fb343de 205 ADS1015_REG_CONFIG_MODE_SINGLE; // Single-shot mode (default)
arve0 0:8174d9ceeca1 206
arve0 3:fb735fb343de 207 // Set PGA/voltage range
arve0 3:fb735fb343de 208 config |= m_gain;
arve0 0:8174d9ceeca1 209
arve0 3:fb735fb343de 210 // Set channels
arve0 3:fb735fb343de 211 config |= ADS1015_REG_CONFIG_MUX_DIFF_0_1; // AIN0 = P, AIN1 = N
arve0 0:8174d9ceeca1 212
arve0 3:fb735fb343de 213 // Set 'start single-conversion' bit
arve0 3:fb735fb343de 214 config |= ADS1015_REG_CONFIG_OS_SINGLE;
arve0 0:8174d9ceeca1 215
arve0 3:fb735fb343de 216 // Write config register to the ADC
arve0 3:fb735fb343de 217 writeRegister(m_i2cAddress, ADS1015_REG_POINTER_CONFIG, config);
arve0 3:fb735fb343de 218
arve0 3:fb735fb343de 219 // Wait for the conversion to complete
arve0 3:fb735fb343de 220 wait_ms(m_conversionDelay);
arve0 0:8174d9ceeca1 221
arve0 3:fb735fb343de 222 // Read the conversion results
arve0 3:fb735fb343de 223 uint16_t res = readRegister(m_i2cAddress, ADS1015_REG_POINTER_CONVERT) >> m_bitShift;
arve0 3:fb735fb343de 224 if (m_bitShift == 0) {
arve0 3:fb735fb343de 225 return (int16_t)res;
arve0 3:fb735fb343de 226 } else {
arve0 3:fb735fb343de 227 // Shift 12-bit results right 4 bits for the ADS1015,
arve0 3:fb735fb343de 228 // making sure we keep the sign bit intact
arve0 3:fb735fb343de 229 if (res > 0x07FF) {
arve0 3:fb735fb343de 230 // negative number - extend the sign to 16th bit
arve0 3:fb735fb343de 231 res |= 0xF000;
arve0 3:fb735fb343de 232 }
arve0 3:fb735fb343de 233 return (int16_t)res;
arve0 0:8174d9ceeca1 234 }
arve0 0:8174d9ceeca1 235 }
arve0 0:8174d9ceeca1 236
arve0 0:8174d9ceeca1 237 /**************************************************************************/
arve0 3:fb735fb343de 238 /*!
arve0 0:8174d9ceeca1 239 @brief Reads the conversion results, measuring the voltage
arve0 0:8174d9ceeca1 240 difference between the P (AIN2) and N (AIN3) input. Generates
arve0 0:8174d9ceeca1 241 a signed value since the difference can be either
arve0 0:8174d9ceeca1 242 positive or negative.
arve0 0:8174d9ceeca1 243 */
arve0 0:8174d9ceeca1 244 /**************************************************************************/
arve0 3:fb735fb343de 245 int16_t Adafruit_ADS1015::readADC_Differential_2_3()
arve0 3:fb735fb343de 246 {
arve0 3:fb735fb343de 247 // Start with default values
arve0 3:fb735fb343de 248 uint16_t config = ADS1015_REG_CONFIG_CQUE_NONE | // Disable the comparator (default val)
arve0 3:fb735fb343de 249 ADS1015_REG_CONFIG_CLAT_NONLAT | // Non-latching (default val)
arve0 3:fb735fb343de 250 ADS1015_REG_CONFIG_CPOL_ACTVLOW | // Alert/Rdy active low (default val)
arve0 3:fb735fb343de 251 ADS1015_REG_CONFIG_CMODE_TRAD | // Traditional comparator (default val)
arve0 4:6445a678d458 252 ADS1015_REG_CONFIG_DR_1600SPS | // 1600(ADS1015) or 250(ADS1115) samples per second (default)
arve0 3:fb735fb343de 253 ADS1015_REG_CONFIG_MODE_SINGLE; // Single-shot mode (default)
arve0 0:8174d9ceeca1 254
arve0 3:fb735fb343de 255 // Set PGA/voltage range
arve0 3:fb735fb343de 256 config |= m_gain;
arve0 0:8174d9ceeca1 257
arve0 3:fb735fb343de 258 // Set channels
arve0 3:fb735fb343de 259 config |= ADS1015_REG_CONFIG_MUX_DIFF_2_3; // AIN2 = P, AIN3 = N
arve0 0:8174d9ceeca1 260
arve0 3:fb735fb343de 261 // Set 'start single-conversion' bit
arve0 3:fb735fb343de 262 config |= ADS1015_REG_CONFIG_OS_SINGLE;
arve0 0:8174d9ceeca1 263
arve0 3:fb735fb343de 264 // Write config register to the ADC
arve0 3:fb735fb343de 265 writeRegister(m_i2cAddress, ADS1015_REG_POINTER_CONFIG, config);
arve0 3:fb735fb343de 266
arve0 3:fb735fb343de 267 // Wait for the conversion to complete
arve0 3:fb735fb343de 268 wait_ms(m_conversionDelay);
arve0 0:8174d9ceeca1 269
arve0 3:fb735fb343de 270 // Read the conversion results
arve0 3:fb735fb343de 271 uint16_t res = readRegister(m_i2cAddress, ADS1015_REG_POINTER_CONVERT) >> m_bitShift;
arve0 3:fb735fb343de 272 if (m_bitShift == 0) {
arve0 3:fb735fb343de 273 return (int16_t)res;
arve0 3:fb735fb343de 274 } else {
arve0 3:fb735fb343de 275 // Shift 12-bit results right 4 bits for the ADS1015,
arve0 3:fb735fb343de 276 // making sure we keep the sign bit intact
arve0 3:fb735fb343de 277 if (res > 0x07FF) {
arve0 3:fb735fb343de 278 // negative number - extend the sign to 16th bit
arve0 3:fb735fb343de 279 res |= 0xF000;
arve0 3:fb735fb343de 280 }
arve0 3:fb735fb343de 281 return (int16_t)res;
arve0 0:8174d9ceeca1 282 }
arve0 0:8174d9ceeca1 283 }
arve0 0:8174d9ceeca1 284
arve0 0:8174d9ceeca1 285 /**************************************************************************/
arve0 0:8174d9ceeca1 286 /*!
arve0 0:8174d9ceeca1 287 @brief Sets up the comparator to operate in basic mode, causing the
arve0 0:8174d9ceeca1 288 ALERT/RDY pin to assert (go from high to low) when the ADC
arve0 0:8174d9ceeca1 289 value exceeds the specified threshold.
arve0 0:8174d9ceeca1 290
arve0 0:8174d9ceeca1 291 This will also set the ADC in continuous conversion mode.
arve0 0:8174d9ceeca1 292 */
arve0 0:8174d9ceeca1 293 /**************************************************************************/
arve0 0:8174d9ceeca1 294 void Adafruit_ADS1015::startComparator_SingleEnded(uint8_t channel, int16_t threshold)
arve0 0:8174d9ceeca1 295 {
arve0 3:fb735fb343de 296 // Start with default values
arve0 3:fb735fb343de 297 uint16_t config = ADS1015_REG_CONFIG_CQUE_1CONV | // Comparator enabled and asserts on 1 match
arve0 3:fb735fb343de 298 ADS1015_REG_CONFIG_CLAT_LATCH | // Latching mode
arve0 3:fb735fb343de 299 ADS1015_REG_CONFIG_CPOL_ACTVLOW | // Alert/Rdy active low (default val)
arve0 3:fb735fb343de 300 ADS1015_REG_CONFIG_CMODE_TRAD | // Traditional comparator (default val)
arve0 4:6445a678d458 301 ADS1015_REG_CONFIG_DR_1600SPS | // 1600(ADS1015) or 250(ADS1115) samples per second (default)
arve0 3:fb735fb343de 302 ADS1015_REG_CONFIG_MODE_CONTIN | // Continuous conversion mode
arve0 3:fb735fb343de 303 ADS1015_REG_CONFIG_MODE_CONTIN; // Continuous conversion mode
arve0 3:fb735fb343de 304
arve0 3:fb735fb343de 305 // Set PGA/voltage range
arve0 3:fb735fb343de 306 config |= m_gain;
arve0 0:8174d9ceeca1 307
arve0 3:fb735fb343de 308 // Set single-ended input channel
arve0 3:fb735fb343de 309 switch (channel) {
arve0 3:fb735fb343de 310 case (0):
arve0 3:fb735fb343de 311 config |= ADS1015_REG_CONFIG_MUX_SINGLE_0;
arve0 3:fb735fb343de 312 break;
arve0 3:fb735fb343de 313 case (1):
arve0 3:fb735fb343de 314 config |= ADS1015_REG_CONFIG_MUX_SINGLE_1;
arve0 3:fb735fb343de 315 break;
arve0 3:fb735fb343de 316 case (2):
arve0 3:fb735fb343de 317 config |= ADS1015_REG_CONFIG_MUX_SINGLE_2;
arve0 3:fb735fb343de 318 break;
arve0 3:fb735fb343de 319 case (3):
arve0 3:fb735fb343de 320 config |= ADS1015_REG_CONFIG_MUX_SINGLE_3;
arve0 3:fb735fb343de 321 break;
arve0 3:fb735fb343de 322 }
arve0 0:8174d9ceeca1 323
arve0 3:fb735fb343de 324 // Set the high threshold register
arve0 3:fb735fb343de 325 // Shift 12-bit results left 4 bits for the ADS1015
arve0 3:fb735fb343de 326 writeRegister(m_i2cAddress, ADS1015_REG_POINTER_HITHRESH, threshold << m_bitShift);
arve0 0:8174d9ceeca1 327
arve0 3:fb735fb343de 328 // Write config register to the ADC
arve0 3:fb735fb343de 329 writeRegister(m_i2cAddress, ADS1015_REG_POINTER_CONFIG, config);
arve0 0:8174d9ceeca1 330 }
arve0 0:8174d9ceeca1 331
arve0 0:8174d9ceeca1 332 /**************************************************************************/
arve0 0:8174d9ceeca1 333 /*!
arve0 0:8174d9ceeca1 334 @brief In order to clear the comparator, we need to read the
arve0 0:8174d9ceeca1 335 conversion results. This function reads the last conversion
arve0 0:8174d9ceeca1 336 results without changing the config value.
arve0 0:8174d9ceeca1 337 */
arve0 0:8174d9ceeca1 338 /**************************************************************************/
arve0 0:8174d9ceeca1 339 int16_t Adafruit_ADS1015::getLastConversionResults()
arve0 0:8174d9ceeca1 340 {
arve0 3:fb735fb343de 341 // Wait for the conversion to complete
arve0 3:fb735fb343de 342 wait_ms(m_conversionDelay);
arve0 0:8174d9ceeca1 343
arve0 3:fb735fb343de 344 // Read the conversion results
arve0 3:fb735fb343de 345 uint16_t res = readRegister(m_i2cAddress, ADS1015_REG_POINTER_CONVERT) >> m_bitShift;
arve0 3:fb735fb343de 346 if (m_bitShift == 0) {
arve0 3:fb735fb343de 347 return (int16_t)res;
arve0 3:fb735fb343de 348 } else {
arve0 3:fb735fb343de 349 // Shift 12-bit results right 4 bits for the ADS1015,
arve0 3:fb735fb343de 350 // making sure we keep the sign bit intact
arve0 3:fb735fb343de 351 if (res > 0x07FF) {
arve0 3:fb735fb343de 352 // negative number - extend the sign to 16th bit
arve0 3:fb735fb343de 353 res |= 0xF000;
arve0 3:fb735fb343de 354 }
arve0 3:fb735fb343de 355 return (int16_t)res;
arve0 0:8174d9ceeca1 356 }
arve0 3:fb735fb343de 357 }