Here are a few reasons. The ADS1115<\/p>\n
- \n
- has a resolution of 16 bits compared to the 10 bits of the Arduino.<\/li>\n
- uses an internal amplifier so that it can measure even small voltages.<\/li>\n
- has an alert function that you can use to efficiently monitor voltages, because:
- \n
- if your microcontroller has nothing else to do, you could send it to sleep and let the power efficient ADS1115 work.<\/li>\n
- outsourced processes that are connected via interrupts can simplify your code.<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
The ADS1015 has a resolution of 12 bits but is considerably faster than the ADS1115.<\/p>\n\n
Technical features of the ADS1115 \/ ADS1015<\/h2>\n\n
![\"Various](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2020\/06\/various_ads1115_modules-1024x316.jpg\")
<\/a>Various ADS1115 modules<\/figcaption><\/figure>\n\n Inputs and outputs of the ADS1115 \/ ADS1015<\/h3>\n\n
The ADS1115 \/ ADS1015 and the modules have the following inputs and outputs:<\/p>\n
- \n
- VCC \/ GND<\/strong>: To be connected to 2 to 5.5 volts.<\/li>\n
- SDA \/ SCL<\/strong>: Communication via I2C. I didn’t need any extra pull-up resistors, but they’re not necessarily implemented in every module.<\/li>\n
- ADDR<\/strong>: Address pin – you can choose from four I2C addresses according to the table shown below.<\/li>\n
- ALRT<\/strong>: the alert pin asserts when adjustable thresholds are exceeded or when an A\/D conversion (“conversion ready”) is completed. By default, the pin is deactivated.<\/li>\n
- A0 – A3<\/strong>: Connections for the four channels. The applied voltage must not exceed VCC by more than 0.3 volts!<\/li>\n<\/ul>\n\n
As you can see, the middle module shown above does not have an address and alarm pin. Thus, you can’t change the address 0x48 and use the alert functions. If you don’t need it, you have a very space-saving solution with such a module.<\/p>\n\n
![\"Setting](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2021\/01\/ADS1115_Address-1024x111.png\")
<\/a>Setting the I2C addresses of the ADS1115 \/ ADS1015<\/figcaption><\/figure>\n\n If you want to check the I2C address, you can use this I2C scanner.<\/a><\/p>\n\n
attributes<\/h3>\n\n
Here is a brief overview of the most important features:<\/p>\n
- \n
- 16 bit Resolution – signed (+\/- 215<\/sup> Bit).\n
- \n
- 12 bit for the ADS1015<\/li>\n<\/ul>\n<\/li>\n
- 4 channels that can be measured against each other or against GND.<\/li>\n
- Multiplexing, so only one channel can be converted per time.<\/li>\n
- 6 voltage (or gain) ranges from +\/- 256 mV to +\/- 6.144 V.<\/li>\n
- Alert function (limit overrun or “conversion ready”).<\/li>\n
- Conversion rate from 8 s-1<\/sup> to 860 s-1<\/sup>.\n
- \n
- For the ADS1015: 128 s-1<\/sup> to 3300 s-1<\/sup><\/li>\n<\/ul>\n<\/li>\n
- Continuous mode or single-shot.<\/li>\n
- Internal voltage reference.<\/li>\n
- Low power consumption: 150 \u00b5A in continuous mode, 2.5 \u00b5A in power-down mode. The ADS1115 \/ ADS1015 automatically enters power-down mode after a single-shot measurement.<\/li>\n<\/ul>\n
Further information can be found in the data sheet<\/a> of the ADS1115.<\/p>\n
ADS1115\/ADS1015 modules are available for a few euros in most online stores, e.g. here<\/a> on Amazon.<\/p>\n
Apparently, there are also ADS1115 modules that do not deliver 16-bit resolution because they are incorrectly based on an ADS1015. There are also ADS1015 modules that are incorrectly based on ADS1115 modules. You can use my sample sketch \u201cWho_AM_I.ino\u201d to check which chip is installed. <\/p>\n\n
Typical circuit<\/h3>\n\n
I used the circuit shown below for all example sketches. Instead of the potentiometers you can, of course, connect anything else to the inputs. You could use a multimeter to check the results, or you could measure in parallel with the analog inputs of the Arduino.<\/p>\n
As already mentioned, I didn’t need pull-ups for the I2C lines. If you have problems, add them.<\/p>\n\n
![\"Wiring](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2020\/06\/ADS1115_Test_Wiring-1024x519.png\")
<\/a>Wiring the ADS1115 – used for all example sketches<\/figcaption><\/figure>\n\n Control with the ADS1115_WE library<\/h2>\n\n
You can download the library with the Arduino Library Manager or directly here<\/a> from GitHub.<\/p>\n
The use of example sketches is the most effective way to explain how to use the ADS1115_WE library. I have added various example sketches to the library. I go most intensively into Single_Shot.ino. Many functions used there are also used in other sketches. The sketches are written for the ADS1115. The \u201ctranslation\u201d for the ADS1015 is simple. You will find the example sketch \u201cContinuous_ADS1015.ino\u201d as part of the library.<\/p>\n\n
Example sketch 1: Single_Shot.ino<\/h3>\n\n
With this sketch, we measure the four inputs in single-shot mode (i.e. on request) against GND one after the other. The parameters for the library functions you can choose from are listed in the comments in the sketch. A few notes on the (relevant) functions:<\/p>\n
- \n
ADS1115_WE adc = ADS1115_WE()<\/code> creates the ADS1115_WE object. You can pass alternative I2C addresses and buses. <\/li>\ninit()<\/code> resets the settings of the configuration register of the ADS1115 to the default values. This has the advantage that you do not have to disconnect the ADS1115 from the power supply after you have changed your sketch. Otherwise, you would have to do this to have a defined state of the registers.init()<\/code> also checks the connection to the module. The function returns false if the ADS1115 does not respond.<\/li>\nsetVoltageRange_mV()<\/code> determines the voltage range in millivolts. The smaller the range, the greater the gain and resolution (= +\/-range \/ 215<\/sup>).<\/li>\nsetCompareChannels()<\/code> sets the channels to be compared.<\/li>\nsetConversionRate()<\/code> sets the conversion rate in conversions per second (SPS = Samples per second).<\/li>\nsetMeasureMode()<\/code> sets the mode, i.e. continuous or single-shot. The latter is the default.<\/li>\nstartSingleMeasurement()<\/code> starts a conversion for the channels previously selected withsetCompareChannels()<\/code>.<\/li>\nisBusy()<\/code> returns true while the conversion is not yet complete. Without the linewhile(adc.isBusy()){}<\/code>, the value from the last conversion would be read\u2014and that may come from a different channel. There is only one conversion register!<\/li>\ngetResult_V()<\/code> delivers the voltage in volts. For small values you can usegetResult_mV()<\/code>.<\/li>\n<\/ul>\nThe other functions only become relevant when you use the alert pin.<\/p>\n<\/p>\n
\n\/***************************************************************************\n* Example sketch for the ADS1115_WE library\n*\n* This sketch shows how to use the ADS1115 in single shot mode. \n* \n* Further information can be found on:\n* https:\/\/wolles-elektronikkiste.de\/ads1115 (German)\n* https:\/\/wolles-elektronikkiste.de\/en\/ads1115-a-d-converter-with-amplifier (English)\n* \n***************************************************************************\/\n\n#include<ADS1115_WE.h> \n#include<Wire.h>\n#define I2C_ADDRESS 0x48\n\n\/* There are several ways to create your ADS1115_WE object:\n * ADS1115_WE adc = ADS1115_WE() -> uses Wire \/ I2C Address = 0x48\n * ADS1115_WE adc = ADS1115_WE(I2C_ADDRESS) -> uses Wire \/ I2C_ADDRESS\n * ADS1115_WE adc = ADS1115_WE(&wire2) -> uses the TwoWire object wire2 \/ I2C_ADDRESS\n * ADS1115_WE adc = ADS1115_WE(&wire2, I2C_ADDRESS) -> all together\n * Successfully tested with two I2C busses on an ESP32\n *\/\nADS1115_WE adc = ADS1115_WE(I2C_ADDRESS);\n\nvoid setup() {\n Wire.begin();\n Serial.begin(9600);\n if(!adc.init()){\n Serial.println(\"ADS1115 not connected!\");\n }\n\n \/* Set the voltage range of the ADC to adjust the gain\n * Please note that you must not apply more than VDD + 0.3V to the input pins!\n * \n * ADS1115_RANGE_6144 -> +\/- 6144 mV\n * ADS1115_RANGE_4096 -> +\/- 4096 mV\n * ADS1115_RANGE_2048 -> +\/- 2048 mV (default)\n * ADS1115_RANGE_1024 -> +\/- 1024 mV\n * ADS1115_RANGE_0512 -> +\/- 512 mV\n * ADS1115_RANGE_0256 -> +\/- 256 mV\n *\/\n adc.setVoltageRange_mV(ADS1115_RANGE_6144); \/\/comment line\/change parameter to change range\n\n \/* Set the inputs to be compared\n * \n * ADS1115_COMP_0_1 -> compares 0 with 1 (default)\n * ADS1115_COMP_0_3 -> compares 0 with 3\n * ADS1115_COMP_1_3 -> compares 1 with 3\n * ADS1115_COMP_2_3 -> compares 2 with 3\n * ADS1115_COMP_0_GND -> compares 0 with GND\n * ADS1115_COMP_1_GND -> compares 1 with GND\n * ADS1115_COMP_2_GND -> compares 2 with GND\n * ADS1115_COMP_3_GND -> compares 3 with GND\n *\/\n \/\/adc.setCompareChannels(ADS1115_COMP_0_GND); \/\/uncomment if you want to change the default\n\n \/* Set number of conversions after which the alert pin will assert\n * - or you can disable the alert \n * \n * ADS1115_ASSERT_AFTER_1 -> after 1 conversion\n * ADS1115_ASSERT_AFTER_2 -> after 2 conversions\n * ADS1115_ASSERT_AFTER_4 -> after 4 conversions\n * ADS1115_DISABLE_ALERT -> disable comparator \/ alert pin (default) \n *\/\n \/\/adc.setAlertPinMode(ADS1115_ASSERT_AFTER_1); \/\/uncomment if you want to change the default\n\n \/* Set the conversion rate in SPS (samples per second)\n * Options should be self-explaining: \n * \n * ADS1115_8_SPS \n * ADS1115_16_SPS \n * ADS1115_32_SPS \n * ADS1115_64_SPS \n * ADS1115_128_SPS (default)\n * ADS1115_250_SPS \n * ADS1115_475_SPS \n * ADS1115_860_SPS \n *\/\n \/\/adc.setConvRate(ADS1115_128_SPS); \/\/uncomment if you want to change the default\n\n \/* Set continuous or single shot mode:\n * \n * ADS1115_CONTINUOUS -> continuous mode\n * ADS1115_SINGLE -> single shot mode (default)\n *\/\n \/\/adc.setMeasureMode(ADS1115_CONTINUOUS); \/\/uncomment if you want to change the default\n\n \/* Choose maximum limit or maximum and minimum alert limit (window) in volts - alert pin will \n * assert when measured values are beyond the maximum limit or outside the window \n * Upper limit first: setAlertLimit_V(MODE, maximum, minimum)\n * In max limit mode the minimum value is the limit where the alert pin assertion will be \n * be cleared (if not latched) \n * \n * ADS1115_MAX_LIMIT\n * ADS1115_WINDOW\n * \n *\/\n \/\/adc.setAlertModeAndLimit_V(ADS1115_MAX_LIMIT, 3.0, 1.5); \/\/uncomment if you want to change the default\n \n \/* Enable or disable latch. If latch is enabled the alert pin will assert until the\n * conversion register is read (getResult functions). If disabled the alert pin assertion\n * will be cleared with next value within limits. \n * \n * ADS1115_LATCH_DISABLED (default)\n * ADS1115_LATCH_ENABLED\n *\/\n \/\/adc.setAlertLatch(ADS1115_LATCH_ENABLED); \/\/uncomment if you want to change the default\n\n \/* Sets the alert pin polarity if active:\n * \n * ADS1115_ACT_LOW -> active low (default) \n * ADS1115_ACT_HIGH -> active high\n *\/\n \/\/adc.setAlertPol(ADS1115_ACT_LOW); \/\/uncomment if you want to change the default\n \n \/* With this function the alert pin will assert, when a conversion is ready.\n * In order to deactivate, use the setAlertLimit_V function \n *\/\n \/\/adc.setAlertPinToConversionReady(); \/\/uncomment if you want to change the default\n\n Serial.println(\"ADS1115 Example Sketch - Single Shot Mode\");\n Serial.println(\"Channel \/ Voltage [V]: \");\n Serial.println();\n}\n\nvoid loop() {\n float voltage = 0.0;\n\n Serial.print(\"0: \");\n voltage = readChannel(ADS1115_COMP_0_GND);\n Serial.print(voltage);\n\n Serial.print(\", 1: \");\n voltage = readChannel(ADS1115_COMP_1_GND);\n Serial.print(voltage);\n \n Serial.print(\", 2: \");\n voltage = readChannel(ADS1115_COMP_2_GND);\n Serial.print(voltage);\n\n Serial.print(\", 3: \");\n voltage = readChannel(ADS1115_COMP_3_GND);\n Serial.println(voltage);\n\n delay(1000);\n}\n\nfloat readChannel(ADS1115_MUX channel) {\n float voltage = 0.0;\n adc.setCompareChannels(channel);\n adc.startSingleMeasurement();\n while(adc.isBusy()){}\n voltage = adc.getResult_V(); \/\/ alternative: getResult_mV for Millivolt\n return voltage;\n}<\/pre>\n\u00a0<\/p>\n<\/div>\n
\n\n
Example sketch 2: Continuous.ino<\/h3>\n\n
In this example, the ADS1115 measures continuously. Here, too, we switch channels again. The ADS1115 can always be read, regardless of whether the conversion register has been updated since the last read. Once the channel has been changed, it takes approximately two conversions before a new measurement value is available. To prevent values from being read from the previous channel, a
delay()<\/code> matched to the data rate is inserted when changing channels. The library does this in the background.<\/p>\nThe main difference in the code is that the measurement does not need to be initiated.<\/p>\n
I show here only the relevant or changed lines. Download the full sketches with the library.<\/strong><\/p>\n<\/p>\n
adc.setVoltageRange_mV(ADS1115_RANGE_6144); \/\/ wir nutzen wieder die ganze Range\n ....\n ....\n \n adc.setCompareChannels(ADS1115_COMP_0_GND); \/\/ we start with this channel\n ....\n ....\n adc.setMeasureMode(ADS1115_CONTINUOUS); \/\/ here we select continuous mode\n\nvoid loop() {\n float voltage = 0.0;\n\n Serial.print(\"0: \");\n voltage = readChannel(ADS1115_COMP_0_GND);\n Serial.print(voltage);\n\n Serial.print(\", 1: \");\n voltage = readChannel(ADS1115_COMP_1_GND);\n Serial.print(voltage);\n ....\n ....\n delay(1000);\n}\n\nfloat readChannel(ADS1115_MUX channel) {\n float voltage = 0.0;\n adc.setCompareChannels(channel);\n voltage = adc.getResult_V(); \/\/ we just retrieve a new value no startSingleMeasurement() needed\n return voltage;\n}<\/pre>\n\u00a0<\/p>\n
\n\n
Otherwise, the sketch should be understandable without further explanation.<\/p>\n\n
Example sketch 3: Single_Shot_Conv_Ready_Controlled.ino<\/h3>\n\n
I have chosen a somewhat unwieldy name for the sketch. What I mean to say is that the ADS1115 measures in single-shot mode and controls the frequency of value output via the number of completed measurements and the conversion rate. I have set the conversion rate to 8 SPS. At every 32nd conversion the sketch outputs a value, i.e. every 4 seconds. Of course, you don’t have to measure 32 times to read a value. I only did this to slow down the output. It should be clear that the output is controlled by the data rate rather than a delay. <\/p>\n<\/p>\n
adc.setVoltageRange_mV(ADS1115_RANGE_6144); \n ....\n ....\n adc.setCompareChannels(ADS1115_COMP_0_GND); \n ....\n ....\n adc.setConvRate(ADS1115_8_SPS); \/\/ 8 conversions per second\n ....\n ....\n \/\/adc.setMeasureMode(ADS1115_CONTINUOUS); \/\/ commented, hence default is applied (single-shot)\n ....\n ....\nvoid loop() {\n float voltage = 0.0;\n for(int i=0; i<32; i++){ \/\/ wait for 32 conversions\n adc.startSingleMeasurement();\n while(adc.isBusy()){}\n }\n voltage = adc.getResult_V(); \/\/ alternative: getResult_mV for Millivolt\n Serial.print(\"Channel 0 vs GND [V]: \");\n Serial.println(voltage);\n Serial.println(\"-------------------------------\");\n}<\/pre>\n\u00a0<\/p>\n
\n\n
Example sketch 4: Conv_Ready_Alert_Pin_Controlled.ino<\/h3>\n\n
Another unwieldy name. This sketch also controls the output frequency by the number of conversions made. Unlike the last example, the Arduino does not ask for completion with
isBusy()<\/code>, but the ADS1115 reports this event via the alert pin. If this goes LOW (asserts), an interrupt is triggered that increments the counter variable.<\/p>\nAgain, I am only performing the 32 measurements to slow down the output.<\/p>\n
As new functions, the sketch uses:<\/p>\n
- \n
setAlertPinMode()<\/code> normally determines after how many limit overruns the alert pin asserts (1, 2 or 4). Actually, this is not relevant here. However, if you do not call the function, the default setting will be applied (ADS1115_DISABLE_ALERT). This means: the function must be called for this sketch with any parameter except ADS1115_DISABLE_ALERT.<\/li>\nsetAlertPol()<\/code> determines whether the alarm pin is LOW or HIGH in the event of an alert. The default setting is LOW (ADS1115_ACT_LOW).<\/li>\nsetAlertPinToConversionReady()<\/code> tells the ADS1115 that the alert should be triggered when the conversion is completed.<\/li>\n<\/ul>\nThe Conversion Ready alarm also works in continuous mode. However, this only applies to the alarm pin, i.e., the query via hardware. The software query via
isBusy()<\/code> only works in single-shot mode.<\/p>\n<\/p>\n\n....\n....\nint interruptPin = 2;\nvolatile bool convReady = false;\n....\n....\nvoid setup() {\n ....\n ....\n pinMode(interruptPin, INPUT_PULLUP);\n ....\n ....\n adc.setVoltageRange_mV(ADS1115_RANGE_6144); \n ....\n ....\n adc.setCompareChannels(ADS1115_COMP_0_GND); \n ....\n ....\n adc.setAlertPinMode(ADS1115_ASSERT_AFTER_1); \n ....\n ....\n adc.setConvRate(ADS1115_8_SPS); \/\/comment line\/change paramater to change SPS\n .... \n ....\n \/\/adc.setMeasureMode(ADS1115_CONTINUOUS); \/\/ commented --> single-shot\n ....\n ....\n \/\/adc.setAlertPol(ADS1115_ACT_LOW); \/\/ active-low\n ....\n ....\n adc.setAlertPinToConversionReady(); \/\/ sets the alert pin to conversion ready\n ....\n ....\n attachInterrupt(digitalPinToInterrupt(interruptPin), convReadyAlert, FALLING); \/\/ interrupt, if alert pin is low, ISR = convReadyAlert\n adc.startSingleMeasurement(); \/\/ start measurement\n}\n\nvoid loop() {\n float voltage = 0.0;\n static int counter = 0;\n if(convReady){\n counter++;\n convReady = false;\n if(counter==32){ \/\/ counter is 32, conversion rate is 8 SPS --> 4s\n voltage = adc.getResult_V(); \n Serial.print(\"Channel 0 vs GND [V]: \");\n Serial.println(voltage);\n Serial.println(\"-------------------------------\");\n counter = 0;\n }\n adc.startSingleMeasurement(); \n }\n}\n\nvoid convReadyAlert(){ \/\/ Interrupt Service Routine (ISR)\n convReady = true;\n}<\/pre>\n\u00a0<\/p>\n<\/div>\n
\n\n
Example sketch 5: Alert_Window_Mode.ino<\/h3>\n\n
Now we come to a very helpful feature of the ADS1115, namely the limit alarm. This allows you to monitor voltages very conveniently. However, there is only one register for the upper and lower limits, respectively, and not for each channel. If you want to set the limits for each channel individually, you will have to do so again after each channel change.<\/p>\n
The alert pin asserts if you exceed the limits set by you. The conditions under which the ADS1115 deasserts the alert pin again depends on further settings.<\/p>\n
The following new function is relevant:<\/p>\n
- \n
setAlertModeAndLimit()<\/code> :\n- \n
- Sets the mode:\n
- \n
- With ADS1115_WINDOW, you define a window with maximum and minimum. If values outside the limits are detected, the alert pin asserts. If the ADS1115 then determines values within the limit, the alert pin is deasserted – unless latch is active.<\/li>\n
- With ADS1115_MAX_LIMIT, the alert pin only asserts if the maximum is exceeded. The minimum is the value the assertion ends – unless latch is active.<\/li>\n<\/ul>\n<\/li>\n
- In addition to the mode, the function also passes the limits in volts.<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
You can find out what latch is all about in example sketch 6. In the current example, the alert pin automatically deassert when the above conditions occur.<\/p>\n
Note: with assert and deassert I mean “alert on” \/ alert off”. Deassert does not mean that the alert pin is without function.<\/em><\/p>\n<\/p>\n
\n....\n....\nint ledPin = 10; \/\/ LED that indicates an alert\nvolatile bool outOfLimit = false;\n....\n....\n\nvoid setup() {\n .... \n pinMode(interruptPin, INPUT_PULLUP);\n pinMode(ledPin, OUTPUT);\n digitalWrite(ledPin, LOW);\n ....\n ....\n adc.setCompareChannels(ADS1115_COMP_0_GND); \n ....\n ....\n adc.setAlertPinMode(ADS1115_ASSERT_AFTER_1); \/\/ alert after 1 value that is out of limit\n ....\n .... \n adc.setMeasureMode(ADS1115_CONTINUOUS); \/\/ single-shot would make no sense here\n ....\n ....\n adc.setAlertModeAndLimit_V(ADS1115_WINDOW, 3.0, 1.5); \/\/you can change modes \/ limits\n ....\n ....\n \/\/adc.setAlertPinToConversionReady(); \/\/ must be commented\n ....\n attachInterrupt(digitalPinToInterrupt(interruptPin), outOfLimitAlert, FALLING);\n}\n\nvoid loop() {\n float voltage = 0.0;\n if(outOfLimit){\n voltage = adc.getResult_V();\n Serial.print(\"Voltage [V]: \");\n Serial.println(voltage); \n digitalWrite(ledPin,HIGH);\n delay(1000);\n digitalWrite(ledPin,LOW);\n outOfLimit = false;\n attachInterrupt(digitalPinToInterrupt(interruptPin), outOfLimitAlert, FALLING); \n } \n}\n\nvoid outOfLimitAlert(){\n detachInterrupt(2);\n outOfLimit = true;\n}<\/pre>\n\u00a0<\/p>\n<\/div>\n
\n\n
Example sketch 6: Alert_Window_Mode_with_Latch.ino<\/h3>\n\n
This sketch basically does the same as Alert_Window_Mode.ino, except that latch is used. Latch prevents the alert pin from being automatically deactivated again.<\/p>\n
The following new functions are relevant:<\/p>\n
- \n
setAlertLatch()<\/code> activates or deactivates latch.<\/li>\nclearAlert()<\/code> deactivates the alert pin. Latch is active when the next reading is outside the limits. As an alternative toclearAlert()<\/code> you can usegetResult_V()<\/code> orgetResult_mV()<\/code>.<\/li>\n<\/ul>\n<\/p>\n....\nvolatile int interruptPin = 2;\nint ledPin = 10;\nvolatile bool outOfLimit = false;\n....\n....\nvoid setup() {\n ....\n ....\n adc.setCompareChannels(ADS1115_COMP_0_GND);\n ....\n ....\n adc.setAlertPinMode(ADS1115_ASSERT_AFTER_1); \/\/ ...AFTER_2 or ...4 would also work\n ....\n ....\n adc.setMeasureMode(ADS1115_CONTINUOUS); \n ....\n ....\n adc.setAlertModeAndLimit_V(ADS1115_WINDOW, 3.0, 1.5); \/\/ you could also select the max limit method\n ....\n ....\n adc.setAlertLatch(ADS1115_LATCH_ENABLED); \/\/ latch enabled\n ....\n ....\n attachInterrupt(digitalPinToInterrupt(interruptPin), outOfLimitAlert, FALLING);\n}\n\nvoid loop() {\n float voltage = 0.0;\n if(outOfLimit){\n voltage = adc.getResult_V();\n Serial.print(\"Voltage [V]: \");\n Serial.println(voltage); \n digitalWrite(ledPin,HIGH);\n delay(1000);\n digitalWrite(ledPin,LOW);\n outOfLimit = false;\n attachInterrupt(digitalPinToInterrupt(interruptPin), outOfLimitAlert, FALLING); \n adc.clearAlert(); \/\/ clear alert; alternatives: call getResult_V() or getResult_mV()\n } \n}\n\nvoid outOfLimitAlert(){\n detachInterrupt(2);\n outOfLimit = true;\n}<\/pre>\n\u00a0<\/p>\n
\n\n
After the output of the exceeded limit value and the warning light of the LED, first the interrupt is switched on again. Then the alarm is deactivated with
clearAlert()<\/code>, i.e. the pin goes HIGH. If the out-of-limit condition still exists, the next interrupt is triggered immediately. As a result, the LED lights up almost continuously. <\/p>\nThe latch provides more control, but you have to be careful with the timing. If you switch on the interrupt function after you have deactivated the alert, then the alert pin may be low again and a “falling” will not occur anymore.<\/p>\n\n
Example sketch 7: Auto_Range.ino<\/h3>\n\n
In this example sketch, I present the functions
setAutoRange()<\/code> andsetPermanentAutoRangeMode()<\/code>. As you can imagine, the range is set automatically with both. To do this,setAutoRange()<\/code> does the following:<\/p>\n- \n
- If the ADS1115 is in single-shot mode, the function switches to continuous mode.<\/li>\n
- The maximum range (+\/- 6.144) is set first.<\/li>\n
- A measured value is recorded.<\/li>\n
- The smallest possible range is then selected in which the measured value is still below 80% of the maximum value of the range. I have selected 80% so that certain fluctuations do not immediately lead to an overflow.<\/li>\n
- If the ADS1115 was originally in single-shot mode, it will switch back to this mode.<\/li>\n<\/ul>\n
The function
setAutoRange()<\/code> only makes sense if the expected measured values are stable or change only slowly. A call to the function takes a period of several conversions. If you have set 8 SPS as the conversion rate, this is already clearly noticeable.<\/p>\nsetPermanentAutoRangeMode()<\/code> only needs to be called once. You can use it to set the system to check whether each measured value is within the range of 30 – 80 % of the maximum value of the current range. Only if this is not the case issetAutoRange()<\/code> called up in the background. This makes the function faster. Uses one OR the other function.<\/p>\nTo show that the range change really works, the range is also output in the example sketch.<\/p>\n<\/p>\n
\n....\n adc.setMeasureMode(ADS1115_CONTINUOUS); \/\/comment line\/change parameter to change mode\n .... \n .... \n adc.setPermanentAutoRangeMode(true); \/\/use either this or setAutoRange()\n ....\n}\n\nvoid loop() {\n float voltage = 0.0;\n \n Serial.print(\"Channel 0 - \");\n readChannel(ADS1115_COMP_0_GND);\n \n Serial.print(\"Channel 1 - \");\n readChannel(ADS1115_COMP_1_GND); \n ....\n ....\n Serial.println(\"-------------------------------\");\n delay(1000);\n}\n\nvoid readChannel(ADS1115_MUX channel) {\n float voltage = 0.0;\n adc.setCompareChannels(channel);\n \/\/adc.setAutoRange(); \/\/use either this or setPermanentAutoRangeMode(true)\n voltage = adc.getResult_V(); \/\/ alternative: getResult_mV for Millivolt\n printVoltageRange(); \/\/ this is just to show that the range is changing with changing voltages \n Serial.println(voltage);\n}\n \nvoid printVoltageRange(){\n unsigned int voltageRange = adc.getVoltageRange_mV();\n Serial.print(\"Range: \");\n\n switch(voltageRange){\n case 6144:\n Serial.print(\"+\/- 6144 mV, Voltage [V]: \");\n break;\n case 4096:\n Serial.print(\"+\/- 4096 mV, Voltage [V]: \");\n break;\n case 2048:\n Serial.print(\"+\/- 2048 mV, Voltage [V]: \");\n break;\n case 1024:\n Serial.print(\"+\/- 1024 mV, Voltage [V]: \");\n break;\n case 512:\n Serial.print(\"+\/- 512 mV, Voltage [V]: \");\n break;\n case 256:\n Serial.print(\"+\/- 256 mV, Voltage [V]: \");\n break;\n default:\n Serial.println(\"Something went wrong\");\n }\n}<\/pre>\n\u00a0<\/p>\n<\/div>\n
\n\n
Output of Auto_Range.ino<\/h4>\n\n
An output of the sketch could then look like this:<\/p>\n\n
![\"Example](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2021\/09\/Output_Auto_Range_2.png\")
<\/a>Output of Auto_Range.ino <\/figcaption><\/figure>\n\n Example sketch 8: Result_Format_Options<\/h3>\n\n
This sketch shows the various output options for the conversion results:<\/p>\n
- \n
getResult_mV()<\/code> returns the result in millivolts<\/li>\ngetResult_V()<\/code> outputs the result in volts<\/li>\ngetRawResult()<\/code> returns the raw value as it appears in the conversion register<\/li>\n- With
getResultWith Range(x,y)<\/code> the raw value is scaled to the range x to y. If you select (-1023, 1023), for example, you will get your result back as a 10-bit value. <\/li>\n- If you call the last function with a third parameter like
getResultWithRange(x,y,z)<\/code>, the result is also scaled to a voltage range. The parameter is specified in millivolts. The parameters (-1023, 1023, 5000) would give you the value that you would get with analogRead() with an Arduino Uno R3 in the default settings. <\/li>\n<\/ul>\n<\/p>\n....\n adc.setVoltageRange_mV(ADS1115_RANGE_6144); \/\/comment line\/change parameter to change range\n adc.setCompareChannels(ADS1115_COMP_0_GND); \/\/comment line\/change parameter to change channel\n adc.setMeasureMode(ADS1115_CONTINUOUS); \/\/comment line\/change parameter to change mode\n ....\n ....\n\nvoid loop() {\n \n float voltageInMillivolt = adc.getResult_mV(); \n Serial.print(\"Result in Millivolt [mV]: \");\n Serial.println(voltageInMillivolt);\n\n float voltageInVolt = adc.getResult_V(); \n Serial.print(\"Result in Volt [V]: \");\n Serial.println(voltageInVolt);\n\n int rawResult = adc.getRawResult();\n Serial.print(\"Raw Result : \");\n Serial.println(rawResult);\n\n int scaledResult = adc.getResultWithRange(-1023, 1023);\n Serial.print(\"Scaled result : \");\n Serial.println(scaledResult);\n\n int scaledResultWithMaxVoltage = adc.getResultWithRange(-1023, 1023, 5000); \n Serial.print(\"Scaled result with voltage scale : \");\n Serial.println(scaledResultWithMaxVoltage);\n\n unsigned int voltRange = adc.getVoltageRange_mV();\n Serial.print(\"Voltage Range of ADS1115 [mV]: \");\n Serial.println(voltRange);\n \n Serial.println(\"-------------------------------\");\n delay(2000);\n}<\/pre>\n\u00a0<\/p>\n
\n\n
Output of Result_Format_Options.ino<\/h4>\n\n
And this is what an output of the Result_Format_Option.ino sketch looks like:<\/p>\n\n
![\"\"](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2021\/02\/Output_Result_Format_Options.png\")
<\/a>Output of Result_Format_Options.ino<\/figcaption><\/figure>\n\n All functions at a glance<\/h3>\n\n
Here<\/a> I have summarized all the functions. The table is part of my documentation on GitHub. However, you can also find the table as “List of public functions.pdf” in the library folder “libraries\/ADS1115_WE” on your PC, provided you have installed the library. <\/p>\n
I have not mentioned one function yet, namely
reset()<\/code> . It uses the global I2C reset (0x06). All I2C devices that are connected to the same interface and also listen to the global commands (general calls) perform a reset when the function is called. <\/p>\n\nDeeper insights into the ADS1115 \/ ADS1015<\/h2>\n\n
I am referring to the ADS1115 in this chapter. The good news is that the registers of the ADS1015 are almost identical. For all registers where its 12-bit resolution is used, the lowest 4 bits are simply set to 0.<\/p>\n\n
Register map<\/h3>\n\n
![\"Registers](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2021\/01\/ads1115_register_map-1024x264.png\")
<\/a>Registers of the ADS1115<\/figcaption><\/figure>\n\n The ADS1115 has a relatively small number of registers. All settings – with one exception – are made in the configuration register (config register). I’ll go into that in a little bit.<\/p>\n\n
The results of the conversions are retrieved from the conversion register. There is only one for all four channels. Therefore, you always have to select the channel first and then wait for a result for this channel. The LSB for the conversion register is:<\/p>\n<\/p>\n
- Sets the mode:\n
- For the ADS1015: 128 s-1<\/sup> to 3300 s-1<\/sup><\/li>\n<\/ul>\n<\/li>\n
- SDA \/ SCL<\/strong>: Communication via I2C. I didn’t need any extra pull-up resistors, but they’re not necessarily implemented in every module.<\/li>\n
- VCC \/ GND<\/strong>: To be connected to 2 to 5.5 volts.<\/li>\n