From 491d824f90534bdd84ca9cfb34aa66556784e75f Mon Sep 17 00:00:00 2001 From: "Wolfgang (Wolle) Ewald" Date: Sat, 27 Jun 2020 13:21:08 +0200 Subject: Add files via upload --- src/ADS1115_WE.cpp | 209 +++++++++++++++++++++++++++++++++++++++++++++++++++++ src/ADS1115_WE.h | 137 +++++++++++++++++++++++++++++++++++ 2 files changed, 346 insertions(+) create mode 100644 src/ADS1115_WE.cpp diff --git a/src/ADS1115_WE.cpp b/src/ADS1115_WE.cpp new file mode 100644 index 0000000..f1af282 --- /dev/null +++ b/src/ADS1115_WE.cpp @@ -0,0 +1,209 @@ +/***************************************** +* This is a library for the ADS1115 A/D Converter +* +* You'll find an example which should enable you to use the library. +* +* You are free to use it, change it or build on it. In case you like +* it, it would be cool if you give it a star. +* +* If you find bugs, please inform me! +* +* Written by Wolfgang (Wolle) Ewald +* https://wolles-elektronikkiste.de +* +*******************************************/ + +#include "ADS1115_WE.h" + +ADS1115_WE::ADS1115_WE(int addr){ + i2cAddress = addr; +} + +ADS1115_WE::ADS1115_WE(){ + i2cAddress = 0x48; +} + +void ADS1115_WE::reset(){ + Wire.beginTransmission(0); + Wire.write(0x06); + Wire.endTransmission(); +} + +bool ADS1115_WE::init(){ + Wire.beginTransmission(i2cAddress); + bool success = Wire.endTransmission(); + if(success){ + return 0; + } + writeRegister(ADS1115_CONFIG_REG, ADS1115_REG_RESET_VAL); + setVoltageRange_mV(ADS1115_RANGE_2048); + 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); +} + +void ADS1115_WE::setAlertLatch(ADS1115_LATCH latch){ + 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); +} + +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); + +} + +void ADS1115_WE::setConvRate(ADS1115_CONV_RATE rate){ + uint16_t currentConfReg = readRegister(ADS1115_CONFIG_REG); + currentConfReg &= ~(0x00E0); + currentConfReg |= rate; + writeRegister(ADS1115_CONFIG_REG, currentConfReg); +} + +void ADS1115_WE::setMeasureMode(ADS1115_MEASURE_MODE mode){ + uint16_t currentConfReg = readRegister(ADS1115_CONFIG_REG); + currentConfReg &= ~(0x0100); + currentConfReg |= mode; + writeRegister(ADS1115_CONFIG_REG, currentConfReg); +} + +void ADS1115_WE::setVoltageRange_mV(ADS1115_RANGE range){ + + 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; + } + + uint16_t currentConfReg = readRegister(ADS1115_CONFIG_REG); + uint16_t currentRange = (currentConfReg >> 9) & 7; + uint16_t currentAlertPinMode = currentConfReg & 3; + uint16_t currentCompMode = (currentConfReg>>4) & 1; + + if ((currentRange != range) && (currentAlertPinMode != ADS1115_DISABLE_ALERT)){ + int16_t alertLimit = readRegister(ADS1115_HI_THRESH_REG); + alertLimit = (alertLimit/currentRange) * range; + writeRegister(ADS1115_HI_THRESH_REG, alertLimit); + + if(currentCompMode != ADS1115_MAX_LIMIT){ + int16_t alertLimit = readRegister(ADS1115_LO_THRESH_REG); + alertLimit = (alertLimit/currentRange) * range; + writeRegister(ADS1115_LO_THRESH_REG, alertLimit); + } + } + + currentConfReg &= ~(0x0E00); + currentConfReg |= range; + writeRegister(ADS1115_CONFIG_REG, currentConfReg); +} + +void ADS1115_WE::setCompareChannels(ADS1115_MUX mux){ + uint16_t currentConfReg = readRegister(ADS1115_CONFIG_REG); + currentConfReg &= ~(0x7000); + currentConfReg |= (mux); + writeRegister(ADS1115_CONFIG_REG, currentConfReg); +} + +bool ADS1115_WE::isBusy(){ + 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); +} + +float ADS1115_WE::getResult_V(){ + 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; +} + +void ADS1115_WE::setAlertPinToConversionReady(){ + writeRegister(ADS1115_LO_THRESH_REG, (0<<15)); + writeRegister(ADS1115_HI_THRESH_REG, (1<<15)); +} + +void ADS1115_WE::unlatchAlertPin(){ + readRegister(ADS1115_CONV_REG); +} + +/************************************************ + private functions +*************************************************/ + +int16_t ADS1115_WE::calcLimit(float rawLimit){ + int16_t limit = (int16_t)((rawLimit * ADS1115_REG_FACTOR / voltageRange)*1000); + return limit; +} + +uint8_t ADS1115_WE::writeRegister(uint8_t reg, uint16_t val){ + Wire.beginTransmission(i2cAddress); + uint8_t lVal = val & 255; + uint8_t hVal = val >> 8; + Wire.write(reg); + Wire.write(hVal); + Wire.write(lVal); + return Wire.endTransmission(); +} + +uint16_t ADS1115_WE::readRegister(uint8_t reg){ + uint8_t MSByte, LSByte = 0; + uint16_t regValue = 0; + Wire.beginTransmission(i2cAddress); + Wire.write(reg); + Wire.endTransmission(); + Wire.requestFrom(i2cAddress,2); + if(Wire.available()){ + MSByte = Wire.read(); + LSByte = Wire.read(); + } + regValue = (MSByte<<8) + LSByte; + return regValue; +} + + + diff --git a/src/ADS1115_WE.h b/src/ADS1115_WE.h index 8b13789..4a671d4 100644 --- a/src/ADS1115_WE.h +++ b/src/ADS1115_WE.h @@ -1 +1,138 @@ +/****************************************************************************** + * + * This is a library for the ADS1115 A/D Converter + * + * You'll find several example sketches which should enable you to use the library. + * + * You are free to use it, change it or build on it. In case you like it, it would + * be cool if you give it a star. + * + * If you find bugs, please inform me! + * + * Written by Wolfgang (Wolle) Ewald + * https://wolles-elektronikkiste.de + * + * + ******************************************************************************/ + +#ifndef ADS1115_WE_H_ +#define ADS1115_WE_H_ + +#if (ARDUINO >= 100) + #include "Arduino.h" +#else + #include "WProgram.h" +#endif + +#include + +/* 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 + +/* 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_3 = 0x0002, + ADS1115_DISABLE_ALERT = 0x0003 +} compQue; + +typedef enum ADS1115_LATCH { + ADS1115_LATCH_DISABLED = 0x0000, + ADS1115_LATCH_ENABLED = 0x0004, +} latch; + +typedef enum ADS1115_ALERT_POL { + ADS1115_ACT_LOW = 0x0000, + ADS1115_ACT_HIGH = 0x0008 +} alertPol; + +typedef enum ADS1115_COMP_MODE{ + 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 +} convRate; + +typedef enum ADS1115_MEASURE_MODE{ + ADS1115_CONTINOUS = 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, +} 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 +} mux; + +typedef enum ADS1115_STATUS_OR_START{ + ADS1115_BUSY = 0x0000, + ADS1115_START_ISREADY = 0x8000 +} statusOrStart; + + +class ADS1115_WE +{ +public: + ADS1115_WE(int addr); + ADS1115_WE(); //sets default I2C Address 0x48 + + void reset(); + bool init(); + void setAlertPinMode(ADS1115_COMP_QUE mode); + void setAlertLatch(ADS1115_LATCH latch); + void setAlertPol(ADS1115_ALERT_POL polarity); + void setAlertModeAndLimit_V(ADS1115_COMP_MODE mode, float hithres, float lothres); + void setConvRate(ADS1115_CONV_RATE rate); + void setMeasureMode(ADS1115_MEASURE_MODE mode); + void setVoltageRange_mV(ADS1115_RANGE range); + void setCompareChannels(ADS1115_MUX mux); + bool isBusy(); + void startSingleMeasurement(); + float getResult_V(); + float getResult_mV(); + void setAlertPinToConversionReady(); + void unlatchAlertPin(); + + +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); + +}; + +#endif -- cgit v1.2.3