simo 2.8.15__py3-none-any.whl → 2.10.1__py3-none-any.whl

simo/fleet/controllers.py

@@ -1,4 +1,4 @@
-import json
+import json, ast
 from django.utils.translation import gettext_lazy as _
 from django.db.transaction import atomic
 from simo.core.middleware import get_current_instance
@@ -9,7 +9,7 @@ from simo.core.controllers import (
     NumericSensor as BaseNumericSensor,
     Switch as BaseSwitch, Dimmer as BaseDimmer,
     MultiSensor as BaseMultiSensor, RGBWLight as BaseRGBWLight,
-    Blinds as BaseBlinds, Gate as BaseGate
+    Blinds as BaseBlinds, Gate as BaseGate,
 )
 from simo.core.app_widgets import NumericSensorWidget, AirQualityWidget
 from simo.core.controllers import Lock, ControllerBase, SingleSwitchWidget
@@ -17,7 +17,8 @@ from simo.core.utils.helpers import heat_index
 from simo.core.utils.serialization import (
     serialize_form_data, deserialize_form_data
 )
-from .models import Colonel
+from simo.core.forms import BaseComponentForm
+from .models import Colonel, CustomDaliDevice
 from .gateways import FleetGatewayHandler
 from .forms import (
     ColonelPinChoiceField,
@@ -31,7 +32,8 @@ from .forms import (
     TTLockConfigForm, DALIDeviceConfigForm, DaliLampForm, DaliGearGroupForm,
     DaliSwitchConfigForm,
     DaliOccupancySensorConfigForm, DALILightSensorConfigForm,
-    DALIButtonConfigForm
+    DALIButtonConfigForm, RoomSensorDeviceConfigForm,
+    RoomZonePresenceConfigForm
 )
 
 
@@ -465,7 +467,7 @@ class TTLock(FleeDeviceMixin, Lock):
     discovery_msg = _("Please activate your TTLock so it can be discovered.")
 
     @classmethod
-    def init_discovery(self, form_cleaned_data):
+    def _init_discovery(self, form_cleaned_data):
         from simo.core.models import Gateway
         print("INIT discovery form cleaned data: ", form_cleaned_data)
         print("Serialized form: ", serialize_form_data(form_cleaned_data))
@@ -663,7 +665,7 @@ class DALIDevice(FleeDeviceMixin, ControllerBase):
         return value
 
     @classmethod
-    def init_discovery(self, form_cleaned_data):
+    def _init_discovery(self, form_cleaned_data):
         from simo.core.models import Gateway
         gateway = Gateway.objects.filter(type=self.gateway_class.uid).first()
         gateway.start_discovery(
@@ -824,4 +826,235 @@ class DALIButton(BaseButton, DALIDevice):
     family = 'dali'
     manual_add = False
     name = 'DALI Button'
-    config_form = DALIButtonConfigForm
+    config_form = DALIButtonConfigForm
+
+
+class RoomSensor(FleeDeviceMixin, ControllerBase):
+    gateway_class = FleetGatewayHandler
+    config_form = RoomSensorDeviceConfigForm
+    name = "Room Sensor"
+    base_type = 'room-sensor'
+    default_value = 0
+    app_widget = NumericSensorWidget
+
+    def _validate_val(self, value, occasion=None):
+        return value
+
+
+class AirQualitySensor(FleeDeviceMixin, BaseMultiSensor):
+    gateway_class = FleetGatewayHandler
+    config_form = BaseComponentForm
+    name = "Air Quality Sensor"
+    app_widget = AirQualityWidget
+    manual_add = False
+
+    default_value = [
+        ["TVOC", 0, "ppb"],
+        ["AQI (UBA)", 0, ""]
+    ]
+
+    def _receive_from_device(self, value, *args, **kwargs):
+        aqi = 5
+        if value < 812:
+            aqi = 4
+        if value < 325:
+            aqi = 3
+        if value < 162:
+            aqi = 2
+        if value < 65:
+            aqi = 1
+        value = [
+            ["TVOC", value, "ppb"],
+            ["AQI (UBA)", aqi, ""]
+        ]
+        return super()._receive_from_device(value, *args, **kwargs)
+
+    def get_tvoc(self):
+        try:
+            for entry in self.component.value:
+                if entry[0] == 'TVOC':
+                    return entry[1]
+        except:
+            return
+
+    def get_aqi(self):
+        try:
+            for entry in self.component.value:
+                if entry[0] == 'AQI (UBA)':
+                    return entry[1]
+        except:
+            return
+
+
+class TempHumSensor(FleeDeviceMixin, BasicSensorMixin, BaseMultiSensor):
+    gateway_class = FleetGatewayHandler
+    config_form = BaseComponentForm
+    name = "Temperature & Humidity sensor"
+    app_widget = NumericSensorWidget
+    manual_add = False
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.sys_temp_units = 'C'
+        if hasattr(self.component, 'zone') \
+                and self.component.zone.instance.units_of_measure == 'imperial':
+            self.sys_temp_units = 'F'
+
+    @property
+    def default_value(self):
+        return [
+            ['temperature', 0, self.sys_temp_units],
+            ['humidity', 20, '%'],
+            ['real_feel', 0, self.sys_temp_units]
+        ]
+
+    def _receive_from_device(self, value, *args, **kwargs):
+
+        if isinstance(value, dict):
+            temp = value['temp']
+            humidity = value['humidity']
+        else:
+            buf = bytes.fromhex(value)
+            humidity = (
+                (buf[0] << 12) | (buf[1] << 4) | (buf[2] >> 4)
+            )
+            humidity = (humidity * 100) / 0x100000
+            humidity = int(round(humidity, 0))
+            temp = ((buf[2] & 0xF) << 16) | (buf[3] << 8) | buf[4]
+            temp = ((temp * 200.0) / 0x100000) - 50
+            temp = round(temp, 1)
+
+        new_val = [
+            ['temperature', temp, self.sys_temp_units],
+            ['humidity', humidity, '%'],
+            ['real_feel', 0, self.sys_temp_units]
+        ]
+
+        if self.sys_temp_units == 'F':
+            new_val[0][1] = round((new_val[0][1] * 9 / 5) + 32, 1)
+
+        real_feel = heat_index(
+            new_val[0][1], new_val[1][1], self.sys_temp_units == 'F'
+        )
+        new_val[2] = ['real_feel', real_feel, self.sys_temp_units]
+
+        return super()._receive_from_device(new_val, *args, **kwargs)
+
+
+class AmbientLightSensor(FleeDeviceMixin, BaseNumericSensor):
+    gateway_class = FleetGatewayHandler
+    name = "Ambient lighting sensor"
+    manual_add = False
+    default_config = {
+        'widget': 'numeric-sensor',
+        'value_units': 'lux',
+        'limits': [
+            {"name": "Dark", "value": 20},
+            {"name": "Moderate", "value": 300},
+            {"name": "Bright", "value": 800},
+        ]
+    }
+
+
+class RoomPresenceSensor(FleeDeviceMixin, BaseBinarySensor):
+    gateway_class = FleetGatewayHandler
+    name = "Human presence sensor"
+    manual_add = False
+
+
+class RoomZonePresenceSensor(FleeDeviceMixin, BaseBinarySensor):
+    gateway_class = FleetGatewayHandler
+    add_form = RoomZonePresenceConfigForm
+    config_form = BaseComponentForm
+    name = "Room zone presence"
+    discovery_msg = _(
+        "Move vigorously in particular zone of the room, "
+        "where presence needs to be detected. "
+        "Your movements are being recorded. "
+        "Hit Done, once you are done."
+    )
+
+    @classmethod
+    def _init_discovery(self, form_cleaned_data):
+        from simo.core.models import Gateway
+        gateway = Gateway.objects.filter(type=self.gateway_class.uid).first()
+        gateway.start_discovery(
+            self.uid, serialize_form_data(form_cleaned_data),
+            timeout=60
+        )
+        if form_cleaned_data['device'].startswith('wifi'):
+            colonel = Colonel.objects.filter(
+                id=form_cleaned_data['device'][5:]
+            ).first()
+            GatewayObjectCommand(
+                gateway, colonel,
+                command='discover', type=self.uid.split('.')[-1],
+            ).publish()
+        else:
+            dali_device = CustomDaliDevice.objects.filter(
+                id=form_cleaned_data['device'][5:]
+            ).first()
+            from .custom_dali_operations import Frame
+            frame = Frame(40, bytes(bytearray(5)))
+            frame[8:11] = 15 # command to custom dali device
+            frame[12:15] = 0 # action to perform: start room zone discovery
+            dali_device.transmit(frame)
+
+
+    @classmethod
+    @atomic
+    def _finish_discovery(cls, started_with):
+        started_with = deserialize_form_data(started_with)
+        form = cls.add_form(
+            controller_uid=cls.uid, data=started_with
+        )
+        form.is_valid()
+        if form.cleaned_data['device'].startswith('wifi'):
+            form.instance.alive = False
+            form.instance.config['colonel'] = int(
+                form.cleaned_data['device'][5:]
+            )
+            new_component = form.save()
+            GatewayObjectCommand(
+                new_component.gateway, Colonel(
+                    id=new_component.config['colonel']
+                ), command='finalize',
+                data={
+                    'comp_config': {
+                        'type': str(cls).split('.')[-1],
+                        'family': new_component.controller.family,
+                        'config': json.loads(json.dumps(new_component.config))
+                    }
+                }
+            ).publish()
+        else:
+            from simo.core.models import Component
+            dali_device = CustomDaliDevice.objects.filter(
+                id=form.cleaned_data['device'][5:]
+            ).first()
+            free_slots = {0, 1, 2, 3, 4, 5, 6, 7}
+            for comp in Component.objects.filter(
+                controller_uid=cls.uid, config__dali_device=dali_device.id
+            ):
+                try:
+                    free_slots.remove(int(comp.config['slot']))
+                except:
+                    continue
+            if not free_slots:
+                return []
+
+            form.instance.alive = False
+            form.instance.config['dali_device'] = int(
+                form.cleaned_data['device'][5:]
+            )
+            form.instance.config['slot'] = free_slots.pop()
+            new_component = form.save()
+            from .custom_dali_operations import Frame
+            frame = Frame(40, bytes(bytearray(5)))
+            frame[8:11] = 15  # command to custom dali device
+            frame[12:15] = 1  # action to perform: stop room zone discovery
+            frame[16:18] = new_component.config['slot']
+            dali_device.transmit(frame)
+
+        print("NEW COMPONENT: ", new_component)
+        return new_component

simo/fleet/custom_dali_operations.py

@@ -0,0 +1,275 @@
+from django.utils import timezone
+from simo.core.models import Component
+from .models import Interface, CustomDaliDevice
+from .controllers import (
+    TempHumSensor, AirQualitySensor, AmbientLightSensor,
+    RoomPresenceSensor, RoomZonePresenceSensor
+)
+
+
+class Frame:
+    """A DALI frame.
+
+    A Frame consists of one start bit, n data bits, and one stop
+    condition.  The most significant bit is always transmitted first.
+
+    Instances of this object are mutable.
+    """
+
+    def __init__(self, bits, data=0):
+        """Initialise a Frame with the supplied number of data bits.
+
+        :parameter bits: the number of data bits in the Frame
+        :parameter data: initial data for the Frame as an integer or
+        an iterable sequence of integers
+        """
+        if not isinstance(bits, int):
+            raise TypeError(
+                "Number of bits must be an integer")
+        if bits < 1:
+            raise ValueError(
+                "Frames must contain at least 1 data bit")
+        self._bits = bits
+        if isinstance(data, int):
+            self._data = data
+        else:
+            self._data = int.from_bytes(data, 'big')
+        if self._data < 0:
+            raise ValueError("Initial data must not be negative")
+        if len(self.pack) > bits:
+            raise ValueError(
+                "Initial data will not fit in {} bits".format(bits))
+        self._error = False
+
+    @property
+    def error(self):
+        """Frame was received with a framing error."""
+        return self._error
+
+    def __len__(self):
+        return self._bits
+
+    def __eq__(self, other):
+        try:
+            return self._bits == other._bits and self._data == other._data
+        except Exception:
+            return False
+
+    def __ne__(self, other):
+        try:
+            return self._bits != other._bits or self._data != other._data
+        except Exception:
+            return True
+
+    def _readslice(self, key):
+        """Check that a slice is valid, return indices
+
+        The slice must have indices that are integers.  The indices
+        must be in the range 0..(len(self)-1).
+        """
+        if not isinstance(key.start, int) or not isinstance(key.stop, int):
+            raise TypeError("slice indices must be integers")
+        if key.step not in (None, 1):
+            raise TypeError("slice with step not supported")
+        hi = max(key.start, key.stop)
+        lo = min(key.start, key.stop)
+        if hi < 0 or lo < 0:
+            raise IndexError("slice indices must be >= 0")
+        if hi >= self._bits or lo >= self._bits:
+            raise IndexError("slice index out of range")
+        return hi, lo
+
+    def __getitem__(self, key):
+        """Read a bit or group of bits from the frame
+
+        If the key is an integer, return that bit as True or False or
+        raise IndexError if the key is out of bounds.
+
+        If the key is a slice, return that slice as an integer or
+        raise IndexError if out of bounds.  We abuse the slice
+        mechanism slightly such that slice(5,7) and slice(7,5) are
+        treated the same.  Slices with a step or a negative index are
+        not supported.
+        """
+        if isinstance(key, slice):
+            hi, lo = self._readslice(key)
+            d = self._data >> lo
+            return d & ((1 << (hi + 1 - lo)) - 1)
+        elif isinstance(key, int):
+            if key < 0 or key >= self._bits:
+                raise IndexError("index out of range")
+            return (self._data & (1 << key)) != 0
+        raise TypeError
+
+    def __setitem__(self, key, value):
+        """Write a bit or a group of bits to the frame
+
+        If the key is an integer, set that bit to the truth value of
+        value or raise IndexError if the key is out of bounds.
+
+        If the key is a slice, value must be an integer that fits
+        within the slice; set that slice to value or raise IndexError
+        if out of bounds.  We abuse the slice mechanism slightly such
+        that slice(5,7) and slice(7,5) are treated the same.  Slices
+        with a step or a negative index are not supported.
+        """
+        if isinstance(key, slice):
+            hi, lo = self._readslice(key)
+            if not isinstance(value, int):
+                raise TypeError("value must be an integer")
+            if len(bin(value)) - 2 > (hi + 1 - lo):
+                raise ValueError("value will not fit in supplied slice")
+            if value < 0:
+                raise ValueError("value must not be negative")
+            template = ((1 << hi + 1 - lo) - 1) << lo
+            mask = ((1 << self._bits) - 1) ^ template
+            self._data = self._data & mask | (value << lo)
+        elif isinstance(key, int):
+            if key < 0 or key >= self._bits:
+                raise IndexError("index out of range")
+            if value:
+                self._data = self._data | (1 << key)
+            else:
+                self._data = self._data \
+                    & (((1 << self._bits) - 1) ^ (1 << key))
+        else:
+            raise TypeError
+
+    def __contains__(self, item):
+        if item is True:
+            return self._data != 0
+        if item is False:
+            return self._data != (1 << self._bits) - 1
+        return False
+
+    def __add__(self, other):
+        try:
+            return Frame(self._bits + other._bits,
+                         self._data << other._bits | other._data)
+        except Exception:
+            raise TypeError("Frame can only be added to another Frame")
+
+    @property
+    def as_integer(self):
+        """The contents of the frame represented as an integer."""
+        return self._data
+
+    @property
+    def as_byte_sequence(self):
+        """The contents of the frame represented as a sequence.
+
+        Returns a sequence of integers each in the range 0..255
+        representing the data in the frame, with the most-significant
+        bits first.  If the frame is not an exact multiple of 8 bits
+        long, the first element in the sequence contains fewer than 8
+        bits.
+        """
+        return list(self.pack)
+
+    @property
+    def pack(self):
+        """The contents of the frame represented as a byte string.
+
+        If the frame is not an exact multiple of 8 bits long, the
+        first byte in the string will contain fewer than 8 bits.
+        """
+        return self._data.to_bytes(
+            (len(self) // 8) + (1 if len(self) % 8 else 0),
+            'big')
+
+    def pack_len(self, l):
+        """The contents of the frame represented as a fixed length byte string.
+
+        The least significant bit of the frame is aligned to the end
+        of the byte string.  The start of the byte string is padded
+        with zeroes.
+
+        If the frame will not fit in the byte string, raises
+        OverflowError.
+        """
+        return self._data.to_bytes(l, 'big')
+
+    def __str__(self):
+        return "{}({},{})".format(self.__class__.__name__, len(self),
+                                  self.as_byte_sequence)
+
+
+def process_frame(colonel_id, interface_no, data):
+    interface = Interface.objects.filter(
+        colonel_id=colonel_id, no=interface_no
+    ).first()
+    if not interface:
+        return
+
+    data = bytes.fromhex(data)
+    frame = Frame(len(data) * 8, data)
+
+    device_address = frame[0:7]
+    device = CustomDaliDevice.objects.filter(
+        random_address=device_address, instance=interface.colonel.instance
+    ).first()
+    if not device:
+        return
+
+    device.interface = interface
+    device.last_seen = timezone.now()
+    device.save()
+
+    print("Frame received: ", frame.pack)
+
+    if frame[8:11] == 0:
+        # climate and air quality data
+        temp = (frame[12:21] - 512) / 10
+        humidity = round(frame[22:27] / 64 * 100)
+        comp = Component.objects.filter(
+            controller_uid=TempHumSensor.uid, config__dali_device=device.id
+        ).first()
+        if comp:
+            comp.controller._receive_from_device({'temp': temp, 'humidity': humidity})
+        voc = frame[28:38]
+        comp = Component.objects.filter(
+            controller_uid=AirQualitySensor.uid, config__dali_device=device.id
+        ).first()
+        if comp:
+            comp.controller._receive_from_device(voc)
+
+    elif frame[8:11] == 1:
+        comp = Component.objects.filter(
+            controller_uid=AmbientLightSensor.uid, config__dali_device=device.id
+        ).first()
+        if comp:
+            comp.controller._receive_from_device(frame[12:22] * 2)
+        comp = Component.objects.filter(
+            controller_uid=RoomPresenceSensor.uid, config__dali_device=device.id
+        ).first()
+        if comp:
+            comp.controller._receive_from_device(frame[23])
+
+        zone_sensors = {}
+        for slot in range(8):
+            comp = Component.objects.filter(
+                controller_uid=RoomZonePresenceSensor.uid,
+                config__dali_device=device.id, config__slot=slot
+            ).first()
+            if comp:
+                zone_sensors[slot] = comp
+
+        for slot in range(8):
+            if frame[24 + slot * 2]:
+                comp = zone_sensors.get(slot)
+                if comp:
+                    comp.controller._receive_from_device(frame[25 + slot * 2])
+                else:
+                    # component no longer exists, probably deleted by user
+                    # need to inform device about that!
+                    f = Frame(40, bytes(bytearray(5)))
+                    f[8:11] = 15  # command to custom dali device
+                    f[12:15] = 2  # action to perform: delete zone sensor
+                    f[16:18] = slot
+                    device.transmit(f)
+            elif zone_sensors.get(slot):
+                # not yet picked up by the device itself or
+                # was never successfully created
+                if zone_sensors[slot].alive:
+                    zone_sensors[slot].alive = False
+                    zone_sensors[slot].save()