Example #1
0
    def __init__(self, name, sda=None, scl=None,
                 width=128, height=64,
                 addr=0x3c):
        self.present = False
        self._y = 0
        self._x = 0
        self.last_text = ""
        self.char_width = width // 8
        self.char_height = height // 8

        if type(sda) is I2C:
            i2c = sda
        else:
            i2c = I2C(sda=sda, scl=scl)
        # test if lcd is responding
        try:
            self.dp = ssd1306.SSD1306_I2C(width, height, i2c, addr=addr)
            self.clear(show=False)
            self.println("  iot.ulno.net\n", show=True)

        except OSError:
            print("lcd not found")
        else:
            self.present = True
            Device.__init__(self, name, i2c, setters={"set": self.evaluate},
                            report_change=False)
            self.getters[""] = self.value
Example #2
0
 def __init__(self,
              name,
              pin,
              ignore_case=True,
              on_change=None,
              report_change=False,
              turn_time_ms=700,
              freq=50,
              min_us=600,
              max_us=2400,
              angle=180):
     self.min_us = min_us
     self.max_us = max_us
     self.us = 0
     self.freq = freq
     self.angle = angle
     self.angle_list = None
     self.turn_time_ms = turn_time_ms
     self.turn_start = None
     Device.__init__(self,
                     name,
                     PWM(pin, freq=self.freq, duty=0),
                     setters={"set": self.turn},
                     ignore_case=ignore_case,
                     on_change=on_change,
                     report_change=report_change)
     self._init()
Example #3
0
 def __init__(self,
              name,
              pin,
              ignore_case=True,
              on_change=None,
              report_change=False):
     self.is_on = False
     self.last_rgb = _c.white
     self.current_rgb = _c.black
     self.ani = None
     b = "brightness"
     r = "rgb"
     s = "set"
     st = "/status"
     Device.__init__(self,
                     name,
                     pin,
                     setters={
                         b + "/" + s: self._command_brightness,
                         r + "/" + s: self._command_rgb,
                         s: self._command_status,
                         "animation": self.animation
                     },
                     getters={
                         "": self.get_status,
                         b + st: self.get_brightness,
                         r + st: self.get
                     },
                     ignore_case=ignore_case,
                     on_change=on_change,
                     report_change=report_change)
     self.set(*_c.black)  # off
Example #4
0
 def __init__(self,
              name,
              trigger_pin,
              echo_pin,
              echo_timeout_us=30000,
              precision=10,
              on_change=None,
              report_change=True,
              filter=None):
     # trigger_pin: Output pin to send pulses
     # echo_pin: Readonly pin to measure the distance.
     #           The pin should be protected with 1k resistor
     # echo_timeout_us: Timeout in microseconds to listen to echo pin.
     # By default is based in sensor limit range (4m)
     self.current_value = 0
     self._last_measured = 0
     if type(trigger_pin) is not Pin:
         trigger_pin = Pin(trigger_pin)
     self.trigger_pin = trigger_pin
     if type(echo_pin) is not Pin:
         echo_pin = Pin(trigger_pin)
     self.echo_pin = echo_pin
     self.precision = precision
     trigger_pin.init(Pin.OUT)
     trigger_pin.off()
     echo_pin.init(Pin.IN)
     echo_pin.init(Pin.OPEN_DRAIN)
     self.echo_timeout_us = echo_timeout_us
     self.distance = None
     Device.__init__(self,
                     name, (trigger_pin, echo_pin),
                     on_change=on_change,
                     report_change=report_change,
                     filter=filter)
Example #5
0
    def __init__(self, name, sda=None, scl=None,
                 addr=8, ignore_case=False, report_change=True, filter=None):
        not_found = "i2c device not found"

        self.addr = addr
        self.ownaddr = addr
        self.count = None
        self.current_value = ""
        self.suspend_start = None
        self.suspend_time = 0
        self.msgq = None
        if type(sda) is I2C:
            i2c = sda
        else:
            i2c = I2C(sda=sda, scl=scl)

        try:
            l = i2c.scan()  # see, if you can find the dive with respective addr
        except OSError:
            print(not_found)
        else:
            if addr in l:
                self.present = True
                Device.__init__(self, name, i2c, setters={"set": self.evaluate},
                                ignore_case=ignore_case,
                                report_change=report_change, filter=filter)
            else:
                print(not_found)
