abstract_driver.py

Go to the documentation of this file.

# -*- coding: utf-8; -*-
#
# Copyright (c) 2016 Álan Crístoffer
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.



import ahio



class AbstractahioDriverInfo(object):
    NAME = 'Driver name'
    AVAILABLE = 'True if the driver is available, false otherwise'



class AbstractDriver(object):

    _pin_mapping = {}
    _pin_lin = {}

    
    def available_pins(self):
        raise NotImplementedMethod()

    
    def map_pin(self, abstract_pin_id, physical_pin_id):
        if physical_pin_id:
            self._pin_mapping[abstract_pin_id] = physical_pin_id
        else:
            self._pin_mapping.pop(abstract_pin_id, None)

    
    def mapped_pins(self):
        return self._pin_mapping

    def _linear_interpolation(self, x, imin, imax, omin, omax):
        return (imax * omin - imin * omax + x * (omax - omin)) / (imax - imin)

    
    def set_pin_interpolation(self,
                              pin,
                              read_min,
                              read_max,
                              write_min,
                              write_max):
        if type(pin) is list:
            # I don't like breaking calls in multiple lines
            args = (read_min, read_max, write_min, write_max)
            for p in pin:
                self.set_pin_interpolation(p, *args)
            return

        valid_read = (read_min is not None and read_max is not None)
        valid_write = (write_min is not None and write_max is not None)

        if not valid_read and not valid_write:
            self._pin_lin.pop(pin, None)
            return

        pin_id = self._pin_mapping.get(pin, None)
        pins = [pin for pin in self.available_pins() if pin_id == pin['id']]
        read = pins[0]['analog']['read_range']
        write = pins[0]['analog']['write_range']
        valid_read = valid_read and read
        valid_write = valid_write and write
        self._pin_lin[pin] = {
            'read': (*read, read_min, read_max) if valid_read else None,
            'write': (write_min, write_max, *write) if valid_write else None
        }

    
    def set_pin_direction(self, pin, direction):
        if type(pin) is list:
            for p in pin:
                self.set_pin_direction(p, direction)
            return

        pin_id = self._pin_mapping.get(pin, None)
        if pin_id and type(direction) is ahio.Direction:
            self._set_pin_direction(pin_id, direction)
        else:
            raise KeyError('Requested pin is not mapped: %s' % pin)

    
    def pin_direction(self, pin):
        if type(pin) is list:
            return [self.pin_direction(p) for p in pin]

        pin_id = self._pin_mapping.get(pin, None)
        if pin_id:
            return self._pin_direction(pin_id)
        else:
            raise KeyError('Requested pin is not mapped: %s' % pin)

    
    def set_pin_type(self, pin, ptype):
        if type(pin) is list:
            for p in pin:
                self.set_pin_type(p, ptype)
            return

        pin_id = self._pin_mapping.get(pin, None)
        if type(ptype) is not ahio.PortType:
            raise KeyError('ptype must be of type ahio.PortType')
        elif pin_id:
            self._set_pin_type(pin_id, ptype)
        else:
            raise KeyError('Requested pin is not mapped: %s' % pin)

    
    def pin_type(self, pin):
        if type(pin) is list:
            return [self.pin_type(p) for p in pin]

        pin_id = self._pin_mapping.get(pin, None)
        if pin_id:
            return self._pin_type(pin_id)
        else:
            raise KeyError('Requested pin is not mapped: %s' % pin)

    
    def write(self, pin, value, pwm=False):
        if type(pin) is list:
            for p in pin:
                self.write(p, value, pwm)
            return

        if pwm and type(value) is not int and type(value) is not float:
            raise TypeError('pwm is set, but value is not a float or int')

        pin_id = self._pin_mapping.get(pin, None)
        if pin_id:
            lpin = self._pin_lin.get(pin, None)
            if lpin and type(lpin['write']) is tuple:
                write_range = lpin['write']
                value = self._linear_interpolation(value, *write_range)
            self._write(pin_id, value, pwm)
        else:
            raise KeyError('Requested pin is not mapped: %s' % pin)

    
    def read(self, pin):
        if type(pin) is list:
            return [self.read(p) for p in pin]

        pin_id = self._pin_mapping.get(pin, None)
        if pin_id:
            value = self._read(pin_id)
            lpin = self._pin_lin.get(pin, None)
            if lpin and type(lpin['read']) is tuple:
                read_range = lpin['read']
                value = self._linear_interpolation(value, *read_range)
            return value
        else:
            raise KeyError('Requested pin is not mapped: %s' % pin)

    
    def analog_references(self):
        raise NotImplementedMethod()

    
    def set_analog_reference(self, reference, pin=None):
        if pin is None:
            self._set_analog_reference(reference, None)
        else:
            pin_id = self._pin_mapping.get(pin, None)
            if pin_id:
                self._set_analog_reference(reference, pin_id)
            else:
                raise KeyError('Requested pin is not mapped: %s' % pin)

    
    def analog_reference(self, pin=None):
        if pin is None:
            return self._analog_reference(None)
        else:
            pin_id = self._pin_mapping.get(pin, None)
            if pin_id:
                return self._analog_reference(pin_id)
            else:
                raise KeyError('Requested pin is not mapped: %s' % pin)

    
    def set_pwm_frequency(self, frequency, pin=None):
        if pin is None:
            self._set_pwm_frequency(frequency, None)
        else:
            pin_id = self._pin_mapping.get(pin, None)
            if pin_id:
                self._set_pwm_frequency(frequency, pin_id)
            else:
                raise KeyError('Requested pin is not mapped: %s' % pin)