Merge pull request #596 from PepperDash/hotfix/dge-device-info

Hotfix/dge device info
Merge branch 'main' into hotfix/dge-device-info
2026-01-26 10:54:59 +00:00 · 2021-02-04 11:41:31 -07:00 · 2021-02-04 11:25:10 -07:00 · 2021-02-04 11:22:30 -07:00 · 2021-02-04 11:17:49 -07:00 · 2021-02-04 11:01:21 -07:00
8 changed files with 1520 additions and 1125 deletions
--- a/PepperDashEssentials/Room/Types/EssentialsHuddleVtc1Room.cs
+++ b/PepperDashEssentials/Room/Types/EssentialsHuddleVtc1Room.cs
@@ -597,12 +597,21 @@ namespace PepperDash.Essentials
                        if (VideoCodec.UsageTracker.InUseTracker.InUseFeedback.BoolValue)
                        {
                            Debug.Console(1, this, "Video Codec in use, deactivating standby on codec");
+                            VideoCodec.StandbyDeactivate();
                        }

                        if (VideoCodec.StandbyIsOnFeedback.BoolValue)
                        {
                            VideoCodec.StandbyDeactivate();
                        }
+                        else
+                        {
+                            Debug.Console(1, this, "Video codec not in standby. No need to wake.");
+                        }
+                    }
+                    else
+                    {
+                        Debug.Console(1, this, "Room OnFeedback state: {0}", OnFeedback.BoolValue);
                    }

                    // report back when done
