Add driver for ADS1x15 ADCs

[caternuson]

Add driver to support the ADS1x15 ADCs.

• ADS1015 12-Bit ADC (PID 1083)
• ADS1115 16-Bit ADC (PID 1085)

[tannewt]

I'd love it if ADC drivers exposed a number of sub-objects for each input that can be used in place of an AnalogIn. To do that, it'd need the same properties.

[tannewt]

my goal would be able to do something like:

# setup analog

# import analogio
# import board
# a = analogio.AnalogIn(board.A0)

# OR!
import adafruit_CircuitPython_ADS1x15
adc = adafruit_CircuitPython_ADS1x15.ADS1015()
a = adc[0]

while True:
    # change neopixel color based on analog readings from a

That way all code written for one analog input is agnostic to whether its on the MCU or on a helper chip.

[caternuson]

In-work version is here:
https://github.com/caternuson/CircuitPython_ADS1x15

[caternuson]

Something like this?
(but with a generator instead of static list of channels in the ADC class):

import random

class ADC_Channel():
    def __init__(self, adc, channel):
        self._adc = adc
        self._channel = channel
        self._value = None
    
    @property
    def value(self, ):
        self._value = self._adc.read_adc(self._channel)
        return self._value 

class Generic_ADC():
    def __init__(self, ):
        self.channels = [ADC_Channel(self, 0),
                         ADC_Channel(self, 1),
                         ADC_Channel(self, 2),
                         ADC_Channel(self, 3)]
    
    def __getitem__(self, key):
        return self.channels[key]
    
    def read_adc(self, chan):
        return chan + random.random() 

adc = Generic_ADC()
a = adc[3]
a.value

[tannewt]

Yup! Thats what I was thinking.

[caternuson]

Could get a little messy trying to support all the modes the ADC can run in: single ended, differential, comparator. AnalogIn is essentially single ended only, so could make it to where that is the only mode supported for the above access method.

The ADC class will still have full functionality.

adc.read_adc()
adc.read_adc_difference()
adc.start_adc_comparator()
# etc

[tannewt]

Sure. The other way to do it would be three separate drivers for the three different modes. Each could be in a different file so you only need to load the code related to your use.

…

On Wed, Oct 11, 2017 at 10:30 AM Carter Nelson ***@***.***> wrote: Could get a little messy trying to support all the modes the ADC can run in: single ended, differential, comparator. AnalogIn is essentially single ended only, so could make it to where that is the only mode supported for the above access method. The ADC class will still have full functionality. adc.read_adc() adc.read_adc_difference() adc.start_adc_comparator()# etc — You are receiving this because you commented. Reply to this email directly, view it on GitHub <#312 (comment)>, or mute the thread <https://github.com/notifications/unsubscribe-auth/AADNqSJbW109JqMpFCADaXcERpckzEQAks5srPsfgaJpZM4PzMNZ> .

[caternuson]

Separate ADC classes?

[tannewt]

Yup, thats what I mean. So maybe:

from adafruit_ADS1x15.single_ended import ADS1015

What do you think? The model of more, smaller classes makes sense in terms of reducing memory footprint.

[caternuson]

Hmmm. Or if we add a mode property to the ADC class. Could then do something like:

class ADC_Channel():
    def __init__(self, adc, channel):
        self._adc = adc
        self._channel = channel
        self._value = None
    
    @property
    def value(self, ):
        if self._adc._mode == self._adc.SINGLE_ENDED:
            self._value = self._adc.read_adc(self._channel)
        elif self._adc._mode == self._adc.DIFFERENTIAL:
            self._value = self._adc.read_adc_difference(self._channel)
        elif self._adc._mode == self._adc.COMPARATOR:
            self._value = self._adc.get_last_result()
        return self._value 

[caternuson]

I like keeping ADC to just one class - or more importantly, making the CircuitPython version match the Python version as much as possible. Otherwise there would be an Arduino way of using it, a Python way of using it, and a CircuitPython way of using it.

I'm thinking this feature should be, as much as possible, a bolt on to the ADC class.

[caternuson]

How about this? (mode is in channel, not adc)

import random

class ADC_Channel():
    
    SINGLE_ENDED = 0
    DIFFERENTIAL = 1
    COMPARATOR   = 2
    
    def __init__(self, adc, channel):
        self._adc = adc
        self._channel = channel
        self._mode = ADC_Channel.SINGLE_ENDED
        self._value = None
        
    @property
    def mode(self, ):
        return self._mode
    
    @mode.setter
    def mode(self, mode):
        self._mode = mode
    
    @property
    def value(self, ):
        if self.mode == ADC_Channel.SINGLE_ENDED:
            self._value = self._adc.read_adc(self._channel)
        elif self.mode == ADC_Channel.DIFFERENTIAL:
            self._value = self._adc.read_adc_difference(self._channel)
        elif self.mode == ADC_Channel.COMPARATOR:
            self._value = self._adc.get_last_result()
        return self._value 

class Generic_ADC():
    def __init__(self, ):
        self.channels = [ADC_Channel(self, 0),
                         ADC_Channel(self, 1),
                         ADC_Channel(self, 2),
                         ADC_Channel(self, 3)]
    
    def __getitem__(self, key):
        return self.channels[key]
    
    def read_adc(self, chan):
        return chan + random.random()
    
    def read_adc_difference(self, chan):
        return -1 * (chan + random.random())
    
    def get_last_result(self, ):
        return random.random()


adc = Generic_ADC()
# use ADC directly (normal)
print adc.read_adc(1)
print adc.read_adc_difference(1)
print adc.get_last_result()
# get an ADC channel to use as an AnalogIn replacement
# this is probably the most common usage
a = adc[0]
print a.value
# support for differential mode
a = adc[1]
a.mode = ADC_Channel.DIFFERENTIAL
print a.value 
# support for comparator mode
a = adc[2]
a.mode = ADC_Channel.COMPARATOR
print a.value