Example #6
0
 def __init__(self,
              name,
              pin,
              *args,
              report_high="on",
              report_low="off",
              pullup=True,
              threshold=0,
              on_change=None,
              report_change=True,
              filter=None):
     if len(args) > 0:
         report_high = args[0]
         if len(args) > 1:
             report_low = args[1]
     Device.__init__(self,
                     name,
                     pin,
                     value_map={
                         True: report_high,
                         False: report_low
                     },
                     on_change=on_change,
                     report_change=report_change,
                     filter=filter)
     if pullup:
         pin.init(Pin.IN, Pin.PULL_UP)
     else:
         pin.init(Pin.IN)
         try:
             Pin.init(Pin.OPEN_DRAIN)
         except:
             pass
     self.threshold = threshold + 1
     self.debouncer = self.port() * self.threshold
Example #7
0
 def __init__(self,
              name,
              pin,
              rising=False,
              falling=False,
              pullup=True,
              on_change=None,
              report_change=True):
     if pullup:
         pin.init(Pin.IN, Pin.PULL_UP)
     else:
         pin.init(Pin.IN, Pin.OPEN_DRAIN)
     if rising and falling:
         trigger = Pin.IRQ_RISING | Pin.IRQ_FALLING
     elif not rising and falling:
         trigger = Pin.IRQ_FALLING
     else:  # also if both all false
         trigger = Pin.IRQ_RISING
     pin.irq(trigger=trigger, handler=self.callback)
     self.counter = 0
     self.report_counter = 0
     self.triggered = False
     Device.__init__(self,
                     name,
                     pin,
                     on_change=on_change,
                     report_change=report_change)
     self.getters[""] = self.value
Example #8
0
 def __init__(self,
              name,
              pin,
              *args,
              high_command='on',
              low_command='off',
              ignore_case=True,
              on_change=None,
              report_change=False):
     if len(args) > 0:
         high_command = args[0]
         if len(args) > 1:
             low_command = args[1]
     if ignore_case:
         high_command = high_command.lower()
         low_command = low_command.lower()
     self.high_command = high_command
     self.low_command = low_command
     Device.__init__(self,
                     name,
                     pin,
                     setters={"set": self.evaluate},
                     ignore_case=ignore_case,
                     on_change=on_change,
                     report_change=report_change,
                     value_map={
                         1: self.high_command,
                         0: self.low_command
                     })
     pin.init(Pin.OUT)
     self.state = pin()
Example #9
0
 def __init__(self, name, pin, on_change=None, filter=None):
     import onewire, ds18x20
     gc.collect()
     self.ds = ds18x20.DS18X20(onewire.OneWire(pin))
     self.roms = self.ds.scan()
     self.lasttime = time.ticks_ms()
     self.ds.convert_temp()
     self.temp_list = None
     Device.__init__(self, name, pin, on_change=on_change, filter=filter)
Example #10
0
 def __init__(self, name, precision=1, threshold=None,
              on_change=None, report_change=True):
     self.precision = precision
     self.threshold = None
     if threshold is not None:
         self.threshold = max(1, min(threshold, 1023))
     self.current_value = -10000
     Device.__init__(self, name, ADC(0), on_change=on_change,
                     report_change=report_change)
     self.getters[""] = self.value
Example #11
0
 def __init__(self, name, pin, dht_dev, delay,
              on_change=None, report_change=True):
     self.delay = delay
     import dht
     self.dht = dht_dev
     self.lasttime = time.ticks_ms()
     self.dht.measure()
     Device.__init__(self, name, pin, on_change=on_change,
                     getters={"temperature": self.temperature,
                              "humidity": self.humidity},
                     report_change=report_change)
Example #12
0
 def __init__(self,
              name,
              precision=1,
              threshold=None,
              on_change=None,
              report_change=True,
              filter=None):
     self.precision = precision
     self.threshold = None
     if threshold is not None:
         self.threshold = max(1, min(threshold, 1023))
     self.last_value = None
     Device.__init__(self,
                     name,
                     ADC(0),
                     on_change=on_change,
                     report_change=report_change,
                     filter=filter)