--- a/Core/PepperDashEssentialsBase/Occupancy/CenOdtOccupancySensorBaseController.cs
+++ b/Core/PepperDashEssentialsBase/Occupancy/CenOdtOccupancySensorBaseController.cs
--- a/Core/PepperDashEssentialsBase/Occupancy/GlsOccupancySensorBaseController.cs
+++ b/Core/PepperDashEssentialsBase/Occupancy/GlsOccupancySensorBaseController.cs
@@ -13,448 +13,586 @@ using PepperDash.Essentials.Core.Bridges;

 namespace PepperDash.Essentials.Core
 {
-    [Description("Wrapper class for Single Technology GLS Occupancy Sensors")]
-    public class GlsOccupancySensorBaseController : CrestronGenericBridgeableBaseDevice, IOccupancyStatusProvider
-    {
-        public GlsOccupancySensorBase OccSensor { get; private set; }
+	[Description("Wrapper class for Single Technology GLS Occupancy Sensors")]
+    [ConfigSnippet("\"properties\": {\"control\": {\"method\": \"cresnet\",\"cresnetId\": \"97\"},\"enablePir\": true,\"enableLedFlash\": true,\"enableRawStates\":true,\"remoteTimeout\": 30,\"internalPhotoSensorMinChange\": 0,\"externalPhotoSensorMinChange\": 0}")]
+	public class GlsOccupancySensorBaseController : CrestronGenericBridgeableBaseDevice, IOccupancyStatusProvider
+	{
+        public GlsOccupancySensorPropertiesConfig PropertiesConfig { get; private set; }

-        public BoolFeedback RoomIsOccupiedFeedback { get; private set; }
+		public GlsOccupancySensorBase OccSensor { get; private set; }

-        public BoolFeedback GraceOccupancyDetectedFeedback { get; private set; }
+		public BoolFeedback RoomIsOccupiedFeedback { get; private set; }

-        public BoolFeedback RawOccupancyFeedback { get; private set; }
+		public BoolFeedback GraceOccupancyDetectedFeedback { get; private set; }

-        public BoolFeedback PirSensorEnabledFeedback { get; private set; }
+		public BoolFeedback RawOccupancyFeedback { get; private set; }

-        public BoolFeedback LedFlashEnabledFeedback { get; private set; }
+		public BoolFeedback PirSensorEnabledFeedback { get; private set; }

-        public BoolFeedback ShortTimeoutEnabledFeedback { get; private set; }
+		public BoolFeedback LedFlashEnabledFeedback { get; private set; }

-        public IntFeedback PirSensitivityInVacantStateFeedback { get; private set; }
+		public BoolFeedback ShortTimeoutEnabledFeedback { get; private set; }

-        public IntFeedback PirSensitivityInOccupiedStateFeedback { get; private set; }
+		public IntFeedback PirSensitivityInVacantStateFeedback { get; private set; }

-        public IntFeedback CurrentTimeoutFeedback { get; private set; }
+		public IntFeedback PirSensitivityInOccupiedStateFeedback { get; private set; }

-        public IntFeedback LocalTimoutFeedback { get; private set; }
+		public IntFeedback CurrentTimeoutFeedback { get; private set; }

-        public IntFeedback InternalPhotoSensorValue { get; set; }
+		public IntFeedback LocalTimoutFeedback { get; private set; }

-        public IntFeedback ExternalPhotoSensorValue { get; set; }
+		public IntFeedback InternalPhotoSensorValue { get; set; }

-        // Debug properties
-        public bool InTestMode { get; private set; }
+		public IntFeedback ExternalPhotoSensorValue { get; set; }

-        public bool TestRoomIsOccupiedFeedback { get; private set; }
+		// Debug properties
+		public bool InTestMode { get; private set; }

-        public Func<bool> RoomIsOccupiedFeedbackFunc
-        {
-            get
+		public bool TestRoomIsOccupiedFeedback { get; private set; }
+
+		public Func<bool> RoomIsOccupiedFeedbackFunc
+		{
+			get
+			{
+				return () => InTestMode ? TestRoomIsOccupiedFeedback : OccSensor.OccupancyDetectedFeedback.BoolValue;
+			}
+		}
+
+		public GlsOccupancySensorBaseController(string key, Func<DeviceConfig, GlsOccupancySensorBase> preActivationFunc,
+			DeviceConfig config)
+			: base(key, config.Name)
+		{
+            var props = config.Properties.ToObject<GlsOccupancySensorPropertiesConfig>();
+
+            if (props != null)
            {
-                return () => InTestMode ? TestRoomIsOccupiedFeedback : OccSensor.OccupancyDetectedFeedback.BoolValue;
-            }
-        }
-
-        public GlsOccupancySensorBaseController(string key, Func<DeviceConfig, GlsOccupancySensorBase> preActivationFunc,
-            DeviceConfig config)
-            : base(key, config.Name)
-        {
-
-
-            AddPreActivationAction(() =>
-            {
-                OccSensor = preActivationFunc(config);
-
-                RegisterCrestronGenericBase(OccSensor);
-
-                RegisterGlsOdtSensorBaseController(OccSensor);
-
-            });
-        }
-
-        public GlsOccupancySensorBaseController(string key, string name) : base(key, name) {}
-
-        protected void RegisterGlsOdtSensorBaseController(GlsOccupancySensorBase occSensor)
-        {
-            OccSensor = occSensor;
-
-            RoomIsOccupiedFeedback = new BoolFeedback(RoomIsOccupiedFeedbackFunc);
-
-            PirSensorEnabledFeedback = new BoolFeedback(() => OccSensor.PirEnabledFeedback.BoolValue);
-
-            LedFlashEnabledFeedback = new BoolFeedback(() => OccSensor.LedFlashEnabledFeedback.BoolValue);
-
-            ShortTimeoutEnabledFeedback = new BoolFeedback(() => OccSensor.ShortTimeoutEnabledFeedback.BoolValue);
-
-            PirSensitivityInVacantStateFeedback =
-                new IntFeedback(() => OccSensor.PirSensitivityInVacantStateFeedback.UShortValue);
-
-            PirSensitivityInOccupiedStateFeedback =
-                new IntFeedback(() => OccSensor.PirSensitivityInOccupiedStateFeedback.UShortValue);
-
-            CurrentTimeoutFeedback = new IntFeedback(() => OccSensor.CurrentTimeoutFeedback.UShortValue);
-
-            LocalTimoutFeedback = new IntFeedback(() => OccSensor.LocalTimeoutFeedback.UShortValue);
-
-            GraceOccupancyDetectedFeedback =
-                new BoolFeedback(() => OccSensor.GraceOccupancyDetectedFeedback.BoolValue);
-
-            RawOccupancyFeedback = new BoolFeedback(() => OccSensor.RawOccupancyFeedback.BoolValue);
-
-            InternalPhotoSensorValue = new IntFeedback(() => OccSensor.InternalPhotoSensorValueFeedback.UShortValue);
-
-            ExternalPhotoSensorValue = new IntFeedback(() => OccSensor.ExternalPhotoSensorValueFeedback.UShortValue);
-
-            OccSensor.BaseEvent += OccSensor_BaseEvent;
-
-            OccSensor.GlsOccupancySensorChange += OccSensor_GlsOccupancySensorChange;
-        }
-
-
-        /// <summary>
-        /// Catches events for feedbacks on the base class.  Any extending wrapper class should call this delegate after it checks for it's own event IDs.
-        /// </summary>
-        /// <param name="device"></param>
-        /// <param name="args"></param>
-        protected virtual void OccSensor_GlsOccupancySensorChange(GlsOccupancySensorBase device, GlsOccupancySensorChangeEventArgs args)
-        {
-            switch (args.EventId)
-            {
-                case GlsOccupancySensorBase.PirEnabledFeedbackEventId:
-                    PirSensorEnabledFeedback.FireUpdate();
-                    break;
-                case GlsOccupancySensorBase.LedFlashEnabledFeedbackEventId:
-                    LedFlashEnabledFeedback.FireUpdate();
-                    break;
-                case GlsOccupancySensorBase.ShortTimeoutEnabledFeedbackEventId:
-                    ShortTimeoutEnabledFeedback.FireUpdate();
-                    break;
-                case GlsOccupancySensorBase.PirSensitivityInOccupiedStateFeedbackEventId:
-                    PirSensitivityInOccupiedStateFeedback.FireUpdate();
-                    break;
-                case GlsOccupancySensorBase.PirSensitivityInVacantStateFeedbackEventId:
-                    PirSensitivityInVacantStateFeedback.FireUpdate();
-                    break;
-            }
-        }
-
-        protected virtual void OccSensor_BaseEvent(Crestron.SimplSharpPro.GenericBase device, Crestron.SimplSharpPro.BaseEventArgs args)
-        {
-            Debug.Console(2, this, "GlsOccupancySensorChange  EventId: {0}", args.EventId);
-
-            switch (args.EventId)
-            {
-                case Crestron.SimplSharpPro.GeneralIO.GlsOccupancySensorBase.RoomVacantFeedbackEventId:
-                case Crestron.SimplSharpPro.GeneralIO.GlsOccupancySensorBase.RoomOccupiedFeedbackEventId:
-                    Debug.Console(1, this, "Occupancy State: {0}", OccSensor.OccupancyDetectedFeedback.BoolValue);
-                    RoomIsOccupiedFeedback.FireUpdate();
-                    break;
-                case GlsOccupancySensorBase.TimeoutFeedbackEventId:
-                    CurrentTimeoutFeedback.FireUpdate();
-                    break;
-                case GlsOccupancySensorBase.TimeoutLocalFeedbackEventId:
-                    LocalTimoutFeedback.FireUpdate();
-                    break;
-                case GlsOccupancySensorBase.GraceOccupancyDetectedFeedbackEventId:
-                    GraceOccupancyDetectedFeedback.FireUpdate();
-                    break;
-                case GlsOccupancySensorBase.RawOccupancyFeedbackEventId:
-                    RawOccupancyFeedback.FireUpdate();
-                    break;
-                case GlsOccupancySensorBase.InternalPhotoSensorValueFeedbackEventId:
-                    InternalPhotoSensorValue.FireUpdate();
-                    break;
-                case GlsOccupancySensorBase.ExternalPhotoSensorValueFeedbackEventId:
-                    ExternalPhotoSensorValue.FireUpdate();
-                    break;
-            }
-        }
-
-        public void SetTestMode(bool mode)
-        {
-            InTestMode = mode;
-
-            Debug.Console(1, this, "In Mock Mode: '{0}'", InTestMode);
-        }
-
-        public void SetTestOccupiedState(bool state)
-        {
-            if (!InTestMode)
-                Debug.Console(1, "Mock mode not enabled");
-            else
-            {
-                TestRoomIsOccupiedFeedback = state;
-
-                RoomIsOccupiedFeedback.FireUpdate();
-            }
-        }
-
-        /// <summary>
-        /// Enables or disables the PIR sensor
-        /// </summary>
-        /// <param name="state"></param>
-        public void SetPirEnable(bool state)
-        {
-            if (state)
-            {
-                OccSensor.EnablePir.BoolValue = state;
-                OccSensor.DisablePir.BoolValue = !state;
+                PropertiesConfig = props;
            }
            else
            {
-                OccSensor.EnablePir.BoolValue = state;
-                OccSensor.DisablePir.BoolValue = !state;
-            }            
-        }
-
-        /// <summary>
-        /// Enables or disables the LED Flash
-        /// </summary>
-        /// <param name="state"></param>
-        public void SetLedFlashEnable(bool state)
-        {
-            if (state)
-            {
-                OccSensor.EnableLedFlash.BoolValue = state;
-                OccSensor.DisableLedFlash.BoolValue = !state;
-            }
-            else
-            {
-                OccSensor.EnableLedFlash.BoolValue = state;
-                OccSensor.DisableLedFlash.BoolValue = !state;
-            }
-        }
-
-        /// <summary>
-        /// Enables or disables short timeout based on state
-        /// </summary>
-        /// <param name="state"></param>
-        public void SetShortTimeoutState(bool state)
-        {
-            if (state)
-            {
-                OccSensor.EnableShortTimeout.BoolValue = state;
-                OccSensor.DisableShortTimeout.BoolValue = !state;
-            }
-            else
-            {
-                OccSensor.EnableShortTimeout.BoolValue = state;
-                OccSensor.DisableShortTimeout.BoolValue = !state;
-            }
-        }
-
-        public void IncrementPirSensitivityInOccupiedState(bool pressRelease)
-        {
-            OccSensor.IncrementPirSensitivityInOccupiedState.BoolValue = pressRelease;
-        }
-
-        public void DecrementPirSensitivityInOccupiedState(bool pressRelease)
-        {
-            OccSensor.DecrementPirSensitivityInOccupiedState.BoolValue = pressRelease;
-        }
-
-        public void IncrementPirSensitivityInVacantState(bool pressRelease)
-        {
-            OccSensor.IncrementPirSensitivityInVacantState.BoolValue = pressRelease;
-        }
-
-        public void DecrementPirSensitivityInVacantState(bool pressRelease)
-        {
-            OccSensor.DecrementPirSensitivityInVacantState.BoolValue = pressRelease;
-        }
-
-        public void ForceOccupied()
-        {
-            OccSensor.ForceOccupied.BoolValue = true;
-        }
-
-        public void ForceVacant()
-        {
-            OccSensor.ForceVacant.BoolValue = true;
-        }
-
-        public void EnableRawStates(bool state)
-        {
-            OccSensor.EnableRawStates.BoolValue = state;
-        }
-
-        public void SetRemoteTimeout(ushort time)
-        {
-            OccSensor.RemoteTimeout.UShortValue = time;
-        }
-
-        public void SetInternalPhotoSensorMinChange(ushort value)
-        {
-            OccSensor.InternalPhotoSensorMinimumChange.UShortValue = value;
-        }
-
-        public void SetExternalPhotoSensorMinChange(ushort value)
-        {
-            OccSensor.ExternalPhotoSensorMinimumChange.UShortValue = value;
-        }
-
-
-
-        protected void LinkOccSensorToApi(GlsOccupancySensorBaseController occController, BasicTriList trilist,
-            uint joinStart, string joinMapKey, EiscApiAdvanced bridge)
-        {
-            var joinMap = new GlsOccupancySensorBaseJoinMap(joinStart);
-
-            var joinMapSerialized = JoinMapHelper.GetSerializedJoinMapForDevice(joinMapKey);
-
-            if (!string.IsNullOrEmpty(joinMapSerialized))
-                joinMap = JsonConvert.DeserializeObject<GlsOccupancySensorBaseJoinMap>(joinMapSerialized);
-
-            if (bridge != null)
-            {
-                bridge.AddJoinMap(Key, joinMap);
-            }
-            else
-            {
-                Debug.Console(0, this, "Please update config to use 'eiscapiadvanced' to get all join map features for this device.");
+                Debug.Console(1, this, "props are null.  Unable to deserialize into GlsOccupancySensorPropertiesConfig");
            }

-            Debug.Console(1, occController, "Linking to Trilist '{0}'", trilist.ID.ToString("X"));
+			AddPreActivationAction(() =>
+			{
+				OccSensor = preActivationFunc(config);

-            #region Single and Dual Sensor Stuff
-            occController.IsOnline.LinkInputSig(trilist.BooleanInput[joinMap.IsOnline.JoinNumber]);
-            trilist.StringInput[joinMap.Name.JoinNumber].StringValue = occController.Name;
+				RegisterCrestronGenericBase(OccSensor);

-            trilist.OnlineStatusChange += (d, args) =>
+				RegisterGlsOdtSensorBaseController(OccSensor);
+
+			});
+
+            AddPostActivationAction(() =>
            {
-                if (args.DeviceOnLine)
+                OccSensor.OnlineStatusChange += (o, a) =>
                {
-                    trilist.StringInput[joinMap.Name.JoinNumber].StringValue = occController.Name;
-                }
-            };
+                    if (a.DeviceOnLine)
+                    {
+                        ApplySettingsToSensorFromConfig();
+                    }
+                };
+            });            
+		}

-            // Occupied status
-            trilist.SetSigTrueAction(joinMap.ForceOccupied.JoinNumber, occController.ForceOccupied);
-            trilist.SetSigTrueAction(joinMap.ForceVacant.JoinNumber, occController.ForceVacant);
-            occController.RoomIsOccupiedFeedback.LinkInputSig(trilist.BooleanInput[joinMap.RoomOccupiedFeedback.JoinNumber]);
-            occController.RoomIsOccupiedFeedback.LinkComplementInputSig(trilist.BooleanInput[joinMap.RoomVacantFeedback.JoinNumber]);
-            occController.RawOccupancyFeedback.LinkInputSig(trilist.BooleanInput[joinMap.RawOccupancyFeedback.JoinNumber]);
-            trilist.SetBoolSigAction(joinMap.EnableRawStates.JoinNumber, occController.EnableRawStates);
-
-            // Timouts
-            trilist.SetUShortSigAction(joinMap.Timeout.JoinNumber, occController.SetRemoteTimeout);
-            occController.CurrentTimeoutFeedback.LinkInputSig(trilist.UShortInput[joinMap.Timeout.JoinNumber]);
-            occController.LocalTimoutFeedback.LinkInputSig(trilist.UShortInput[joinMap.TimeoutLocalFeedback.JoinNumber]);
-
-            // LED Flash
-            trilist.SetSigTrueAction(joinMap.EnableLedFlash.JoinNumber, () => occController.SetLedFlashEnable(true));
-            trilist.SetSigTrueAction(joinMap.DisableLedFlash.JoinNumber, () => occController.SetLedFlashEnable(false));
-            occController.LedFlashEnabledFeedback.LinkComplementInputSig(trilist.BooleanInput[joinMap.EnableLedFlash.JoinNumber]);
-
-            // Short Timeout
-            trilist.SetSigTrueAction(joinMap.EnableShortTimeout.JoinNumber, () => occController.SetShortTimeoutState(true));
-            trilist.SetSigTrueAction(joinMap.DisableShortTimeout.JoinNumber, () => occController.SetShortTimeoutState(false));
-            occController.ShortTimeoutEnabledFeedback.LinkInputSig(trilist.BooleanInput[joinMap.EnableShortTimeout.JoinNumber]);
-
-            // PIR Sensor
-            trilist.SetSigTrueAction(joinMap.EnablePir.JoinNumber, () => occController.SetPirEnable(true));
-            trilist.SetSigTrueAction(joinMap.DisablePir.JoinNumber, () => occController.SetPirEnable(false));
-            occController.PirSensorEnabledFeedback.LinkInputSig(trilist.BooleanInput[joinMap.EnablePir.JoinNumber]);
-
-            // PIR Sensitivity in Occupied State
-            trilist.SetBoolSigAction(joinMap.IncrementPirInOccupiedState.JoinNumber, occController.IncrementPirSensitivityInOccupiedState);
-            trilist.SetBoolSigAction(joinMap.DecrementPirInOccupiedState.JoinNumber, occController.DecrementPirSensitivityInOccupiedState);
-            occController.PirSensitivityInOccupiedStateFeedback.LinkInputSig(trilist.UShortInput[joinMap.PirSensitivityInOccupiedState.JoinNumber]);
-
-            // PIR Sensitivity in Vacant State
-            trilist.SetBoolSigAction(joinMap.IncrementPirInVacantState.JoinNumber, occController.IncrementPirSensitivityInVacantState);
-            trilist.SetBoolSigAction(joinMap.DecrementPirInVacantState.JoinNumber, occController.DecrementPirSensitivityInVacantState);
-            occController.PirSensitivityInVacantStateFeedback.LinkInputSig(trilist.UShortInput[joinMap.PirSensitivityInVacantState.JoinNumber]);
-            #endregion
-
-            #region Dual Technology Sensor Stuff
-            var odtOccController = occController as GlsOdtOccupancySensorController;
-
-            if (odtOccController == null) return;
-            // OR When Vacated
-            trilist.SetBoolSigAction(joinMap.OrWhenVacated.JoinNumber, odtOccController.SetOrWhenVacatedState);
-            odtOccController.OrWhenVacatedFeedback.LinkInputSig(trilist.BooleanInput[joinMap.OrWhenVacated.JoinNumber]);
-
-            // AND When Vacated
-            trilist.SetBoolSigAction(joinMap.AndWhenVacated.JoinNumber, odtOccController.SetAndWhenVacatedState);
-            odtOccController.AndWhenVacatedFeedback.LinkInputSig(trilist.BooleanInput[joinMap.AndWhenVacated.JoinNumber]);
-
-            // Ultrasonic A Sensor
-            trilist.SetSigTrueAction(joinMap.EnableUsA.JoinNumber, () => odtOccController.SetUsAEnable(true));
-            trilist.SetSigTrueAction(joinMap.DisableUsA.JoinNumber, () => odtOccController.SetUsAEnable(false));
-            odtOccController.UltrasonicAEnabledFeedback.LinkInputSig(trilist.BooleanInput[joinMap.EnableUsA.JoinNumber]);
-
-            // Ultrasonic B Sensor
-            trilist.SetSigTrueAction(joinMap.EnableUsB.JoinNumber, () => odtOccController.SetUsBEnable(true));
-            trilist.SetSigTrueAction(joinMap.DisableUsB.JoinNumber, () => odtOccController.SetUsBEnable(false));
-            odtOccController.UltrasonicAEnabledFeedback.LinkInputSig(trilist.BooleanInput[joinMap.EnableUsB.JoinNumber]);
-
-            // US Sensitivity in Occupied State
-            trilist.SetBoolSigAction(joinMap.IncrementUsInOccupiedState.JoinNumber, odtOccController.IncrementUsSensitivityInOccupiedState);
-            trilist.SetBoolSigAction(joinMap.DecrementUsInOccupiedState.JoinNumber, odtOccController.DecrementUsSensitivityInOccupiedState);
-            odtOccController.UltrasonicSensitivityInOccupiedStateFeedback.LinkInputSig(trilist.UShortInput[joinMap.UsSensitivityInOccupiedState.JoinNumber]);
-
-            // US Sensitivity in Vacant State
-            trilist.SetBoolSigAction(joinMap.IncrementUsInVacantState.JoinNumber, odtOccController.IncrementUsSensitivityInVacantState);
-            trilist.SetBoolSigAction(joinMap.DecrementUsInVacantState.JoinNumber, odtOccController.DecrementUsSensitivityInVacantState);
-            odtOccController.UltrasonicSensitivityInVacantStateFeedback.LinkInputSig(trilist.UShortInput[joinMap.UsSensitivityInVacantState.JoinNumber]);
-
-            //Sensor Raw States
-            odtOccController.RawOccupancyPirFeedback.LinkInputSig(trilist.BooleanInput[joinMap.RawOccupancyPirFeedback.JoinNumber]);
-            odtOccController.RawOccupancyUsFeedback.LinkInputSig(trilist.BooleanInput[joinMap.RawOccupancyUsFeedback.JoinNumber]);
-
-            #endregion
-        }
-
-        public override void LinkToApi(BasicTriList trilist, uint joinStart, string joinMapKey, EiscApiAdvanced bridge)
+		public GlsOccupancySensorBaseController(string key, string name, DeviceConfig config)
+            : base(key, name) 
        {
-            LinkOccSensorToApi(this, trilist, joinStart, joinMapKey, bridge);
+
+            var props = config.Properties.ToObject<GlsOccupancySensorPropertiesConfig>();
+
+            if (props != null)
+            {
+                PropertiesConfig = props;
+            }
+            else
+            {
+                Debug.Console(1, this, "props are null.  Unable to deserialize into GlsOccupancySensorPropertiesConfig");
+            }
+
+            AddPostActivationAction(() =>
+                {
+                    OccSensor.OnlineStatusChange += (o, a) =>
+                    {
+                        if (a.DeviceOnLine)
+                        {
+                            ApplySettingsToSensorFromConfig();
+                        }
+                    };
+
+                    if (OccSensor.IsOnline)
+                    {
+                        ApplySettingsToSensorFromConfig();
+
+                    }
+                });
        }

-        #region PreActivation

-        private static GlsOirCCn GetGlsOirCCn(DeviceConfig dc)
+        /// <summary>
+        /// Applies any sensor settings defined in config 
+        /// </summary>
+        protected virtual void ApplySettingsToSensorFromConfig()
        {
-            var control = CommFactory.GetControlPropertiesConfig(dc);
-            var cresnetId = control.CresnetIdInt;
-            var branchId = control.ControlPortNumber;
-            var parentKey = string.IsNullOrEmpty(control.ControlPortDevKey) ? "processor" : control.ControlPortDevKey;
+            Debug.Console(1, this, "Attempting to apply settings to sensor from config");

-            if (parentKey.Equals("processor", StringComparison.CurrentCultureIgnoreCase))
+            if (PropertiesConfig.EnablePir != null)
            {
-                Debug.Console(0, "Device {0} is a valid cresnet master - creating new GlsOirCCn", parentKey);
-                return new GlsOirCCn(cresnetId, Global.ControlSystem);
+                Debug.Console(1, this, "EnablePir found, attempting to set value from config");
+                SetPirEnable((bool)PropertiesConfig.EnablePir);
+            }
+            else
+            {
+                Debug.Console(1, this, "EnablePir null, no value specified in config");
            }
-            var cresnetBridge = DeviceManager.GetDeviceForKey(parentKey) as IHasCresnetBranches;

-            if (cresnetBridge != null)
+            if (PropertiesConfig.EnableLedFlash != null)
            {
-                Debug.Console(0, "Device {0} is a valid cresnet master - creating new GlsOirCCn", parentKey);
-                return new GlsOirCCn(cresnetId, cresnetBridge.CresnetBranches[branchId]);
+                Debug.Console(1, this, "EnableLedFlash found, attempting to set value from config");
+                SetLedFlashEnable((bool)PropertiesConfig.EnableLedFlash);
+            }
+
+            if (PropertiesConfig.RemoteTimeout != null)
+            {
+                Debug.Console(1, this, "RemoteTimeout found, attempting to set value from config");
+                SetRemoteTimeout((ushort)PropertiesConfig.RemoteTimeout);
+            }
+            else
+            {
+                Debug.Console(1, this, "RemoteTimeout null, no value specified in config");
+            }
+
+            if (PropertiesConfig.ShortTimeoutState != null)
+            {
+                SetShortTimeoutState((bool)PropertiesConfig.ShortTimeoutState);
+            }
+
+            if (PropertiesConfig.EnableRawStates != null)
+            {
+                EnableRawStates((bool)PropertiesConfig.EnableRawStates);
+            }
+
+            if (PropertiesConfig.InternalPhotoSensorMinChange != null)
+            {
+                SetInternalPhotoSensorMinChange((ushort)PropertiesConfig.InternalPhotoSensorMinChange);
+            }
+
+            if (PropertiesConfig.ExternalPhotoSensorMinChange != null)
+            {
+                SetExternalPhotoSensorMinChange((ushort)PropertiesConfig.ExternalPhotoSensorMinChange);
            }
-            Debug.Console(0, "Device {0} is not a valid cresnet master", parentKey);
-            return null;
        }
-        #endregion

-        public class GlsOccupancySensorBaseControllerFactory : EssentialsDeviceFactory<GlsOccupancySensorBaseController>
-        {
-            public GlsOccupancySensorBaseControllerFactory()
-            {
-                TypeNames = new List<string>() { "glsoirccn" };
-            }
+		protected void RegisterGlsOdtSensorBaseController(GlsOccupancySensorBase occSensor)
+		{
+			OccSensor = occSensor;
+
+			RoomIsOccupiedFeedback = new BoolFeedback(RoomIsOccupiedFeedbackFunc);
+
+			PirSensorEnabledFeedback = new BoolFeedback(() => OccSensor.PirEnabledFeedback.BoolValue);
+
+			LedFlashEnabledFeedback = new BoolFeedback(() => OccSensor.LedFlashEnabledFeedback.BoolValue);
+
+			ShortTimeoutEnabledFeedback = new BoolFeedback(() => OccSensor.ShortTimeoutEnabledFeedback.BoolValue);
+
+			PirSensitivityInVacantStateFeedback =
+				new IntFeedback(() => OccSensor.PirSensitivityInVacantStateFeedback.UShortValue);
+
+			PirSensitivityInOccupiedStateFeedback =
+				new IntFeedback(() => OccSensor.PirSensitivityInOccupiedStateFeedback.UShortValue);
+
+			CurrentTimeoutFeedback = new IntFeedback(() => OccSensor.CurrentTimeoutFeedback.UShortValue);
+
+			LocalTimoutFeedback = new IntFeedback(() => OccSensor.LocalTimeoutFeedback.UShortValue);
+
+			GraceOccupancyDetectedFeedback =
+				new BoolFeedback(() => OccSensor.GraceOccupancyDetectedFeedback.BoolValue);
+
+			RawOccupancyFeedback = new BoolFeedback(() => OccSensor.RawOccupancyFeedback.BoolValue);
+
+			InternalPhotoSensorValue = new IntFeedback(() => OccSensor.InternalPhotoSensorValueFeedback.UShortValue);
+
+			ExternalPhotoSensorValue = new IntFeedback(() => OccSensor.ExternalPhotoSensorValueFeedback.UShortValue);
+
+			OccSensor.BaseEvent += OccSensor_BaseEvent;
+
+			OccSensor.GlsOccupancySensorChange += OccSensor_GlsOccupancySensorChange;
+		}


-            public override EssentialsDevice BuildDevice(DeviceConfig dc)
-            {
-                Debug.Console(1, "Factory Attempting to create new GlsOccupancySensorBaseController Device");
+		/// <summary>
+		/// Catches events for feedbacks on the base class.  Any extending wrapper class should call this delegate after it checks for it's own event IDs.
+		/// </summary>
+		/// <param name="device"></param>
+		/// <param name="args"></param>
+		protected virtual void OccSensor_GlsOccupancySensorChange(GlsOccupancySensorBase device, GlsOccupancySensorChangeEventArgs args)
+		{
+			switch (args.EventId)
+			{
+				case GlsOccupancySensorBase.PirEnabledFeedbackEventId:
+					PirSensorEnabledFeedback.FireUpdate();
+					break;
+				case GlsOccupancySensorBase.LedFlashEnabledFeedbackEventId:
+					LedFlashEnabledFeedback.FireUpdate();
+					break;
+				case GlsOccupancySensorBase.ShortTimeoutEnabledFeedbackEventId:
+					ShortTimeoutEnabledFeedback.FireUpdate();
+					break;
+				case GlsOccupancySensorBase.PirSensitivityInOccupiedStateFeedbackEventId:
+					PirSensitivityInOccupiedStateFeedback.FireUpdate();
+					break;
+				case GlsOccupancySensorBase.PirSensitivityInVacantStateFeedbackEventId:
+					PirSensitivityInVacantStateFeedback.FireUpdate();
+					break;
+			}
+		}

-                return new GlsOccupancySensorBaseController(dc.Key, GetGlsOirCCn, dc);
-            }
+		protected virtual void OccSensor_BaseEvent(Crestron.SimplSharpPro.GenericBase device, Crestron.SimplSharpPro.BaseEventArgs args)
+		{
+			Debug.Console(2, this, "GlsOccupancySensorChange  EventId: {0}", args.EventId);
+
+			switch (args.EventId)
+			{
+				case Crestron.SimplSharpPro.GeneralIO.GlsOccupancySensorBase.RoomVacantFeedbackEventId:
+				case Crestron.SimplSharpPro.GeneralIO.GlsOccupancySensorBase.RoomOccupiedFeedbackEventId:
+					Debug.Console(1, this, "Occupancy State: {0}", OccSensor.OccupancyDetectedFeedback.BoolValue);
+					RoomIsOccupiedFeedback.FireUpdate();
+					break;
+				case GlsOccupancySensorBase.TimeoutFeedbackEventId:
+					CurrentTimeoutFeedback.FireUpdate();
+					break;
+				case GlsOccupancySensorBase.TimeoutLocalFeedbackEventId:
+					LocalTimoutFeedback.FireUpdate();
+					break;
+				case GlsOccupancySensorBase.GraceOccupancyDetectedFeedbackEventId:
+					GraceOccupancyDetectedFeedback.FireUpdate();
+					break;
+				case GlsOccupancySensorBase.RawOccupancyFeedbackEventId:
+					RawOccupancyFeedback.FireUpdate();
+					break;
+				case GlsOccupancySensorBase.InternalPhotoSensorValueFeedbackEventId:
+					InternalPhotoSensorValue.FireUpdate();
+					break;
+				case GlsOccupancySensorBase.ExternalPhotoSensorValueFeedbackEventId:
+					ExternalPhotoSensorValue.FireUpdate();
+					break;
+			}
+		}
+
+		public void SetTestMode(bool mode)
+		{
+			InTestMode = mode;
+
+			Debug.Console(1, this, "In Mock Mode: '{0}'", InTestMode);
+		}
+
+		public void SetTestOccupiedState(bool state)
+		{
+			if (!InTestMode)
+				Debug.Console(1, "Mock mode not enabled");
+			else
+			{
+				TestRoomIsOccupiedFeedback = state;
+
+				RoomIsOccupiedFeedback.FireUpdate();
+			}
+		}
+
+		/// <summary>
+		/// Enables or disables the PIR sensor
+		/// </summary>
+		/// <param name="state"></param>
+		public void SetPirEnable(bool state)
+		{
+            Debug.Console(1, this, "Setting EnablePir to: {0}", state);
+
+			if (state)
+			{
+				OccSensor.EnablePir.BoolValue = state;
+				OccSensor.DisablePir.BoolValue = !state;
+			}
+			else
+			{
+				OccSensor.EnablePir.BoolValue = state;
+				OccSensor.DisablePir.BoolValue = !state;
+			}
+		}
+
+		/// <summary>
+		/// Enables or disables the LED Flash
+		/// </summary>
+		/// <param name="state"></param>
+		public void SetLedFlashEnable(bool state)
+		{
+			if (state)
+			{
+				OccSensor.EnableLedFlash.BoolValue = state;
+				OccSensor.DisableLedFlash.BoolValue = !state;
+			}
+			else
+			{
+				OccSensor.EnableLedFlash.BoolValue = state;
+				OccSensor.DisableLedFlash.BoolValue = !state;
+			}
+		}
+
+		/// <summary>
+		/// Enables or disables short timeout based on state
+		/// </summary>
+		/// <param name="state"></param>
+		public void SetShortTimeoutState(bool state)
+		{
+			if (state)
+			{
+				OccSensor.EnableShortTimeout.BoolValue = state;
+				OccSensor.DisableShortTimeout.BoolValue = !state;
+			}
+			else
+			{
+				OccSensor.EnableShortTimeout.BoolValue = state;
+				OccSensor.DisableShortTimeout.BoolValue = !state;
+			}
+		}
+
+		public void IncrementPirSensitivityInOccupiedState(bool pressRelease)
+		{
+			OccSensor.IncrementPirSensitivityInOccupiedState.BoolValue = pressRelease;
+		}
+
+		public void DecrementPirSensitivityInOccupiedState(bool pressRelease)
+		{
+			OccSensor.DecrementPirSensitivityInOccupiedState.BoolValue = pressRelease;
+		}
+
+		public void IncrementPirSensitivityInVacantState(bool pressRelease)
+		{
+			OccSensor.IncrementPirSensitivityInVacantState.BoolValue = pressRelease;
+		}
+
+		public void DecrementPirSensitivityInVacantState(bool pressRelease)
+		{
+			OccSensor.DecrementPirSensitivityInVacantState.BoolValue = pressRelease;
+		}
+
+		public void ForceOccupied()
+		{
+			OccSensor.ForceOccupied.BoolValue = true;
+		}
+
+		public void ForceVacant()
+		{
+			OccSensor.ForceVacant.BoolValue = true;
+		}
+
+		public void EnableRawStates(bool state)
+		{
+			OccSensor.EnableRawStates.BoolValue = state;
+		}
+
+		public void SetRemoteTimeout(ushort time)
+		{
+            Debug.Console(1, this, "Setting RemoteTimout to: {0}", time);
+
+			OccSensor.RemoteTimeout.UShortValue = time;
+		}
+
+		public void SetInternalPhotoSensorMinChange(ushort value)
+		{
+			OccSensor.InternalPhotoSensorMinimumChange.UShortValue = value;
+		}
+
+		public void SetExternalPhotoSensorMinChange(ushort value)
+		{
+			OccSensor.ExternalPhotoSensorMinimumChange.UShortValue = value;
+		}
+
+		/// <summary>
+		/// Method to print current occ settings to console.
+		/// </summary>
+		/// <param name="key"></param>
+		public virtual void GetSettings()
+		{
+			var dash = new string('*', 50);
+			CrestronConsole.PrintLine(string.Format("{0}\n", dash));
+
+            Debug.Console(0, this, "Vacancy Detected: {0}",
+                OccSensor.VacancyDetectedFeedback.BoolValue);
+
+			Debug.Console(0, this, "Timeout Current: {0} | Local: {1}",
+				OccSensor.CurrentTimeoutFeedback.UShortValue,
+				OccSensor.LocalTimeoutFeedback.UShortValue);
+
+			Debug.Console(0, this, "Short Timeout Enabled: {0}",
+				OccSensor.ShortTimeoutEnabledFeedback.BoolValue);
+
+			Debug.Console(0, this, "PIR Sensor Enabled: {0} | Sensitivity Occupied: {1} | Sensitivity Vacant: {2}",
+				OccSensor.PirEnabledFeedback.BoolValue,
+				OccSensor.PirSensitivityInOccupiedStateFeedback.UShortValue,
+				OccSensor.PirSensitivityInVacantStateFeedback.UShortValue);
+
+			CrestronConsole.PrintLine(string.Format("{0}\n", dash));
+		}
+
+		protected void LinkOccSensorToApi(GlsOccupancySensorBaseController occController, BasicTriList trilist,
+			uint joinStart, string joinMapKey, EiscApiAdvanced bridge)
+		{
+			var joinMap = new GlsOccupancySensorBaseJoinMap(joinStart);
+
+			var joinMapSerialized = JoinMapHelper.GetSerializedJoinMapForDevice(joinMapKey);
+
+			if (!string.IsNullOrEmpty(joinMapSerialized))
+				joinMap = JsonConvert.DeserializeObject<GlsOccupancySensorBaseJoinMap>(joinMapSerialized);
+
+			if (bridge != null)
+			{
+				bridge.AddJoinMap(Key, joinMap);
+			}
+			else
+			{
+				Debug.Console(0, this, "Please update config to use 'eiscapiadvanced' to get all join map features for this device.");
+			}
+
+			Debug.Console(1, occController, "Linking to Trilist '{0}'", trilist.ID.ToString("X"));
+
+			#region Single and Dual Sensor Stuff
+			occController.IsOnline.LinkInputSig(trilist.BooleanInput[joinMap.IsOnline.JoinNumber]);
+			trilist.StringInput[joinMap.Name.JoinNumber].StringValue = occController.Name;
+
+			trilist.OnlineStatusChange += (d, args) =>
+			{
+				if (args.DeviceOnLine)
+				{
+					trilist.StringInput[joinMap.Name.JoinNumber].StringValue = occController.Name;
+				}
+			};
+
+			// Occupied status
+			trilist.SetSigTrueAction(joinMap.ForceOccupied.JoinNumber, occController.ForceOccupied);
+			trilist.SetSigTrueAction(joinMap.ForceVacant.JoinNumber, occController.ForceVacant);
+			occController.RoomIsOccupiedFeedback.LinkInputSig(trilist.BooleanInput[joinMap.RoomOccupiedFeedback.JoinNumber]);
+			occController.RoomIsOccupiedFeedback.LinkComplementInputSig(trilist.BooleanInput[joinMap.RoomVacantFeedback.JoinNumber]);
+			occController.RawOccupancyFeedback.LinkInputSig(trilist.BooleanInput[joinMap.RawOccupancyFeedback.JoinNumber]);
+			trilist.SetBoolSigAction(joinMap.EnableRawStates.JoinNumber, occController.EnableRawStates);
+
+			// Timouts
+			trilist.SetUShortSigAction(joinMap.Timeout.JoinNumber, occController.SetRemoteTimeout);
+			occController.CurrentTimeoutFeedback.LinkInputSig(trilist.UShortInput[joinMap.Timeout.JoinNumber]);
+			occController.LocalTimoutFeedback.LinkInputSig(trilist.UShortInput[joinMap.TimeoutLocalFeedback.JoinNumber]);
+
+			// LED Flash
+			trilist.SetSigTrueAction(joinMap.EnableLedFlash.JoinNumber, () => occController.SetLedFlashEnable(true));
+			trilist.SetSigTrueAction(joinMap.DisableLedFlash.JoinNumber, () => occController.SetLedFlashEnable(false));
+			occController.LedFlashEnabledFeedback.LinkComplementInputSig(trilist.BooleanInput[joinMap.EnableLedFlash.JoinNumber]);
+
+			// Short Timeout
+			trilist.SetSigTrueAction(joinMap.EnableShortTimeout.JoinNumber, () => occController.SetShortTimeoutState(true));
+			trilist.SetSigTrueAction(joinMap.DisableShortTimeout.JoinNumber, () => occController.SetShortTimeoutState(false));
+			occController.ShortTimeoutEnabledFeedback.LinkInputSig(trilist.BooleanInput[joinMap.EnableShortTimeout.JoinNumber]);
+
+			// PIR Sensor
+			trilist.SetSigTrueAction(joinMap.EnablePir.JoinNumber, () => occController.SetPirEnable(true));
+			trilist.SetSigTrueAction(joinMap.DisablePir.JoinNumber, () => occController.SetPirEnable(false));
+			occController.PirSensorEnabledFeedback.LinkInputSig(trilist.BooleanInput[joinMap.EnablePir.JoinNumber]);
+
+			// PIR Sensitivity in Occupied State
+			trilist.SetBoolSigAction(joinMap.IncrementPirInOccupiedState.JoinNumber, occController.IncrementPirSensitivityInOccupiedState);
+			trilist.SetBoolSigAction(joinMap.DecrementPirInOccupiedState.JoinNumber, occController.DecrementPirSensitivityInOccupiedState);
+			occController.PirSensitivityInOccupiedStateFeedback.LinkInputSig(trilist.UShortInput[joinMap.PirSensitivityInOccupiedState.JoinNumber]);
+
+			// PIR Sensitivity in Vacant State
+			trilist.SetBoolSigAction(joinMap.IncrementPirInVacantState.JoinNumber, occController.IncrementPirSensitivityInVacantState);
+			trilist.SetBoolSigAction(joinMap.DecrementPirInVacantState.JoinNumber, occController.DecrementPirSensitivityInVacantState);
+			occController.PirSensitivityInVacantStateFeedback.LinkInputSig(trilist.UShortInput[joinMap.PirSensitivityInVacantState.JoinNumber]);
+			#endregion
+
+			#region Dual Technology Sensor Stuff
+			var odtOccController = occController as GlsOdtOccupancySensorController;
+
+			if (odtOccController == null) return;
+			// OR When Vacated
+			trilist.SetBoolSigAction(joinMap.OrWhenVacated.JoinNumber, odtOccController.SetOrWhenVacatedState);
+			odtOccController.OrWhenVacatedFeedback.LinkInputSig(trilist.BooleanInput[joinMap.OrWhenVacated.JoinNumber]);
+
+			// AND When Vacated
+			trilist.SetBoolSigAction(joinMap.AndWhenVacated.JoinNumber, odtOccController.SetAndWhenVacatedState);
+			odtOccController.AndWhenVacatedFeedback.LinkInputSig(trilist.BooleanInput[joinMap.AndWhenVacated.JoinNumber]);
+
+			// Ultrasonic A Sensor
+			trilist.SetSigTrueAction(joinMap.EnableUsA.JoinNumber, () => odtOccController.SetUsAEnable(true));
+			trilist.SetSigTrueAction(joinMap.DisableUsA.JoinNumber, () => odtOccController.SetUsAEnable(false));
+			odtOccController.UltrasonicAEnabledFeedback.LinkInputSig(trilist.BooleanInput[joinMap.EnableUsA.JoinNumber]);
+
+			// Ultrasonic B Sensor
+			trilist.SetSigTrueAction(joinMap.EnableUsB.JoinNumber, () => odtOccController.SetUsBEnable(true));
+			trilist.SetSigTrueAction(joinMap.DisableUsB.JoinNumber, () => odtOccController.SetUsBEnable(false));
+			odtOccController.UltrasonicAEnabledFeedback.LinkInputSig(trilist.BooleanInput[joinMap.EnableUsB.JoinNumber]);
+
+			// US Sensitivity in Occupied State
+			trilist.SetBoolSigAction(joinMap.IncrementUsInOccupiedState.JoinNumber, odtOccController.IncrementUsSensitivityInOccupiedState);
+			trilist.SetBoolSigAction(joinMap.DecrementUsInOccupiedState.JoinNumber, odtOccController.DecrementUsSensitivityInOccupiedState);
+			odtOccController.UltrasonicSensitivityInOccupiedStateFeedback.LinkInputSig(trilist.UShortInput[joinMap.UsSensitivityInOccupiedState.JoinNumber]);
+
+			// US Sensitivity in Vacant State
+			trilist.SetBoolSigAction(joinMap.IncrementUsInVacantState.JoinNumber, odtOccController.IncrementUsSensitivityInVacantState);
+			trilist.SetBoolSigAction(joinMap.DecrementUsInVacantState.JoinNumber, odtOccController.DecrementUsSensitivityInVacantState);
+			odtOccController.UltrasonicSensitivityInVacantStateFeedback.LinkInputSig(trilist.UShortInput[joinMap.UsSensitivityInVacantState.JoinNumber]);
+
+			//Sensor Raw States
+			odtOccController.RawOccupancyPirFeedback.LinkInputSig(trilist.BooleanInput[joinMap.RawOccupancyPirFeedback.JoinNumber]);
+			odtOccController.RawOccupancyUsFeedback.LinkInputSig(trilist.BooleanInput[joinMap.RawOccupancyUsFeedback.JoinNumber]);
+
+			#endregion
+		}
+
+		public override void LinkToApi(BasicTriList trilist, uint joinStart, string joinMapKey, EiscApiAdvanced bridge)
+		{
+			LinkOccSensorToApi(this, trilist, joinStart, joinMapKey, bridge);
+		}
+
+		#region PreActivation
+
+		private static GlsOirCCn GetGlsOirCCn(DeviceConfig dc)
+		{
+			var control = CommFactory.GetControlPropertiesConfig(dc);
+			var cresnetId = control.CresnetIdInt;
+			var branchId = control.ControlPortNumber;
+			var parentKey = string.IsNullOrEmpty(control.ControlPortDevKey) ? "processor" : control.ControlPortDevKey;
+
+			if (parentKey.Equals("processor", StringComparison.CurrentCultureIgnoreCase))
+			{
+				Debug.Console(0, "Device {0} is a valid cresnet master - creating new GlsOirCCn", parentKey);
+				return new GlsOirCCn(cresnetId, Global.ControlSystem);
+			}
+			var cresnetBridge = DeviceManager.GetDeviceForKey(parentKey) as IHasCresnetBranches;
+
+			if (cresnetBridge != null)
+			{
+				Debug.Console(0, "Device {0} is a valid cresnet master - creating new GlsOirCCn", parentKey);
+				return new GlsOirCCn(cresnetId, cresnetBridge.CresnetBranches[branchId]);
+			}
+			Debug.Console(0, "Device {0} is not a valid cresnet master", parentKey);
+			return null;
+		}
+		#endregion
+
+		public class GlsOccupancySensorBaseControllerFactory : EssentialsDeviceFactory<GlsOccupancySensorBaseController>
+		{
+			public GlsOccupancySensorBaseControllerFactory()
+			{
+				TypeNames = new List<string>() { "glsoirccn" };
+			}
+
+
+			public override EssentialsDevice BuildDevice(DeviceConfig dc)
+			{
+				Debug.Console(1, "Factory Attempting to create new GlsOccupancySensorBaseController Device");
+
+				return new GlsOccupancySensorBaseController(dc.Key, GetGlsOirCCn, dc);
+			}
+
+		}
+	}

-        }
-    }

