feat: binary signal

Editor/Scripts/Inspector/SignalBinary.cs

@@ -0,0 +1,41 @@
+using OC.VisualElements;
+using UnityEditor;
+using UnityEditor.UIElements;
+using UnityEngine;
+using UnityEngine.UIElements;
+
+namespace OC.Editor.Inspector
+{
+    [CustomEditor(typeof(Components.SignalBinary), true), CanEditMultipleObjects]
+    public class SignalBinary : UnityEditor.Editor
+    {
+        public override VisualElement CreateInspectorGUI()
+        {
+            var component = target as Components.SignalBinary;
+            if (component == null) return null;
+
+            var container = new VisualElement();
+
+            var groupControl = new PropertyGroup("Control");
+            groupControl.AddOverrideOption(component);
+            groupControl.Add(new ToggleButton("Signal").BindProperty(component.Signal).AlignedField());
+
+            var groupStatus = new PropertyGroup("Status");
+            groupStatus.Add(new LampField("Value", Color.green).BindProperty(component.Value).AlignedField());
+
+            var groupSettings = new PropertyGroup("Settings");
+            groupSettings.Add(new PropertyField{bindingPath = "_device"});
+
+            var groupEvents = new PropertyGroup("Events");
+            groupEvents.Add(new PropertyField{bindingPath = "OnValueChangedEvent"});
+
+            container.Add(groupControl);
+            container.Add(groupStatus);
+            container.Add(groupSettings);
+            container.Add(new PropertyField{bindingPath = "_link"});
+            container.Add(groupEvents);
+
+            return container;
+        }
+    }
+}

Runtime/Scripts/Components/SignalBinary.cs

@@ -0,0 +1,92 @@
+using OC.Communication;
+using UnityEngine;
+using UnityEngine.Events;
+
+namespace OC.Components
+{
+    [AddComponentMenu("Open Commissioning/Signal Binary")]
+    [SelectionBase]
+    [DisallowMultipleComponent]
+    public class SignalBinary : MonoComponent, IDevice, IMeasurement<bool>, IControlOverridable, ICustomInspector, IInteractable
+    {
+        public Link Link => _link;
+        public IProperty<bool> Override => _override;
+        public IPropertyReadOnly<bool> Value => _value;
+        public IProperty<bool> Signal => _signal;
+
+        public UnityEvent<bool> OnValueChangedEvent;
+
+        [SerializeField]
+        protected Property<bool> _override = new (false);
+        [SerializeField]
+        protected Property<bool> _value = new (false);
+        [SerializeField]
+        protected Property<bool> _signal = new (false);
+        [SerializeField]
+        private Component _device;
+        [SerializeField]
+        private Link _link;
+
+        private Connector _connector;
+        private bool _isMeasurementDeviceValid;
+        private IMeasurement<bool> _measurementDevice;
+
+        private void OnEnable()
+        {
+            _signal.ValueChanged += OnSignalChanged;
+            _value.ValueChanged += OnValueChanged;
+        }
+
+        private void OnDisable()
+        {
+            _signal.ValueChanged -= OnSignalChanged;
+            _value.ValueChanged -= OnValueChanged;
+        }
+
+        private void Start()
+        {
+            _link.Initialize(this);
+            _connector = new Connector(_link);
+            GetMeasurementDevice();
+            OnValueChanged(_value.Value);
+        }
+
+        private void Reset()
+        {
+            _link = new Link(this, "FB_SensorBinary");
+        }
+
+        private void OnSignalChanged(bool value)
+        {
+            _value.Value = value;
+        }
+
+        private void OnValueChanged(bool value)
+        {
+            _connector.Status.SetBit(0, value);
+            OnValueChangedEvent?.Invoke(value);
+        }
+
+        private void GetMeasurementDevice()
+        {
+            _isMeasurementDeviceValid = false;
+
+            if (_device == null) return;
+            if (_device is IMeasurement<bool> device)
+            {
+                _isMeasurementDeviceValid = true;
+                _measurementDevice = device;
+                _measurementDevice.Value.ValueChanged += OnDeviceValueChanged;
+                OnDeviceValueChanged(_measurementDevice.Value.Value);
+            }
+
+            if (!_isMeasurementDeviceValid) Logging.Logger.Log(LogType.Error, "Device reference isn't valid! IMeasurementDevice is required!", this);
+        }
+
+        private void OnDeviceValueChanged(bool value)
+        {
+            if (_override) return;
+            _signal.Value = value;
+        }
+    }
+}