/****************************************************************************** * * 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/en/ads1115-a-d-converter-with-amplifier (English) * https://wolles-elektronikkiste.de/ads1115 (German) * * ******************************************************************************/ #ifndef ADS1115_WE_H_ #define ADS1115_WE_H_ #if (ARDUINO >= 100) #include "Arduino.h" #else #include "WProgram.h" #endif #include "ADS1115_config.h" #ifdef USE_TINY_WIRE_M_ #include #endif #ifndef USE_TINY_WIRE_M_ #include #endif typedef enum ADS1115_COMP_QUE { 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, } 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 = 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 } 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; #define ADS1115_COMP_INC 0x1000 // increment to next channel typedef enum ADS1115_STATUS_OR_START{ ADS1115_BUSY = 0x0000, ADS1115_START_ISREADY = 0x8000 } statusOrStart; class ADS1115_WE { public: /* registers */ static constexpr uint8_t ADS1115_CONV_REG {0x00}; // Conversion Register static constexpr uint8_t ADS1115_CONFIG_REG {0x01}; // Configuration Register static constexpr uint8_t ADS1115_LO_THRESH_REG {0x02}; // Low Threshold Register static constexpr uint8_t ADS1115_HI_THRESH_REG {0x03}; // High Threshold Register /* other */ static constexpr uint16_t ADS1115_REG_FACTOR {32768}; static constexpr uint16_t ADS1115_REG_RESET_VAL {0x8583}; #ifndef USE_TINY_WIRE_M_ ADS1115_WE(const uint8_t addr = 0x48) : _wire{&Wire}, i2cAddress{addr} {} ADS1115_WE(TwoWire *w, const uint8_t addr = 0x48) : _wire{w}, i2cAddress{addr} {} #else ADS1115_WE(const uint8_t addr = 0x48) : i2cAddress{addr} {} #endif 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 automatic voltage range permanantly, but the range will only be changed if the * measured value is outside 30 - 80% of the maximum value of the current range. * Therefore this method is faster than setAutoRange(). */ void setPermanentAutoRangeMode(bool autoMode); /* 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); /* Set to channel (0-3) in single ended mode */ void setSingleChannel(size_t channel); 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 6144 mV (ADS1115_RANGE_6144), * +32767 is 6144 mV; if the range is 4096 mV, +32767 is 4096 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 4096 mV would give 1023. -4096 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(); bool skip_delays; protected: #ifndef USE_TINY_WIRE_M_ TwoWire *_wire; #endif uint16_t voltageRange; ADS1115_MEASURE_MODE deviceMeasureMode; uint8_t i2cAddress; bool autoRangeMode; void delayAccToRate(convRate cr); int16_t calcLimit(float rawLimit); uint8_t writeRegister(uint8_t reg, uint16_t val); uint16_t readRegister(uint8_t reg); }; #endif