-    

 }
--- a/Core/PepperDashEssentialsBase/Occupancy/GlsOccupancySensorPropertiesConfig.cs
+++ b/Core/PepperDashEssentialsBase/Occupancy/GlsOccupancySensorPropertiesConfig.cs
@@ -0,0 +1,51 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+
+using Newtonsoft.Json;
+
+namespace PepperDash.Essentials.Core
+{
+    /// <summary>
+    /// Defines configuration properties for Crestron GLS series occupancy sensors
+    /// </summary>
+    public class GlsOccupancySensorPropertiesConfig
+    {
+        // Single Technology Sensors (PIR): GlsOccupancySensorBase
+        [JsonProperty("enablePir")]
+        public bool? EnablePir { get; set; }
+
+        [JsonProperty("enableLedFlash")]
+        public bool? EnableLedFlash { get; set; }
+
+        [JsonProperty("shortTimeoutState")]
+        public bool? ShortTimeoutState { get; set; }
+
+        [JsonProperty("enableRawStates")]
+        public bool? EnableRawStates { get; set; }
+
+        [JsonProperty("remoteTimeout")]
+        public ushort? RemoteTimeout { get; set; }
+
+        [JsonProperty("internalPhotoSensorMinChange")]
+        public ushort? InternalPhotoSensorMinChange { get; set; }
+
+        [JsonProperty("externalPhotoSensorMinChange")]
+        public ushort? ExternalPhotoSensorMinChange { get; set; }
+
+        // Dual Technology Sensors: GlsOdtCCn
+        [JsonProperty("enableUsA")]
+        public bool? EnableUsA { get; set; }
+
+        [JsonProperty("enableUsB")]
+        public bool? EnableUsB { get; set; }
+
+        [JsonProperty("orWhenVacatedState")]
+        public bool? OrWhenVacatedState { get; set; }
+
+        [JsonProperty("andWhenVacatedState")]
+        public bool? AndWhenVacatedState { get; set; }
+    }
+}
--- a/Core/PepperDashEssentialsBase/Occupancy/GlsOdtOccupancySensorController.cs
+++ b/Core/PepperDashEssentialsBase/Occupancy/GlsOdtOccupancySensorController.cs
@@ -13,206 +13,266 @@ using PepperDash.Essentials.Core.Bridges;

 namespace PepperDash.Essentials.Core
 {
-    [Description("Wrapper class for Dual Technology GLS Occupancy Sensors")]
+	[Description("Wrapper class for Dual Technology GLS Occupancy Sensors")]
+    [ConfigSnippet("\"properties\": {\"control\": {\"method\": \"cresnet\",\"cresnetId\": \"97\"},\"enablePir\": true,\"enableLedFlash\": true,\"enableRawStates\":true,\"remoteTimeout\": 30,\"internalPhotoSensorMinChange\": 0,\"externalPhotoSensorMinChange\": 0,\"enableUsA\": true,\"enableUsB\": true,\"orWhenVacatedState\": true}")]
    public class GlsOdtOccupancySensorController : GlsOccupancySensorBaseController
-    {
-        public new GlsOdtCCn OccSensor { get; private set; }
+	{
+		public new GlsOdtCCn OccSensor { get; private set; }

-        public BoolFeedback OrWhenVacatedFeedback { get; private set; }
+		public BoolFeedback OrWhenVacatedFeedback { get; private set; }

-        public BoolFeedback AndWhenVacatedFeedback { get; private set; }
+		public BoolFeedback AndWhenVacatedFeedback { get; private set; }

-        public BoolFeedback UltrasonicAEnabledFeedback { get; private set; }
+		public BoolFeedback UltrasonicAEnabledFeedback { get; private set; }

-        public BoolFeedback UltrasonicBEnabledFeedback { get; private set; }
+		public BoolFeedback UltrasonicBEnabledFeedback { get; private set; }

-        public IntFeedback UltrasonicSensitivityInVacantStateFeedback { get; private set; }
+		public IntFeedback UltrasonicSensitivityInVacantStateFeedback { get; private set; }

-        public IntFeedback UltrasonicSensitivityInOccupiedStateFeedback { get; private set; }
+		public IntFeedback UltrasonicSensitivityInOccupiedStateFeedback { get; private set; }

-        public BoolFeedback RawOccupancyPirFeedback { get; private set; }
+		public BoolFeedback RawOccupancyPirFeedback { get; private set; }

-        public BoolFeedback RawOccupancyUsFeedback { get; private set; }
+		public BoolFeedback RawOccupancyUsFeedback { get; private set; }


-        public GlsOdtOccupancySensorController(string key, Func<DeviceConfig, GlsOdtCCn> preActivationFunc,
-            DeviceConfig config)
-            : base(key, config.Name)
+		public GlsOdtOccupancySensorController(string key, Func<DeviceConfig, GlsOdtCCn> preActivationFunc,
+			DeviceConfig config)
+			: base(key, config.Name, config)
+		{
+			AddPreActivationAction(() =>
+			{
+				OccSensor = preActivationFunc(config);
+
+				RegisterCrestronGenericBase(OccSensor);
+
+				RegisterGlsOdtSensorBaseController(OccSensor);
+
+				AndWhenVacatedFeedback = new BoolFeedback(() => OccSensor.AndWhenVacatedFeedback.BoolValue);
+
+				OrWhenVacatedFeedback = new BoolFeedback(() => OccSensor.OrWhenVacatedFeedback.BoolValue);
+
+				UltrasonicAEnabledFeedback = new BoolFeedback(() => OccSensor.UsAEnabledFeedback.BoolValue);
+
+				UltrasonicBEnabledFeedback = new BoolFeedback(() => OccSensor.UsBEnabledFeedback.BoolValue);
+
+				RawOccupancyPirFeedback = new BoolFeedback(() => OccSensor.RawOccupancyPirFeedback.BoolValue);
+
+				RawOccupancyUsFeedback = new BoolFeedback(() => OccSensor.RawOccupancyUsFeedback.BoolValue);
+
+				UltrasonicSensitivityInVacantStateFeedback = new IntFeedback(() => OccSensor.UsSensitivityInVacantStateFeedback.UShortValue);
+
+				UltrasonicSensitivityInOccupiedStateFeedback = new IntFeedback(() => OccSensor.UsSensitivityInOccupiedStateFeedback.UShortValue);
+
+			});		
+
+
+		}
+
+        protected override void ApplySettingsToSensorFromConfig()
        {
-            AddPreActivationAction(() =>
+            base.ApplySettingsToSensorFromConfig();
+
+            if (PropertiesConfig.EnableUsA != null)
            {
-                OccSensor = preActivationFunc(config);
-
-                RegisterCrestronGenericBase(OccSensor);
-
-                RegisterGlsOdtSensorBaseController(OccSensor);
-
-                AndWhenVacatedFeedback = new BoolFeedback(() => OccSensor.AndWhenVacatedFeedback.BoolValue);
-
-                OrWhenVacatedFeedback = new BoolFeedback(() => OccSensor.OrWhenVacatedFeedback.BoolValue);
-
-                UltrasonicAEnabledFeedback = new BoolFeedback(() => OccSensor.UsAEnabledFeedback.BoolValue);
-
-                UltrasonicBEnabledFeedback = new BoolFeedback(() => OccSensor.UsBEnabledFeedback.BoolValue);
-
-                RawOccupancyPirFeedback = new BoolFeedback(() => OccSensor.RawOccupancyPirFeedback.BoolValue);
-
-                RawOccupancyUsFeedback = new BoolFeedback(() => OccSensor.RawOccupancyUsFeedback.BoolValue);
-
-                UltrasonicSensitivityInVacantStateFeedback = new IntFeedback(() => OccSensor.UsSensitivityInVacantStateFeedback.UShortValue);
-
-                UltrasonicSensitivityInOccupiedStateFeedback = new IntFeedback(() => OccSensor.UsSensitivityInOccupiedStateFeedback.UShortValue);
-
-            });       
-        }
-
-        /// <summary>
-        /// Overrides the base class event delegate to fire feedbacks for event IDs that pertain to this extended class.
-        /// Then calls the base delegate method to ensure any common event IDs are captured.
-        /// </summary>
-        /// <param name="device"></param>
-        /// <param name="args"></param>
-        protected override void OccSensor_GlsOccupancySensorChange(GlsOccupancySensorBase device, GlsOccupancySensorChangeEventArgs args)
-        {
-            if (args.EventId == GlsOccupancySensorBase.AndWhenVacatedFeedbackEventId)
-                AndWhenVacatedFeedback.FireUpdate();
-            else if (args.EventId == GlsOccupancySensorBase.OrWhenVacatedFeedbackEventId)
-                OrWhenVacatedFeedback.FireUpdate();
-            else if (args.EventId == GlsOccupancySensorBase.UsAEnabledFeedbackEventId)
-                UltrasonicAEnabledFeedback.FireUpdate();
-            else if (args.EventId == GlsOccupancySensorBase.UsBEnabledFeedbackEventId)
-                UltrasonicBEnabledFeedback.FireUpdate();
-            else if (args.EventId == GlsOccupancySensorBase.UsSensitivityInOccupiedStateFeedbackEventId)
-                UltrasonicSensitivityInOccupiedStateFeedback.FireUpdate();
-            else if (args.EventId == GlsOccupancySensorBase.UsSensitivityInVacantStateFeedbackEventId)
-                UltrasonicSensitivityInVacantStateFeedback.FireUpdate();
-
-            base.OccSensor_GlsOccupancySensorChange(device, args);
-        }
-
-        /// <summary>
-        /// Overrides the base class event delegate to fire feedbacks for event IDs that pertain to this extended class.
-        /// Then calls the base delegate method to ensure any common event IDs are captured.
-        /// </summary>
-        /// <param name="device"></param>
-        /// <param name="args"></param>
-        protected override void OccSensor_BaseEvent(Crestron.SimplSharpPro.GenericBase device, Crestron.SimplSharpPro.BaseEventArgs args)
-        {
-             if (args.EventId == GlsOccupancySensorBase.RawOccupancyPirFeedbackEventId)
-                RawOccupancyPirFeedback.FireUpdate();
-            else if (args.EventId == GlsOccupancySensorBase.RawOccupancyUsFeedbackEventId)
-                RawOccupancyUsFeedback.FireUpdate();
-
-            base.OccSensor_BaseEvent(device, args);
-        }
-
-        /// <summary>
-        /// Sets the OrWhenVacated state
-        /// </summary>
-        /// <param name="state"></param>
-        public void SetOrWhenVacatedState(bool state)
-        {
-            OccSensor.OrWhenVacated.BoolValue = state;
-        }
-
-        /// <summary>
-        /// Sets the AndWhenVacated state
-        /// </summary>
-        /// <param name="state"></param>
-        public void SetAndWhenVacatedState(bool state)
-        {
-            OccSensor.AndWhenVacated.BoolValue = state;
-        }
-
-        /// <summary>
-        /// Enables or disables the Ultrasonic A sensor
-        /// </summary>
-        /// <param name="state"></param>
-        public void SetUsAEnable(bool state)
-        {
-            OccSensor.EnableUsA.BoolValue = state;
-            OccSensor.DisableUsA.BoolValue = !state;
-        }
-
-
-        /// <summary>
-        /// Enables or disables the Ultrasonic B sensor
-        /// </summary>
-        /// <param name="state"></param>
-        public void SetUsBEnable(bool state)
-        {
-            OccSensor.EnableUsB.BoolValue = state;
-            OccSensor.DisableUsB.BoolValue = !state;
-        }
-
-        public void IncrementUsSensitivityInOccupiedState(bool pressRelease)
-        {
-            OccSensor.IncrementUsSensitivityInOccupiedState.BoolValue = pressRelease;
-        }
-
-        public void DecrementUsSensitivityInOccupiedState(bool pressRelease)
-        {
-            OccSensor.DecrementUsSensitivityInOccupiedState.BoolValue = pressRelease;
-        }
-
-        public void IncrementUsSensitivityInVacantState(bool pressRelease)
-        {
-            OccSensor.IncrementUsSensitivityInVacantState.BoolValue = pressRelease;
-        }
-
-        public void DecrementUsSensitivityInVacantState(bool pressRelease)
-        {
-            OccSensor.DecrementUsSensitivityInVacantState.BoolValue = pressRelease;
-        }
-
-        public override void LinkToApi(BasicTriList trilist, uint joinStart, string joinMapKey, EiscApiAdvanced bridge)
-        {
-            LinkOccSensorToApi(this, trilist, joinStart, joinMapKey, bridge);
-        }
-
-        #region PreActivation
-
-        private static GlsOdtCCn GetGlsOdtCCn(DeviceConfig dc)
-        {
-            var control = CommFactory.GetControlPropertiesConfig(dc);
-            var cresnetId = control.CresnetIdInt;
-            var branchId = control.ControlPortNumber;
-            var parentKey = string.IsNullOrEmpty(control.ControlPortDevKey) ? "processor" : control.ControlPortDevKey;
-
-            if (parentKey.Equals("processor", StringComparison.CurrentCultureIgnoreCase))
-            {
-                Debug.Console(0, "Device {0} is a valid cresnet master - creating new GlsOdtCCn", parentKey);
-                return new GlsOdtCCn(cresnetId, Global.ControlSystem);
+                Debug.Console(1, this, "EnableUsA found, attempting to set value from config");
+                SetUsAEnable((bool)PropertiesConfig.EnableUsA);   
            }
-            var cresnetBridge = DeviceManager.GetDeviceForKey(parentKey) as IHasCresnetBranches;
-
-            if (cresnetBridge != null)
+            else
            {
-                Debug.Console(0, "Device {0} is a valid cresnet master - creating new GlsOdtCCn", parentKey);
-                return new GlsOdtCCn(cresnetId, cresnetBridge.CresnetBranches[branchId]);
-            }
-            Debug.Console(0, "Device {0} is not a valid cresnet master", parentKey);
-            return null;
-        }
-        #endregion
-
-        public class GlsOdtOccupancySensorControllerFactory : EssentialsDeviceFactory<GlsOdtOccupancySensorController>
-        {
-            public GlsOdtOccupancySensorControllerFactory()
-            {
-                TypeNames = new List<string>() { "glsodtccn" };
+                Debug.Console(1, this, "EnableUsA null, no value specified in config");
            }


-            public override EssentialsDevice BuildDevice(DeviceConfig dc)
+            if (PropertiesConfig.EnableUsB != null)
            {
-                Debug.Console(1, "Factory Attempting to create new GlsOccupancySensorBaseController Device");
-
-                return new GlsOdtOccupancySensorController(dc.Key, GetGlsOdtCCn, dc);
+                Debug.Console(1, this, "EnableUsB found, attempting to set value from config");
+                SetUsBEnable((bool)PropertiesConfig.EnableUsB);
+            }
+            else
+            {
+                Debug.Console(1, this, "EnablePir null, no value specified in config");
            }

+
+            if (PropertiesConfig.OrWhenVacatedState != null)
+            {
+                SetOrWhenVacatedState((bool)PropertiesConfig.OrWhenVacatedState);
+            }
+
+            if (PropertiesConfig.AndWhenVacatedState != null)
+            {
+                SetAndWhenVacatedState((bool)PropertiesConfig.AndWhenVacatedState);
+            }
        }
-    }
+
+		/// <summary>
+		/// Overrides the base class event delegate to fire feedbacks for event IDs that pertain to this extended class.
+		/// Then calls the base delegate method to ensure any common event IDs are captured.
+		/// </summary>
+		/// <param name="device"></param>
+		/// <param name="args"></param>
+		protected override void OccSensor_GlsOccupancySensorChange(GlsOccupancySensorBase device, GlsOccupancySensorChangeEventArgs args)
+		{
+			if (args.EventId == GlsOccupancySensorBase.AndWhenVacatedFeedbackEventId)
+				AndWhenVacatedFeedback.FireUpdate();
+			else if (args.EventId == GlsOccupancySensorBase.OrWhenVacatedFeedbackEventId)
+				OrWhenVacatedFeedback.FireUpdate();
+			else if (args.EventId == GlsOccupancySensorBase.UsAEnabledFeedbackEventId)
+				UltrasonicAEnabledFeedback.FireUpdate();
+			else if (args.EventId == GlsOccupancySensorBase.UsBEnabledFeedbackEventId)
+				UltrasonicBEnabledFeedback.FireUpdate();
+			else if (args.EventId == GlsOccupancySensorBase.UsSensitivityInOccupiedStateFeedbackEventId)
+				UltrasonicSensitivityInOccupiedStateFeedback.FireUpdate();
+			else if (args.EventId == GlsOccupancySensorBase.UsSensitivityInVacantStateFeedbackEventId)
+				UltrasonicSensitivityInVacantStateFeedback.FireUpdate();
+
+			base.OccSensor_GlsOccupancySensorChange(device, args);
+		}
+
+		/// <summary>
+		/// Overrides the base class event delegate to fire feedbacks for event IDs that pertain to this extended class.
+		/// Then calls the base delegate method to ensure any common event IDs are captured.
+		/// </summary>
+		/// <param name="device"></param>
+		/// <param name="args"></param>
+		protected override void OccSensor_BaseEvent(Crestron.SimplSharpPro.GenericBase device, Crestron.SimplSharpPro.BaseEventArgs args)
+		{
+			if (args.EventId == GlsOccupancySensorBase.RawOccupancyPirFeedbackEventId)
+				RawOccupancyPirFeedback.FireUpdate();
+			else if (args.EventId == GlsOccupancySensorBase.RawOccupancyUsFeedbackEventId)
+				RawOccupancyUsFeedback.FireUpdate();
+
+			base.OccSensor_BaseEvent(device, args);
+		}
+
+		/// <summary>
+		/// Sets the OrWhenVacated state
+		/// </summary>
+		/// <param name="state"></param>
+		public void SetOrWhenVacatedState(bool state)
+		{
+			OccSensor.OrWhenVacated.BoolValue = state;
+		}
+
+		/// <summary>
+		/// Sets the AndWhenVacated state
+		/// </summary>
+		/// <param name="state"></param>
+		public void SetAndWhenVacatedState(bool state)
+		{
+			OccSensor.AndWhenVacated.BoolValue = state;
+		}
+
+		/// <summary>
+		/// Enables or disables the Ultrasonic A sensor
+		/// </summary>
+		/// <param name="state"></param>
+		public void SetUsAEnable(bool state)
+		{
+			OccSensor.EnableUsA.BoolValue = state;
+			OccSensor.DisableUsA.BoolValue = !state;
+		}
+
+
+		/// <summary>
+		/// Enables or disables the Ultrasonic B sensor
+		/// </summary>
+		/// <param name="state"></param>
+		public void SetUsBEnable(bool state)
+		{
+			OccSensor.EnableUsB.BoolValue = state;
+			OccSensor.DisableUsB.BoolValue = !state;
+		}
+
+		public void IncrementUsSensitivityInOccupiedState(bool pressRelease)
+		{
+			OccSensor.IncrementUsSensitivityInOccupiedState.BoolValue = pressRelease;
+		}
+
+		public void DecrementUsSensitivityInOccupiedState(bool pressRelease)
+		{
+			OccSensor.DecrementUsSensitivityInOccupiedState.BoolValue = pressRelease;
+		}
+
+		public void IncrementUsSensitivityInVacantState(bool pressRelease)
+		{
+			OccSensor.IncrementUsSensitivityInVacantState.BoolValue = pressRelease;
+		}
+
+		public void DecrementUsSensitivityInVacantState(bool pressRelease)
+		{
+			OccSensor.DecrementUsSensitivityInVacantState.BoolValue = pressRelease;
+		}
+
+		public override void LinkToApi(BasicTriList trilist, uint joinStart, string joinMapKey, EiscApiAdvanced bridge)
+		{
+			LinkOccSensorToApi(this, trilist, joinStart, joinMapKey, bridge);
+		}
+
+		/// <summary>
+		/// Method to print occ sensor settings to console.
+		/// </summary>
+		public override void GetSettings()
+		{
+            base.GetSettings();
+
+			Debug.Console(0, this, "Ultrasonic Enabled A: {0} | B: {1}",
+				OccSensor.UsAEnabledFeedback.BoolValue,
+				OccSensor.UsBEnabledFeedback.BoolValue);
+
+			Debug.Console(0, this, "Ultrasonic Sensitivity Occupied: {0} | Vacant: {1}",
+				OccSensor.UsSensitivityInOccupiedStateFeedback.UShortValue,
+				OccSensor.UsSensitivityInVacantStateFeedback.UShortValue);
+
+            var dash = new string('*', 50);
+			CrestronConsole.PrintLine(string.Format("{0}\n", dash));
+		}
+
+
+		#region PreActivation
+
+		private static GlsOdtCCn GetGlsOdtCCn(DeviceConfig dc)
+		{
+			var control = CommFactory.GetControlPropertiesConfig(dc);
+			var cresnetId = control.CresnetIdInt;
+			var branchId = control.ControlPortNumber;
+			var parentKey = string.IsNullOrEmpty(control.ControlPortDevKey) ? "processor" : control.ControlPortDevKey;
+
+			if (parentKey.Equals("processor", StringComparison.CurrentCultureIgnoreCase))
+			{
+				Debug.Console(0, "Device {0} is a valid cresnet master - creating new GlsOdtCCn", parentKey);
+				return new GlsOdtCCn(cresnetId, Global.ControlSystem);
+			}
+			var cresnetBridge = DeviceManager.GetDeviceForKey(parentKey) as IHasCresnetBranches;
+
+			if (cresnetBridge != null)
+			{
+				Debug.Console(0, "Device {0} is a valid cresnet master - creating new GlsOdtCCn", parentKey);
+				return new GlsOdtCCn(cresnetId, cresnetBridge.CresnetBranches[branchId]);
+			}
+			Debug.Console(0, "Device {0} is not a valid cresnet master", parentKey);
+			return null;
+		}
+		#endregion
+
+		public class GlsOdtOccupancySensorControllerFactory : EssentialsDeviceFactory<GlsOdtOccupancySensorController>
+		{
+			public GlsOdtOccupancySensorControllerFactory()
+			{
+				TypeNames = new List<string>() { "glsodtccn" };
+			}
+
+
+			public override EssentialsDevice BuildDevice(DeviceConfig dc)
+			{
+				Debug.Console(1, "Factory Attempting to create new GlsOccupancySensorBaseController Device");
+
+				return new GlsOdtOccupancySensorController(dc.Key, GetGlsOdtCCn, dc);
+			}
+
+		}
+	}



--- a/Core/PepperDashEssentialsBase/PepperDash_Essentials_Core.csproj
+++ b/Core/PepperDashEssentialsBase/PepperDash_Essentials_Core.csproj
@@ -227,6 +227,7 @@
    <Compile Include="Global\EthernetAdapterInfo.cs" />
    <Compile Include="Interfaces\ILogStrings.cs" />
    <Compile Include="Interfaces\ILogStringsWithLevel.cs" />
+    <Compile Include="Occupancy\GlsOccupancySensorPropertiesConfig.cs" />
    <Compile Include="Queues\ComsMessage.cs" />
    <Compile Include="Queues\ProcessStringMessage.cs" />
    <Compile Include="Queues\GenericQueue.cs" />
--- a/DM/Essentials_DM/Endpoints/DGEs/Dge100Controller.cs
+++ b/DM/Essentials_DM/Endpoints/DGEs/Dge100Controller.cs
@@ -109,8 +109,6 @@ namespace PepperDash.Essentials.DM.Endpoints.DGEs

            var tcpClient = new GenericTcpIpClient("", _dgeEthernetInfo.IpAddressFeedback.StringValue, CtpPort, 1024){AutoReconnect = false};

-            tcpClient.StreamDebugging.SetDebuggingWithDefaultTimeout(eStreamDebuggingSetting.Rx);
-
            var gather = new CommunicationGather(tcpClient, "\r\n\r\n");

            tcpClient.ConnectionChange += (sender, args) =>
@@ -125,29 +123,56 @@ namespace PepperDash.Essentials.DM.Endpoints.DGEs

            gather.LineReceived += (sender, args) =>
            {
-                if (args.Text.ToLower().Contains("host"))
+                try
                {
-                    DeviceInfo.HostName = args.Text.Split(';')[1].Trim();
+                    Debug.Console(1, this, "{0}", args.Text);

-                    tcpClient.Disconnect();
-                    return;
+                    if (args.Text.ToLower().Contains("host"))
+                    {
+                        DeviceInfo.HostName = args.Text.Split(':')[1].Trim();
+
+                        Debug.Console(1, this, "hostname: {0}", DeviceInfo.HostName);
+                        tcpClient.Disconnect();
+                        return;
+                    }
+
+                    //ignore console prompt
+                    /*if (args.Text.ToLower().Contains(">"))
+                    {
+                        Debug.Console(1, this, "Ignoring console");
+                        return;
+                    }
+
+                    if (args.Text.ToLower().Contains("dge"))
+                    {
+                        Debug.Console(1, this, "Ignoring DGE");
+                        return;
+                    }*/
+
+                    if (!args.Text.Contains('['))
+                    {
+                        return;
+                    }
+                    var splitResponse = args.Text.Split('[');
+
+                    foreach (string t in splitResponse)
+                    {
+                        Debug.Console(1, this, "{0}", t);
+                    }
+
+                    DeviceInfo.SerialNumber = splitResponse[1].Split(' ')[4].Replace("#", "");
+                    DeviceInfo.FirmwareVersion = splitResponse[1].Split(' ')[0];
+
+                    Debug.Console(1, this, "Firmware: {0} SerialNumber: {1}", DeviceInfo.FirmwareVersion,
+                        DeviceInfo.SerialNumber);
+
+                    tcpClient.SendText("host\r\n");
                }
-
-                //ignore console prompt
-                if (args.Text.ToLower().Contains(">"))
+                catch (Exception ex)
                {
-                    return;
+                    Debug.Console(0, this, "Exception getting data: {0}", ex.Message);
+                    Debug.Console(0, this, "response: {0}", args.Text);
                }
-
-                if (!args.Text.ToLower().Contains("dge"))
-                {
-                    return;
-                }
-
-                DeviceInfo.SerialNumber = args.Text.Split('[')[1].Split(' ')[4].Replace("#", "");
-                DeviceInfo.FirmwareVersion = args.Text.Split('[')[1].Split(' ')[1];
-
-                tcpClient.SendText("host\r\n");
            };

            tcpClient.Connect();
--- a/Common/VideoCodec/CiscoCodec/xStatus.cs
+++ b/Common/VideoCodec/CiscoCodec/xStatus.cs
@@ -1369,7 +1369,7 @@ namespace PepperDash.Essentials.Devices.Common.VideoCodec.Cisco
                set
                {
                    // If the incoming value is "On" it sets the BoolValue true, otherwise sets it false
-                    BoolValue = value == "On";
+                    BoolValue = value == "On" || value == "Standby";
                    OnValueChanged();
                }
            }
