simo 2.8.14__py3-none-any.whl → 2.9.1__py3-none-any.whl

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()

simo/fleet/forms.py

@@ -1,10 +1,11 @@
 import time
+import datetime
 from django import forms
 from django.utils.translation import gettext_lazy as _
 from django.forms import formset_factory
 from django.urls.base import get_script_prefix
 from django.contrib.contenttypes.models import ContentType
-from dal import autocomplete
+from django.utils import timezone
 from dal import forward
 from simo.core.models import Component
 from simo.core.forms import (
@@ -24,7 +25,7 @@ from simo.core.form_fields import (
 )
 from simo.core.form_fields import PlainLocationField
 from simo.users.models import PermissionsRole
-from .models import Colonel, ColonelPin, Interface
+from .models import Colonel, ColonelPin, Interface, CustomDaliDevice
 from .utils import INTERFACES_PINS_MAP, get_all_control_input_choices
 
 
@@ -1817,4 +1818,132 @@ class DALILightSensorConfigForm(DALIDeviceConfigForm, BaseComponentForm):
 
 
 class DALIButtonConfigForm(DALIDeviceConfigForm, BaseComponentForm):
-    pass
+    pass
+
+
+class CustomDaliDeviceForm(BaseComponentForm):
+    device = forms.ChoiceField()
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        choices = []
+        instance = get_current_instance()
+        for colonel in Colonel.objects.filter(
+                type='room-sensor', instance=instance
+        ):
+            if not colonel.is_connected:
+                continue
+            choices.append((f"wifi-{colonel.id}", colonel.name))
+        for device in CustomDaliDevice.objects.filter(
+                instance=instance,
+                last_seen__gt=timezone.now() - datetime.timedelta(minutes=10)
+        ):
+            choices.append((f"dali-{device.id}", device.name))
+        self.fields['device'].choices = choices
+
+    def get_device(self, field_val):
+        if field_val.startswith('wifi'):
+            return Colonel.objects.filter(
+                id=self.cleaned_data['device'][5:]
+            ).first()
+        else:
+            return CustomDaliDevice.objects.filter(
+                id=self.cleaned_data['device'][5:]
+            )
+
+
+class RoomSensorDeviceConfigForm(CustomDaliDeviceForm):
+
+    def save(self, commit=True):
+        from simo.core.models import Icon
+        colonel = None
+        dali_device = None
+        device = self.get_device(self.cleaned_data['device'])
+        if not device:
+            return
+        if isinstance(device, CustomDaliDevice):
+            dali_device = device
+        else:
+            colonel = device
+
+        from .controllers import (
+            AirQualitySensor, TempHumSensor, AmbientLightSensor,
+            RoomPresenceSensor
+        )
+
+        org_name = self.cleaned_data['name']
+        org_icon = self.cleaned_data['icon']
+        for CtrlClass, icon, suffix in (
+            (AirQualitySensor, 'leaf', 'air quality'),
+            (TempHumSensor, 'temperature-half', 'temperature'),
+            (AmbientLightSensor, 'brightness-low', 'brightness'),
+            (RoomPresenceSensor, 'person', 'presence')
+        ):
+            default_icon = Icon.objects.filter(slug=icon).first()
+            if default_icon:
+                self.cleaned_data['icon'] = default_icon.slug
+            else:
+                self.cleaned_data['icon'] = org_icon
+            self.cleaned_data['name'] = f"{org_name} {suffix}"
+
+            if colonel:
+                comp = Component.objects.filter(
+                    config__colonel=colonel.id,
+                    controller_uid=CtrlClass.uid
+                ).first()
+            else:
+                comp = Component.objects.filter(
+                    config__dali_device=dali_device.id,
+                    controller_uid=CtrlClass.uid
+                ).first()
+
+            form = CtrlClass.config_form(
+                controller_uid=CtrlClass.uid, instance=comp,
+                data=self.cleaned_data
+            )
+            if form.is_valid():
+                comp = form.save()
+                if colonel:
+                    comp.config['colonel'] = colonel.id
+                else:
+                    comp.config['dali_device'] = dali_device.id
+                comp.save()
+            else:
+                raise Exception(form.errors)
+
+        if colonel:
+            GatewayObjectCommand(
+                comp.gateway, colonel, id=comp.id,
+                command='call', method='update_config', args=[
+                    comp.controller._get_colonel_config()
+                ]
+            ).publish()
+
+        return comp
+
+
+class RoomZonePresenceConfigForm(CustomDaliDeviceForm):
+
+    def clean_device(self):
+        value = self.cleaned_data['device']
+        if value.startswith('wifi'):
+            return value
+        from .controllers import RoomZonePresenceSensor
+        dali_device = CustomDaliDevice.objects.filter(
+            id=value[5:]
+        ).first()
+        free_slots = {0, 1, 2, 3, 4, 5, 6, 7}
+        for comp in Component.objects.filter(
+            controller_uid=RoomZonePresenceSensor.uid,
+            config__dali_device=dali_device.id
+        ):
+            try:
+                free_slots.remove(int(comp.config['slot']))
+            except:
+                continue
+        if not free_slots:
+            raise forms.ValidationError(
+                "This device already has 8 zones defined. "
+                "Please first delete some to add a new one."
+            )
+        return value

simo/fleet/managers.py

@@ -8,7 +8,9 @@ class ColonelsManager(models.Manager):
         qs = super().get_queryset()
         instance = get_current_instance()
         if instance:
-            qs = qs.filter(instance__is_active=True)
+            qs = qs.filter(
+                instance__is_active=True
+            )
         return qs
 
 

simo/fleet/migrations/0045_alter_colonel_type_customdalidevice.py

@@ -0,0 +1,29 @@
+# Generated by Django 4.2.10 on 2025-04-03 14:35
+
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('core', '0049_alter_gateway_type'),
+        ('fleet', '0044_auto_20241210_0707'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='colonel',
+            name='type',
+            field=models.CharField(choices=[('4-relays', '4 Relay'), ('ample-wall', 'Ample Wall'), ('game-changer', 'Game Changer'), ('game-changer-mini', 'Game Changer Mini'), ('room-sensor', 'Room Sensor')], default='ample-wall', max_length=20),
+        ),
+        migrations.CreateModel(
+            name='CustomDaliDevice',
+            fields=[
+                ('random_address', models.PositiveIntegerField(primary_key=True, serialize=False)),
+                ('name', models.CharField(help_text='User given name on initial pairing', max_length=200)),
+                ('colonel', models.ForeignKey(blank=True, editable=False, help_text='Colonel on which it has already appeared.', null=True, on_delete=django.db.models.deletion.SET_NULL, to='fleet.colonel')),
+                ('instance', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='core.instance')),
+            ],
+        ),
+    ]