Example #13
0
    def __init__(self,
                 name,
                 sda=None,
                 scl=None,
                 width=16,
                 height=2,
                 addr=0x27):
        self.present = False
        self.last_text = ""
        self.char_width = width
        self.char_height = height
        self.display_buffer = bytearray(b" " * width * height)
        self.back_buffer = bytearray(b" " * width * height)
        self.x = 0
        self.y = 0

        if type(sda) is I2C:
            i2c = sda
        else:
            i2c = I2C(sda=sda, scl=scl)
        # test if lcd is responding
        try:
            self.dp = I2cLcd(i2c, addr, height, width)
            self.dp.clear()
            self.clear()
            self.hide_cursor()
            self.println("iot.ulno.net")

        except OSError:
            print("lcd not found")
        else:
            self.present = True
            Device.__init__(self,
                            name,
                            i2c,
                            setters={"set": self.evaluate},
                            report_change=False)
            self.getters[""] = self.value
Example #14
0
 def __init__(self,
              name,
              pin,
              freq=50,
              duty=0,
              ignore_case=True,
              on_change=None,
              report_change=False):
     self._duty = 0
     self._freq = freq
     Device.__init__(self,
                     name,
                     machine.PWM(pin, freq=freq, duty=duty),
                     setters={
                         "freq/set": self.set_freq,
                         "duty/set": self.set_duty
                     },
                     getters={
                         "freq": self.get_freq,
                         "duty": self.get_duty
                     },
                     ignore_case=ignore_case,
                     on_change=on_change,
                     report_change=report_change)
Example #15
0
    def __init__(self,
                 name,
                 rst,
                 cs=None,
                 sck=None,
                 mosi=None,
                 miso=None,
                 key=b'\xff\xff\xff\xff\xff\xff',
                 datasize=128,
                 on_change=None,
                 report_change=True,
                 filter=None):

        rst.init(Pin.OUT)
        self.rst = rst
        if self.rst is not None:
            self.rst.value(0)
        self.datasize = datasize
        self.key = key
        board = uname()[0]
        if sck is None:  # select defaults (hw based spi)
            if board == 'WiPy' or board == 'LoPy' or board == 'FiPy':
                spi = SPI(0)
                spi.init(SPI.MASTER, baudrate=1000000, pins=(14, 13, 12))
            elif board == 'esp8266':
                spi = SPI(1, baudrate=2500000, polarity=0, phase=0)
                spi.init()
                # hw uses the following pins
                # sck = Pin(14,Pin.OUT)  # d5 (ck)
                # mosi = Pin(13,Pin.OUT) # d7 (mo)
                # miso = Pin(12,Pin.IN)  # d6 (mi)
            else:
                raise RuntimeError("Unsupported platform")
            # TODO: does it make sense to set cs here to default?
            if cs is None:
                self.cs = Pin(15, Pin.OUT)  # d8 (cs)
            else:
                self.cs = cs
                cs.init(Pin.OUT)
            self.spi = spi
        else:
            self.cs = cs
            if cs is not None:
                cs.init(Pin.OUT)
            if type(sck) is SPI:
                self.spi = sck
            else:
                if board == 'WiPy' or board == 'LoPy' or board == 'FiPy':
                    spi = SPI(0)
                    spi.init(SPI.MASTER,
                             baudrate=1000000,
                             pins=(sck, mosi, miso))
                elif board == 'esp8266':
                    sck.init(Pin.OUT)
                    mosi.init(Pin.OUT)
                    miso.init(Pin.IN)
                    spi = SPI(baudrate=100000,
                              polarity=0,
                              phase=0,
                              sck=sck,
                              mosi=mosi,
                              miso=miso)
                    spi.init()
                else:
                    raise RuntimeError("Unsupported platform")
                self.spi = spi

        if self.rst is not None:
            self.rst.value(1)
        if self.cs is not None:
            self.cs.value(0)

        # get some memory
        self.reg_buf = bytearray(4)
        self.block_write_buf = bytearray(18)
        self.auth_buf = bytearray(12)
        self.wreg_buf = bytearray(2)
        self.rreg_buf = bytearray(1)
        self.recv_buf = bytearray(16)
        self.recv_mv = memoryview(self.recv_buf)
        self.maxdata = datasize
        self.card_data_buf = bytearray(16)

        self.phys_init()
        self.last_access = time.ticks_ms()
        self.access_interval = 500  # only allow reads every 500ms

        Device.__init__(self,
                        name,
                        spi,
                        on_change=on_change,
                        report_change=report_change,
                        filter=filter)