Author	SHA1	Message	Date
Andrew Welker	7eb6748682	Merge pull request #596 from PepperDash/hotfix/dge-device-info Hotfix/dge device info	2021-02-04 11:41:31 -07:00
Andrew Welker	225c6281b9	Merge branch 'main' into hotfix/dge-device-info	2021-02-04 11:25:10 -07:00
Andrew Welker	249e9f372e	Merge pull request #593 from PepperDash/hotfix/occupancy-sensor-debug Hotfix/occupancy sensor debug	2021-02-04 11:22:30 -07:00
Andrew Welker	4dfab9a287	got DeviceInfo Parsing working correctly	2021-02-04 11:17:49 -07:00
Neil Dorin	ec43749ba4	Tested working with GLS-ODT-C-CN hardware	2021-02-04 11:01:21 -07:00
Neil Dorin	2e4202ccce	adjustments made based on testing with hardware	2021-02-04 10:52:02 -07:00
Neil Dorin	4c16dd07b5	fixes #594 with standby state in CiscoSparkCodec	2021-02-04 10:39:29 -07:00
Neil Dorin	0c4ad1c4df	Merge branch 'hotfix/occupancy-sensor-debug' of https://github.com/PepperDash/Essentials into hotfix/occupancy-sensor-debug	2021-02-04 09:31:06 -07:00
Neil Dorin	eb90fb343d	adds missing condition to set remoteTimeout from config value	2021-02-04 09:30:45 -07:00
Andrew Welker	7b2a8b17b7	Merge branch 'main' into hotfix/occupancy-sensor-debug	2021-02-03 21:32:15 -07:00
Neil Dorin	89ca614d3d	Minor updates after testing at runtime.	2021-02-03 21:17:27 -07:00
Neil Dorin	355df1341e	#592 Adds properties config class for occ sensors	2021-02-03 16:01:24 -07:00
jkdevito	e0dcde5c35	Reviewed with AW, decided best to remove console commands and create a public method that can be called using DEVJSON to print current settiings.	2021-02-01 11:10:33 -06:00
jkdevito	c6cfecdbbb	Added console command to print occupancy sensor settings in console.	2021-02-01 08:24:54 -06:00
Andrew Welker	5a2070de3f	Merge pull request #580 from PepperDash/hotfix/IrSetTopBoxBase-must-implement-ITvPresetsProvider Hotfix/ir set top box base must implement i tv presets provider	2021-01-28 16:13:08 -07:00
Neil Dorin	a69bc94945	Merge pull request #576 from PepperDash/hotfix/fix-queue-priority Hotfix/fix queue priority	2021-01-27 12:08:04 -07:00