simo/fleet/migrations/0046_delete_customdalidevice.py

@@ -0,0 +1,16 @@
+# Generated by Django 4.2.10 on 2025-04-04 05:28
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('fleet', '0045_alter_colonel_type_customdalidevice'),
+    ]
+
+    operations = [
+        migrations.DeleteModel(
+            name='CustomDaliDevice',
+        ),
+    ]

simo/fleet/migrations/0047_customdalidevice.py

@@ -0,0 +1,28 @@
+# Generated by Django 4.2.10 on 2025-04-04 05:32
+
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('core', '0049_alter_gateway_type'),
+        ('fleet', '0046_delete_customdalidevice'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='CustomDaliDevice',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('random_address', models.PositiveIntegerField(db_index=True, editable=False)),
+                ('name', models.CharField(help_text='User given name on initial pairing', max_length=200)),
+                ('colonel', models.ForeignKey(blank=True, editable=False, help_text='Colonel on which it has already appeared.', null=True, on_delete=django.db.models.deletion.SET_NULL, to='fleet.colonel')),
+                ('instance', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='core.instance')),
+            ],
+            options={
+                'unique_together': {('instance', 'random_address')},
+            },
+        ),
+    ]

simo/fleet/migrations/0048_remove_customdalidevice_colonel_and_more.py

@@ -0,0 +1,28 @@
+# Generated by Django 4.2.10 on 2025-04-07 07:27
+
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('fleet', '0047_customdalidevice'),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name='customdalidevice',
+            name='colonel',
+        ),
+        migrations.AddField(
+            model_name='customdalidevice',
+            name='interface',
+            field=models.ForeignKey(blank=True, editable=False, help_text='Colonel interface on which it operates.', null=True, on_delete=django.db.models.deletion.SET_NULL, to='fleet.interface'),
+        ),
+        migrations.AddField(
+            model_name='customdalidevice',
+            name='last_seen',
+            field=models.DateTimeField(editable=False, null=True),
+        ),
+    ]

simo/fleet/models.py

@@ -1,5 +1,6 @@
 import requests
 import time
+import random
 from actstream import action
 from django.core.exceptions import ValidationError
 from django.db import transaction
@@ -61,6 +62,7 @@ class Colonel(DirtyFieldsMixin, models.Model):
             ('ample-wall', "Ample Wall"),
             ('game-changer', "Game Changer"),
             ('game-changer-mini', "Game Changer Mini"),
