summaryrefslogtreecommitdiffstats
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/ADS1115_WE.cpp326
-rw-r--r--src/ADS1115_WE.h374
2 files changed, 397 insertions, 303 deletions
diff --git a/src/ADS1115_WE.cpp b/src/ADS1115_WE.cpp
index e771f08..d9547ad 100644
--- a/src/ADS1115_WE.cpp
+++ b/src/ADS1115_WE.cpp
@@ -17,193 +17,271 @@
#include "ADS1115_WE.h"
ADS1115_WE::ADS1115_WE(int addr){
- i2cAddress = addr;
+ i2cAddress = addr;
}
ADS1115_WE::ADS1115_WE(){
- i2cAddress = 0x48;
+ i2cAddress = 0x48;
}
void ADS1115_WE::reset(){
- Wire.beginTransmission(0);
- Wire.write(0x06);
- Wire.endTransmission();
+ Wire.beginTransmission(0);
+ Wire.write(0x06);
+ Wire.endTransmission();
}
-bool ADS1115_WE::init(){
- Wire.beginTransmission(i2cAddress);
- uint8_t success = Wire.endTransmission();
- if(success){
- return 0;
- }
- writeRegister(ADS1115_CONFIG_REG, ADS1115_REG_RESET_VAL);
- setVoltageRange_mV(ADS1115_RANGE_2048);
- writeRegister(ADS1115_LO_THRESH_REG, 0x8000);
- writeRegister(ADS1115_HI_THRESH_REG, 0x7FFF);
- return 1;
+bool ADS1115_WE::init(){
+ Wire.beginTransmission(i2cAddress);
+ uint8_t success = Wire.endTransmission();
+ if(success){
+ return 0;
+ }
+ writeRegister(ADS1115_CONFIG_REG, ADS1115_REG_RESET_VAL);
+ setVoltageRange_mV(ADS1115_RANGE_2048);
+ writeRegister(ADS1115_LO_THRESH_REG, 0x8000);
+ writeRegister(ADS1115_HI_THRESH_REG, 0x7FFF);
+ deviceMeasureMode = ADS1115_SINGLE;
+ return 1;
}
void ADS1115_WE::setAlertPinMode(ADS1115_COMP_QUE mode){
- uint16_t currentConfReg = readRegister(ADS1115_CONFIG_REG);
- currentConfReg &= ~(0x0003);
- currentConfReg |= mode;
- writeRegister(ADS1115_CONFIG_REG, currentConfReg);
+ uint16_t currentConfReg = readRegister(ADS1115_CONFIG_REG);
+ currentConfReg &= ~(0x0003);
+ currentConfReg |= mode;
+ writeRegister(ADS1115_CONFIG_REG, currentConfReg);
}
void ADS1115_WE::setAlertLatch(ADS1115_LATCH latch){
- uint16_t currentConfReg = readRegister(ADS1115_CONFIG_REG);
- currentConfReg &= ~(0x0004);
- currentConfReg |= latch;
- writeRegister(ADS1115_CONFIG_REG, currentConfReg);
+ uint16_t currentConfReg = readRegister(ADS1115_CONFIG_REG);
+ currentConfReg &= ~(0x0004);
+ currentConfReg |= latch;
+ writeRegister(ADS1115_CONFIG_REG, currentConfReg);
}
void ADS1115_WE::setAlertPol(ADS1115_ALERT_POL polarity){
- uint16_t currentConfReg = readRegister(ADS1115_CONFIG_REG);
- currentConfReg &= ~(0x0008);
- currentConfReg |= polarity;
- writeRegister(ADS1115_CONFIG_REG, currentConfReg);
+ uint16_t currentConfReg = readRegister(ADS1115_CONFIG_REG);
+ currentConfReg &= ~(0x0008);
+ currentConfReg |= polarity;
+ writeRegister(ADS1115_CONFIG_REG, currentConfReg);
}
void ADS1115_WE::setAlertModeAndLimit_V(ADS1115_COMP_MODE mode, float hiThres, float loThres){
- uint16_t currentConfReg = readRegister(ADS1115_CONFIG_REG);
- currentConfReg &= ~(0x0010);
- currentConfReg |= mode;
- writeRegister(ADS1115_CONFIG_REG, currentConfReg);
- int16_t alertLimit = calcLimit(hiThres);
- writeRegister(ADS1115_HI_THRESH_REG, alertLimit);
- alertLimit = calcLimit(loThres);
- writeRegister(ADS1115_LO_THRESH_REG, alertLimit);
-
+ uint16_t currentConfReg = readRegister(ADS1115_CONFIG_REG);
+ currentConfReg &= ~(0x0010);
+ currentConfReg |= mode;
+ writeRegister(ADS1115_CONFIG_REG, currentConfReg);
+ int16_t alertLimit = calcLimit(hiThres);
+ writeRegister(ADS1115_HI_THRESH_REG, alertLimit);
+ alertLimit = calcLimit(loThres);
+ writeRegister(ADS1115_LO_THRESH_REG, alertLimit);
+
}
void ADS1115_WE::setConvRate(ADS1115_CONV_RATE rate){
- uint16_t currentConfReg = readRegister(ADS1115_CONFIG_REG);
- currentConfReg &= ~(0x00E0);
- currentConfReg |= rate;
- writeRegister(ADS1115_CONFIG_REG, currentConfReg);
+ uint16_t currentConfReg = readRegister(ADS1115_CONFIG_REG);
+ currentConfReg &= ~(0x00E0);
+ currentConfReg |= rate;
+ writeRegister(ADS1115_CONFIG_REG, currentConfReg);
}
-
+
+convRate ADS1115_WE::getConvRate(){
+ uint16_t currentConfReg = readRegister(ADS1115_CONFIG_REG);
+ return (convRate)(currentConfReg & 0xE0);
+}
+
void ADS1115_WE::setMeasureMode(ADS1115_MEASURE_MODE mode){
- uint16_t currentConfReg = readRegister(ADS1115_CONFIG_REG);
- currentConfReg &= ~(0x0100);
- currentConfReg |= mode;
- writeRegister(ADS1115_CONFIG_REG, currentConfReg);
+ uint16_t currentConfReg = readRegister(ADS1115_CONFIG_REG);
+ deviceMeasureMode = mode;
+ currentConfReg &= ~(0x0100);
+ currentConfReg |= mode;
+ writeRegister(ADS1115_CONFIG_REG, currentConfReg);
}
void ADS1115_WE::setVoltageRange_mV(ADS1115_RANGE range){
- uint16_t currentVoltageRange = voltageRange;
- uint16_t currentConfReg = readRegister(ADS1115_CONFIG_REG);
- uint16_t currentRange = (currentConfReg >> 9) & 7;
- uint16_t currentAlertPinMode = currentConfReg & 3;
-
- setMeasureMode(ADS1115_SINGLE);
-
- switch(range){
- case ADS1115_RANGE_6144:
- voltageRange = 6144;
- break;
- case ADS1115_RANGE_4096:
- voltageRange = 4096;
- break;
- case ADS1115_RANGE_2048:
- voltageRange = 2048;
- break;
- case ADS1115_RANGE_1024:
- voltageRange = 1024;
- break;
- case ADS1115_RANGE_0512:
- voltageRange = 512;
- break;
- case ADS1115_RANGE_0256:
- voltageRange = 256;
- break;
- }
-
- if ((currentRange != range) && (currentAlertPinMode != ADS1115_DISABLE_ALERT)){
- int16_t alertLimit = readRegister(ADS1115_HI_THRESH_REG);
- alertLimit = alertLimit * (currentVoltageRange * 1.0 / voltageRange);
- writeRegister(ADS1115_HI_THRESH_REG, alertLimit);
-
- alertLimit = readRegister(ADS1115_LO_THRESH_REG);
- alertLimit = alertLimit * (currentVoltageRange * 1.0 / voltageRange);
- writeRegister(ADS1115_LO_THRESH_REG, alertLimit);
- }
-
- currentConfReg &= ~(0x0E00);
- currentConfReg |= range;
- writeRegister(ADS1115_CONFIG_REG, currentConfReg);
+ uint16_t currentVoltageRange = voltageRange;
+ uint16_t currentConfReg = readRegister(ADS1115_CONFIG_REG);
+ uint16_t currentRange = (currentConfReg >> 9) & 7;
+ uint16_t currentAlertPinMode = currentConfReg & 3;
+
+ setMeasureMode(ADS1115_SINGLE);
+
+ switch(range){
+ case ADS1115_RANGE_6144:
+ voltageRange = 6144;
+ break;
+ case ADS1115_RANGE_4096:
+ voltageRange = 4096;
+ break;
+ case ADS1115_RANGE_2048:
+ voltageRange = 2048;
+ break;
+ case ADS1115_RANGE_1024:
+ voltageRange = 1024;
+ break;
+ case ADS1115_RANGE_0512:
+ voltageRange = 512;
+ break;
+ case ADS1115_RANGE_0256:
+ voltageRange = 256;
+ break;
+ }
+
+ if ((currentRange != range) && (currentAlertPinMode != ADS1115_DISABLE_ALERT)){
+ int16_t alertLimit = readRegister(ADS1115_HI_THRESH_REG);
+ alertLimit = alertLimit * (currentVoltageRange * 1.0 / voltageRange);
+ writeRegister(ADS1115_HI_THRESH_REG, alertLimit);
+
+ alertLimit = readRegister(ADS1115_LO_THRESH_REG);
+ alertLimit = alertLimit * (currentVoltageRange * 1.0 / voltageRange);
+ writeRegister(ADS1115_LO_THRESH_REG, alertLimit);
+ }
+
+ currentConfReg &= ~(0x0E00);
+ currentConfReg |= range;
+ writeRegister(ADS1115_CONFIG_REG, currentConfReg);
+}
+
+void ADS1115_WE::setAutoRange(){
+ uint16_t currentConfReg = readRegister(ADS1115_CONFIG_REG);
+ convRate rate = getConvRate();
+ setVoltageRange_mV(ADS1115_RANGE_6144);
+ delayAccToRate(rate);
+
+ if(deviceMeasureMode == ADS1115_SINGLE){
+ setMeasureMode(ADS1115_CONTINUOUS);
+ delayAccToRate(rate);
+ }
+
+ float result = abs(getResult_mV());
+ range optRange = ADS1115_RANGE_6144;
+
+ if(result < 205.0){
+ optRange = ADS1115_RANGE_0256;
+ }
+ else if(result < 410.0){
+ optRange = ADS1115_RANGE_0512;
+ }
+ else if(result < 820.0){
+ optRange = ADS1115_RANGE_1024;
+ }
+ else if(result < 1640.0){
+ optRange = ADS1115_RANGE_2048;
+ }
+ else if(result < 3280.0){
+ optRange = ADS1115_RANGE_4096;
+ }
+
+ writeRegister(ADS1115_CONFIG_REG, currentConfReg);
+ setVoltageRange_mV(optRange);
+ delayAccToRate(rate);
+}
+
+void ADS1115_WE::delayAccToRate(convRate cr){
+ switch(cr){
+ case ADS1115_8_SPS:
+ delay(130);
+ break;
+ case ADS1115_16_SPS:
+ delay(65);
+ break;
+ case ADS1115_32_SPS:
+ delay(32);
+ break;
+ case ADS1115_64_SPS:
+ delay(16);
+ break;
+ case ADS1115_128_SPS:
+ delay(8);
+ break;
+ case ADS1115_250_SPS:
+ delay(4);
+ break;
+ case ADS1115_475_SPS:
+ delay(3);
+ break;
+ case ADS1115_860_SPS:
+ delay(2);
+ break;
+ }
}
+
void ADS1115_WE::setCompareChannels(ADS1115_MUX mux){
- uint16_t currentConfReg = readRegister(ADS1115_CONFIG_REG);
- currentConfReg &= ~(0x7000);
- currentConfReg |= (mux);
- writeRegister(ADS1115_CONFIG_REG, currentConfReg);
+ uint16_t currentConfReg = readRegister(ADS1115_CONFIG_REG);
+ currentConfReg &= ~(0x7000);
+ currentConfReg |= (mux);
+ writeRegister(ADS1115_CONFIG_REG, currentConfReg);
+
+ if(!(currentConfReg & 0x0100)){ // => if not single shot mode
+ convRate rate = getConvRate();
+ delayAccToRate(rate);
+ delayAccToRate(rate);
+ }
}
-
+
bool ADS1115_WE::isBusy(){
- uint16_t currentConfReg = readRegister(ADS1115_CONFIG_REG);
- return (!(currentConfReg>>15) & 1);
+ uint16_t currentConfReg = readRegister(ADS1115_CONFIG_REG);
+ return (!(currentConfReg>>15) & 1);
}
-
+
void ADS1115_WE::startSingleMeasurement(){
- uint16_t currentConfReg = readRegister(ADS1115_CONFIG_REG);
- currentConfReg |= (1 << 15);
- writeRegister(ADS1115_CONFIG_REG, currentConfReg);
+ uint16_t currentConfReg = readRegister(ADS1115_CONFIG_REG);
+ currentConfReg |= (1 << 15);
+ writeRegister(ADS1115_CONFIG_REG, currentConfReg);
}
-
+
float ADS1115_WE::getResult_V(){
- int16_t rawResult = readRegister(ADS1115_CONV_REG);
- float result = (rawResult * 1.0 / ADS1115_REG_FACTOR) * voltageRange/1000;
- return result;
+ int16_t rawResult = readRegister(ADS1115_CONV_REG);
+ float result = (rawResult * 1.0 / ADS1115_REG_FACTOR) * voltageRange/1000;
+ return result;
}
float ADS1115_WE::getResult_mV(){
- int16_t rawResult = readRegister(ADS1115_CONV_REG);
- float result = (rawResult * 1.0 / ADS1115_REG_FACTOR) * voltageRange;
- return result;
+ int16_t rawResult = readRegister(ADS1115_CONV_REG);
+ float result = (rawResult * 1.0 / ADS1115_REG_FACTOR) * voltageRange;
+ return result;
}
int16_t ADS1115_WE::getRawResult(){
- int16_t rawResult = readRegister(ADS1115_CONV_REG);
- return rawResult;
+ int16_t rawResult = readRegister(ADS1115_CONV_REG);
+ return rawResult;
}
int16_t ADS1115_WE::getResultWithRange(int16_t min, int16_t max){
- int16_t rawResult = readRegister(ADS1115_CONV_REG);
- int16_t result = 0;
- result = map(rawResult, -32767, 32767, min, max);
- return result;
+ int16_t rawResult = readRegister(ADS1115_CONV_REG);
+ int16_t result = 0;
+ result = map(rawResult, -32767, 32767, min, max);
+ return result;
}
int16_t ADS1115_WE::getResultWithRange(int16_t min, int16_t max, int16_t maxMillivolt){
- int16_t rawResult = readRegister(ADS1115_CONV_REG);
- int16_t result = 0;
- result = map(rawResult, -32767, 32767, min, max);
- result = (int16_t) ((1.0 * result * voltageRange / maxMillivolt) + 0.5);
- return result;
+ int16_t rawResult = readRegister(ADS1115_CONV_REG);
+ int16_t result = 0;
+ result = map(rawResult, -32767, 32767, min, max);
+ result = (int16_t) ((1.0 * result * voltageRange / maxMillivolt) + 0.5);
+ return result;
}
uint16_t ADS1115_WE::getVoltageRange_mV(){
- return voltageRange;
+ return voltageRange;
}
void ADS1115_WE::setAlertPinToConversionReady(){
- writeRegister(ADS1115_LO_THRESH_REG, (0<<15));
- writeRegister(ADS1115_HI_THRESH_REG, (1<<15));
+ writeRegister(ADS1115_LO_THRESH_REG, (0<<15));
+ writeRegister(ADS1115_HI_THRESH_REG, (1<<15));
}
void ADS1115_WE::clearAlert(){
- readRegister(ADS1115_CONV_REG);
+ readRegister(ADS1115_CONV_REG);
}
/************************************************
- private functions
+ private functions
*************************************************/
int16_t ADS1115_WE::calcLimit(float rawLimit){
- int16_t limit = (int16_t)((rawLimit * ADS1115_REG_FACTOR / voltageRange)*1000);
- return limit;
+ int16_t limit = (int16_t)((rawLimit * ADS1115_REG_FACTOR / voltageRange)*1000);
+ return limit;
}
uint8_t ADS1115_WE::writeRegister(uint8_t reg, uint16_t val){
@@ -230,6 +308,6 @@ uint16_t ADS1115_WE::readRegister(uint8_t reg){
regValue = (MSByte<<8) + LSByte;
return regValue;
}
-
+
diff --git a/src/ADS1115_WE.h b/src/ADS1115_WE.h
index 7fcd4ba..6d68123 100644
--- a/src/ADS1115_WE.h
+++ b/src/ADS1115_WE.h
@@ -28,224 +28,240 @@
#include <Wire.h>
/* registers */
-#define ADS1115_CONV_REG 0x00 // Conversion Register
-#define ADS1115_CONFIG_REG 0x01 // Configuration Register
-#define ADS1115_LO_THRESH_REG 0x02 // Low Threshold Register
-#define ADS1115_HI_THRESH_REG 0x03 // High Threshold Register
+#define ADS1115_CONV_REG 0x00 // Conversion Register
+#define ADS1115_CONFIG_REG 0x01 // Configuration Register
+#define ADS1115_LO_THRESH_REG 0x02 // Low Threshold Register
+#define ADS1115_HI_THRESH_REG 0x03 // High Threshold Register
/* other */
#define ADS1115_REG_FACTOR 32768
#define ADS1115_REG_RESET_VAL 0x8583
typedef enum ADS1115_COMP_QUE {
- ADS1115_ASSERT_AFTER_1 = 0x0000,
- ADS1115_ASSERT_AFTER_2 = 0x0001,
- ADS1115_ASSERT_AFTER_4 = 0x0002,
- ADS1115_DISABLE_ALERT = 0x0003
+ ADS1115_ASSERT_AFTER_1 = 0x0000,
+ ADS1115_ASSERT_AFTER_2 = 0x0001,
+ ADS1115_ASSERT_AFTER_4 = 0x0002,
+ ADS1115_DISABLE_ALERT = 0x0003
} compQue;
typedef enum ADS1115_LATCH {
- ADS1115_LATCH_DISABLED = 0x0000,
- ADS1115_LATCH_ENABLED = 0x0004,
+ ADS1115_LATCH_DISABLED = 0x0000,
+ ADS1115_LATCH_ENABLED = 0x0004,
} latch;
typedef enum ADS1115_ALERT_POL {
- ADS1115_ACT_LOW = 0x0000,
- ADS1115_ACT_HIGH = 0x0008
+ ADS1115_ACT_LOW = 0x0000,
+ ADS1115_ACT_HIGH = 0x0008
} alertPol;
typedef enum ADS1115_COMP_MODE{
- ADS1115_MAX_LIMIT = 0x0000,
- ADS1115_WINDOW = 0x0010
+ ADS1115_MAX_LIMIT = 0x0000,
+ ADS1115_WINDOW = 0x0010
} compMode;
typedef enum ADS1115_CONV_RATE{
- ADS1115_8_SPS = 0x0000,
- ADS1115_16_SPS = 0x0020,
- ADS1115_32_SPS = 0x0040,
- ADS1115_64_SPS = 0x0050,
- ADS1115_128_SPS = 0x0080,
- ADS1115_250_SPS = 0x00A0,
- ADS1115_475_SPS = 0x00C0,
- ADS1115_860_SPS = 0x00E0
+ ADS1115_8_SPS = 0x0000,
+ ADS1115_16_SPS = 0x0020,
+ ADS1115_32_SPS = 0x0040,
+ ADS1115_64_SPS = 0x0060,
+ ADS1115_128_SPS = 0x0080,
+ ADS1115_250_SPS = 0x00A0,
+ ADS1115_475_SPS = 0x00C0,
+ ADS1115_860_SPS = 0x00E0
} convRate;
typedef enum ADS1115_MEASURE_MODE{
- ADS1115_CONTINOUS = 0x0000, // keeping misspelled enum for backwards compatibility.
- ADS1115_CONTINUOUS = 0x0000,
- ADS1115_SINGLE = 0x0100
+ ADS1115_CONTINOUS = 0x0000, // keeping misspelled enum for backwards compatibility.
+ ADS1115_CONTINUOUS = 0x0000,
+ ADS1115_SINGLE = 0x0100
} measureMode;
typedef enum ADS1115_RANGE{
- ADS1115_RANGE_6144 = 0x0000,
- ADS1115_RANGE_4096 = 0x0200,
- ADS1115_RANGE_2048 = 0x0400,
- ADS1115_RANGE_1024 = 0x0600,
- ADS1115_RANGE_0512 = 0x0800,
- ADS1115_RANGE_0256 = 0x0A00,
+ ADS1115_RANGE_6144 = 0x0000,
+ ADS1115_RANGE_4096 = 0x0200,
+ ADS1115_RANGE_2048 = 0x0400,
+ ADS1115_RANGE_1024 = 0x0600,
+ ADS1115_RANGE_0512 = 0x0800,
+ ADS1115_RANGE_0256 = 0x0A00,
} range;
typedef enum ADS1115_MUX{
- ADS1115_COMP_0_1 = 0x0000,
- ADS1115_COMP_0_3 = 0x1000,
- ADS1115_COMP_1_3 = 0x2000,
- ADS1115_COMP_2_3 = 0x3000,
- ADS1115_COMP_0_GND = 0x4000,
- ADS1115_COMP_1_GND = 0x5000,
- ADS1115_COMP_2_GND = 0x6000,
- ADS1115_COMP_3_GND = 0x7000
+ ADS1115_COMP_0_1 = 0x0000,
+ ADS1115_COMP_0_3 = 0x1000,
+ ADS1115_COMP_1_3 = 0x2000,
+ ADS1115_COMP_2_3 = 0x3000,
+ ADS1115_COMP_0_GND = 0x4000,
+ ADS1115_COMP_1_GND = 0x5000,
+ ADS1115_COMP_2_GND = 0x6000,
+ ADS1115_COMP_3_GND = 0x7000
} mux;
typedef enum ADS1115_STATUS_OR_START{
- ADS1115_BUSY = 0x0000,
- ADS1115_START_ISREADY = 0x8000
+ ADS1115_BUSY = 0x0000,
+ ADS1115_START_ISREADY = 0x8000
} statusOrStart;
class ADS1115_WE
{
public:
- ADS1115_WE(int addr);
- ADS1115_WE(); // uses default I2C Address 0x48
-
- void reset();
- bool init();
-
- /* Set number of conversions after which the alert pin will be active
- * - or you can disable the alert
- *
- * ADS1115_ASSERT_AFTER_1 -> after 1 conversion
- * ADS1115_ASSERT_AFTER_2 -> after 2 conversions
- * ADS1115_ASSERT_AFTER_4 -> after 4 conversions
- * ADS1115_DISABLE_ALERT -> disable comparator // alert pin (default)
- */
- void setAlertPinMode(ADS1115_COMP_QUE mode);
-
- /* Enable or disable latch. If latch is enabled the alarm pin will be active until the
- * conversion register is read (getResult functions). If disabled the alarm pin will be
- * deactivated with next value within limits.
- *
- * ADS1115_LATCH_DISABLED (default)
- * ADS1115_LATCH_ENABLED
- */
- void setAlertLatch(ADS1115_LATCH latch);
-
- /* Sets the alert pin polarity if active:
- *
- * Enable or disable latch. If latch is enabled the alarm pin will be active until the
- * conversion register is read (getResult functions). If disabled the alarm pin will be
- * deactivated with next value within limits.
- *
- * ADS1115_ACT_LOW -> active low (default)
- * ADS1115_ACT_HIGH -> active high
- */
- void setAlertPol(ADS1115_ALERT_POL polarity);
-
- /* Choose maximum limit or maximum and minimum alert limit (window)in Volt - alert pin will
- * be active when measured values are beyond the maximum limit or outside the window
- * Upper limit first: setAlertLimit_V(MODE, maximum, minimum)
- * In max limit mode the minimum value is the limit where the alert pin will be deactivated (if
- * not latched)
- *
- * ADS1115_MAX_LIMIT
- * ADS1115_WINDOW
- */
- void setAlertModeAndLimit_V(ADS1115_COMP_MODE mode, float hithres, float lothres);
-
- /* Set the conversion rate in SPS (samples per second)
- * Options should be self-explaining:
- *
- * ADS1115_8_SPS
- * ADS1115_16_SPS
- * ADS1115_32_SPS
- * ADS1115_64_SPS
- * ADS1115_128_SPS (default)
- * ADS1115_250_SPS
- * ADS1115_475_SPS
- * ADS1115_860_SPS
- */
- void setConvRate(ADS1115_CONV_RATE rate);
-
- /* Set continuous or single shot mode:
- *
- * ADS1115_CONTINUOUS -> continuous mode
- * ADS1115_SINGLE -> single shot mode (default)
- */
- void setMeasureMode(ADS1115_MEASURE_MODE mode);
-
- /* Set the voltage range of the ADC to adjust the gain:
- * Please note that you must not apply more than VDD + 0.3V to the input pins!
- *
- * ADS1115_RANGE_6144 -> +/- 6144 mV
- * ADS1115_RANGE_4096 -> +/- 4096 mV
- * ADS1115_RANGE_2048 -> +/- 2048 mV (default)
- * ADS1115_RANGE_1024 -> +/- 1024 mV
- * ADS1115_RANGE_0512 -> +/- 512 mV
- * ADS1115_RANGE_0256 -> +/- 256 mV
- */
- void setVoltageRange_mV(ADS1115_RANGE range);
-
- /* Set the inputs to be compared
- *
- * ADS1115_COMP_0_1 -> compares 0 with 1 (default)
- * ADS1115_COMP_0_3 -> compares 0 with 3
- * ADS1115_COMP_1_3 -> compares 1 with 3
- * ADS1115_COMP_2_3 -> compares 2 with 3
- * ADS1115_COMP_0_GND -> compares 0 with GND
- * ADS1115_COMP_1_GND -> compares 1 with GND
- * ADS1115_COMP_2_GND -> compares 2 with GND
- * ADS1115_COMP_3_GND -> compares 3 with GND
- */
- void setCompareChannels(ADS1115_MUX mux);
-
- bool isBusy();
- void startSingleMeasurement();
- float getResult_V();
- float getResult_mV();
-
- /* Get the raw result from the conversion register:
- * The conversion register contains the conversion result of the amplified (!)
- * voltage. This means the value depends on the voltage as well as on the
- * voltage range. E.g. if the voltage range is 6.144 mV (ADS1115_RANGE_6144),
- * +32767 is 6.144 mV; if the range is 4.096 mV, +32767 is 4.096 mV, and so on.
- */
- int16_t getRawResult();
-
- /* Scaling of the result to a different range:
- * The results in the conversion register are in a range of -32767 to +32767
- * You might want to receive the result in a different scale, e.g. -1023 to 1023.
- * For -1023 to 1023, and if you have chosen e.g. ADS1115_RANGE_4096, 0 Volt would
- * give 0 as result and 4.096 mV would give 1023. -4.096 mV would give -1023.
- */
- int16_t getResultWithRange(int16_t min, int16_t max);
-
- /* Scaling of the result to a different range plus scaling to a voltage range:
- * You can use this variant if you also want to scale to a voltage range. E.g. in
- * in order to get results equivalent to an Arduino UNO (10 bit, 5000 mV range), you
- * would choose getResultWithRange(-1023, 1023, 5000). A difference to the Arduino
- * UNO is that you can measure negative voltages.
- * You have to ensure that the voltage range you scale to is smaller than the
- * measuring voltage range.
- */
- int16_t getResultWithRange(int16_t min, int16_t max, int16_t maxVoltage);
-
- /* This function returns the voltage range ADS1115_RANGE_XXXX in Millivolt */
- uint16_t getVoltageRange_mV();
-
- /* With this function the alert pin will be active, when a conversion is ready.
- * In order to deactivate, use the setAlertLimit_V function
- */
- void setAlertPinToConversionReady();
- void clearAlert();
+ ADS1115_WE(int addr);
+ ADS1115_WE(); // uses default I2C Address 0x48
+
+ void reset();
+ bool init();
+
+ /* Set number of conversions after which the alert pin will be active
+ * - or you can disable the alert
+ *
+ * ADS1115_ASSERT_AFTER_1 -> after 1 conversion
+ * ADS1115_ASSERT_AFTER_2 -> after 2 conversions
+ * ADS1115_ASSERT_AFTER_4 -> after 4 conversions
+ * ADS1115_DISABLE_ALERT -> disable comparator // alert pin (default)
+ */
+ void setAlertPinMode(ADS1115_COMP_QUE mode);
+
+ /* Enable or disable latch. If latch is enabled the alarm pin will be active until the
+ * conversion register is read (getResult functions). If disabled the alarm pin will be
+ * deactivated with next value within limits.
+ *
+ * ADS1115_LATCH_DISABLED (default)
+ * ADS1115_LATCH_ENABLED
+ */
+ void setAlertLatch(ADS1115_LATCH latch);
+
+ /* Sets the alert pin polarity if active:
+ *
+ * Enable or disable latch. If latch is enabled the alarm pin will be active until the
+ * conversion register is read (getResult functions). If disabled the alarm pin will be
+ * deactivated with next value within limits.
+ *
+ * ADS1115_ACT_LOW -> active low (default)
+ * ADS1115_ACT_HIGH -> active high
+ */
+ void setAlertPol(ADS1115_ALERT_POL polarity);
+
+ /* Choose maximum limit or maximum and minimum alert limit (window)in Volt - alert pin will
+ * be active when measured values are beyond the maximum limit or outside the window
+ * Upper limit first: setAlertLimit_V(MODE, maximum, minimum)
+ * In max limit mode the minimum value is the limit where the alert pin will be deactivated (if
+ * not latched)
+ *
+ * ADS1115_MAX_LIMIT
+ * ADS1115_WINDOW
+ */
+ void setAlertModeAndLimit_V(ADS1115_COMP_MODE mode, float hithres, float lothres);
+
+ /* Set the conversion rate in SPS (samples per second)
+ * Options should be self-explaining:
+ *
+ * ADS1115_8_SPS
+ * ADS1115_16_SPS
+ * ADS1115_32_SPS
+ * ADS1115_64_SPS
+ * ADS1115_128_SPS (default)
+ * ADS1115_250_SPS
+ * ADS1115_475_SPS
+ * ADS1115_860_SPS
+ */
+ void setConvRate(ADS1115_CONV_RATE rate);
+
+ /* returns the conversion rate */
+ convRate getConvRate();
+
+ /* Set continuous or single shot mode:
+ *
+ * ADS1115_CONTINUOUS -> continuous mode
+ * ADS1115_SINGLE -> single shot mode (default)
+ */
+ void setMeasureMode(ADS1115_MEASURE_MODE mode);
+
+ /* Set the voltage range of the ADC to adjust the gain:
+ * Please note that you must not apply more than VDD + 0.3V to the input pins!
+ *
+ * ADS1115_RANGE_6144 -> +/- 6144 mV
+ * ADS1115_RANGE_4096 -> +/- 4096 mV
+ * ADS1115_RANGE_2048 -> +/- 2048 mV (default)
+ * ADS1115_RANGE_1024 -> +/- 1024 mV
+ * ADS1115_RANGE_0512 -> +/- 512 mV
+ * ADS1115_RANGE_0256 -> +/- 256 mV
+ */
+ void setVoltageRange_mV(ADS1115_RANGE range);
+
+ /* Set the voltage range automatically
+ * 1) changes into maximum range and continuous mode
+ * 2) measures the voltage
+ * 3) chooses the smallest range in which the measured voltage is <80%
+ * of the range's maximum
+ * 4) switches back to single shot mode if it was in this mode before
+ *
+ * Please be aware that the procedure takes the the time needed for several conversions.
+ * You should ony use it in case you expect stable or slowly changing voltages.
+ */
+ void setAutoRange();
+
+ /* Set the inputs to be compared
+ *
+ * ADS1115_COMP_0_1 -> compares 0 with 1 (default)
+ * ADS1115_COMP_0_3 -> compares 0 with 3
+ * ADS1115_COMP_1_3 -> compares 1 with 3
+ * ADS1115_COMP_2_3 -> compares 2 with 3
+ * ADS1115_COMP_0_GND -> compares 0 with GND
+ * ADS1115_COMP_1_GND -> compares 1 with GND
+ * ADS1115_COMP_2_GND -> compares 2 with GND
+ * ADS1115_COMP_3_GND -> compares 3 with GND
+ */
+ void setCompareChannels(ADS1115_MUX mux);
+
+ bool isBusy();
+ void startSingleMeasurement();
+ float getResult_V();
+ float getResult_mV();
+
+ /* Get the raw result from the conversion register:
+ * The conversion register contains the conversion result of the amplified (!)
+ * voltage. This means the value depends on the voltage as well as on the
+ * voltage range. E.g. if the voltage range is 6.144 mV (ADS1115_RANGE_6144),
+ * +32767 is 6.144 mV; if the range is 4.096 mV, +32767 is 4.096 mV, and so on.
+ */
+ int16_t getRawResult();
+
+ /* Scaling of the result to a different range:
+ * The results in the conversion register are in a range of -32767 to +32767
+ * You might want to receive the result in a different scale, e.g. -1023 to 1023.
+ * For -1023 to 1023, and if you have chosen e.g. ADS1115_RANGE_4096, 0 Volt would
+ * give 0 as result and 4.096 mV would give 1023. -4.096 mV would give -1023.
+ */
+ int16_t getResultWithRange(int16_t min, int16_t max);
+
+ /* Scaling of the result to a different range plus scaling to a voltage range:
+ * You can use this variant if you also want to scale to a voltage range. E.g. in
+ * in order to get results equivalent to an Arduino UNO (10 bit, 5000 mV range), you
+ * would choose getResultWithRange(-1023, 1023, 5000). A difference to the Arduino
+ * UNO is that you can measure negative voltages.
+ * You have to ensure that the voltage range you scale to is smaller than the
+ * measuring voltage range.
+ */
+ int16_t getResultWithRange(int16_t min, int16_t max, int16_t maxVoltage);
+
+ /* This function returns the voltage range ADS1115_RANGE_XXXX in Millivolt */
+ uint16_t getVoltageRange_mV();
+
+ /* With this function the alert pin will be active, when a conversion is ready.
+ * In order to deactivate, use the setAlertLimit_V function
+ */
+ void setAlertPinToConversionReady();
+ void clearAlert();
private:
- uint16_t voltageRange;
- ADS1115_MEASURE_MODE deviceMeasureMode;
- int i2cAddress;
- int16_t calcLimit(float rawLimit);
- uint8_t writeRegister(uint8_t reg, uint16_t val);
- uint16_t readRegister(uint8_t reg);
+ uint16_t voltageRange;
+ ADS1115_MEASURE_MODE deviceMeasureMode;
+ int i2cAddress;
+ void delayAccToRate(convRate cr);
+ int16_t calcLimit(float rawLimit);
+ uint8_t writeRegister(uint8_t reg, uint16_t val);
+ uint16_t readRegister(uint8_t reg);
};