+            ('room-sensor', "Room Sensor")
         )
     )
     firmware_version = models.CharField(
@@ -258,7 +260,7 @@ class ColonelPin(models.Model):
 @receiver(post_save, sender=Colonel)
 def after_colonel_save(sender, instance, created, *args, **kwargs):
     if created:
-        for no, data in GPIO_PINS.get(instance.type).items():
+        for no, data in GPIO_PINS.get(instance.type, {}).items():
             ColonelPin.objects.get_or_create(
                 colonel=instance, no=no,
                 defaults={
@@ -306,11 +308,13 @@ def post_component_save(sender, instance, created, *args, **kwargs):
     colonel.components.add(instance)
     from .controllers import (
         TTLock, DALILamp, DALIGearGroup, DALIRelay, DALIOccupancySensor,
-        DALILightSensor, DALIButton
+        DALILightSensor, DALIButton,
+        AirQualitySensor, TempHumSensor, AmbientLightSensor, RoomPresenceSensor
     )
     if instance.controller and instance.controller_cls in (
         TTLock, DALILamp, DALIGearGroup, DALIRelay, DALIOccupancySensor,
-        DALILightSensor, DALIButton
+        DALILightSensor, DALIButton,
+        AirQualitySensor, TempHumSensor, AmbientLightSensor, RoomPresenceSensor
     ):
         return
     colonel.rebuild_occupied_pins()
@@ -466,16 +470,13 @@ def post_interface_save(sender, instance, created, *args, **kwargs):
                 address=addr,
             )
     elif instance.type == 'dali':
-        InterfaceAddress.objects.filter(
-            interface=instance
-        ).exclude(address_type__startswith='dali').delete()
         for addr in range(64):
-            InterfaceAddress.objects.create(
+            InterfaceAddress.objects.get_or_create(
                 interface=instance, address_type='dali-gear',
                 address=addr,
             )
         for addr in range(16):
-            InterfaceAddress.objects.create(
+            InterfaceAddress.objects.get_or_create(
                 interface=instance, address_type='dali-group',
                 address=addr,
             )
@@ -492,4 +493,48 @@ def post_interface_delete(sender, instance, *args, **kwargs):
             occupied_by_content_type=ct,
             occupied_by_id=instance.id
         ):
-            pin.occupied_by_content_type = None
+            pin.occupied_by_content_type = None
+
+
+class CustomDaliDevice(models.Model):
+    '''
+    Our own custom dali line device, 
+    not compatible with anything else of DALI!
+    '''
+    instance = models.ForeignKey(Instance, on_delete=models.CASCADE)
+    random_address = models.PositiveIntegerField(db_index=True, editable=False)
+    name = models.CharField(
+        max_length=200, help_text="User given name on initial pairing"
+    )
+    interface = models.ForeignKey(
+        Interface, null=True, blank=True, editable=False,
+        on_delete=models.SET_NULL, related_name='custom_devices',
+        help_text="Colonel interface on which it operates."
+    )
+    last_seen = models.DateTimeField(null=True, editable=False)
+
+    class Meta:
+        unique_together = 'instance', 'random_address'
+
+    def save(self, *args, **kwargs):
+        if not self.random_address:
+            while True:
+                self.random_address = random.randint(0, 255)
+                if CustomDaliDevice.objects.filter(
+                    random_address=self.random_address,
+                    instance=self.instance
+                ).first():
+                    continue
+                break
+        return super().save(*args, **kwargs)
+
+    def transmit(self, frame):
+        from .gateways import FleetGatewayHandler
+        frame[0:7] = self.random_address
+        gateway = Gateway.objects.filter(type=FleetGatewayHandler.uid).first()
+        GatewayObjectCommand(
+            gateway, self.interface.colonel,
+            command='da-tx', interface=self.interface.no,
+            msg=frame.pack.hex()
+        ).publish()
+

simo/fleet/serializers.py

@@ -1,6 +1,8 @@
 from rest_framework import serializers
 from simo.core.serializers import TimestampField
-from .models import InstanceOptions, Colonel, ColonelPin, Interface
+from .models import (
+    InstanceOptions, Colonel, ColonelPin, Interface, CustomDaliDevice
+)
 
 
 class InstanceOptionsSerializer(serializers.ModelSerializer):
@@ -84,3 +86,15 @@ class ColonelSerializer(serializers.ModelSerializer):
         instance = super().update(instance, validated_data)
         instance.update_config()
         return instance
+
+
+class CustomDaliDeviceSerializer(serializers.ModelSerializer):
+
+    class Meta:
+        model = CustomDaliDevice
+        fields = 'id', 'random_address', 'name'
+        read_only_fields = 'random_address',
+
+    def create(self, validated_data):
+        validated_data['instance'] = self.context['instance']
+        return super().create(validated_data)