Example #1
0
 private static void Controller_NodeUpdated(object sender, NodeUpdatedEventArgs args)
 {
     Console.ForegroundColor = ConsoleColor.Yellow;
     Console.WriteLine("NodeUpdated {0} Event Parameter {1} Value {2}", args.NodeId, args.Event.Parameter, args.Event.Value);
     Console.ForegroundColor = ConsoleColor.White;
 }
        private void OnNodeUpdated(object pSender, NodeUpdatedEventArgs e)
        {
            var node = e.Node;
            var viewModel = StagingNodes.FirstOrDefault(n => n.Guid == node.Guid);

            if (viewModel != null && node.IsInNetwork)
            {
                StagingNodes.Remove(viewModel);

                if (!StagingNodes.Any())
                {
                    IsVisible = Visibility.Collapsed;
                }

                if (node.Position.X == -1 && node.Position.Y == -1)
                {
                    node.Position.X = 0;
                    node.Position.Y = 0;
                    mNodeRepository.Update(node);
                }
            }
            else if (viewModel == null && !node.IsInNetwork)
            {
                viewModel = node.ToStagingNodeViewModel();
                StagingNodes.Add(viewModel);

                if (IsVisible == Visibility.Collapsed)
                {
                    IsVisible = Visibility.Visible;
                }
            }
        }
 private void OnNodeUpdated(object pSender, NodeUpdatedEventArgs e)
 {
     var viewModel = NodeViewModels.FirstOrDefault(n => n.Guid == e.Node.Guid);
     viewModel.Update(e.Node);
 }
Example #4
0
        private void Controller_NodeUpdated(object sender, NodeUpdatedEventArgs args)
        {
            var eventData = args.Event;

            while (eventData != null)
            {
                string eventPath  = "UnknwonParameter";
                object eventValue = eventData.Value;
                switch (eventData.Parameter)
                {
                case EventParameter.MeterKwHour:
                    eventPath = GetIndexedParameterPath(ModuleEvents.Meter_KwHour, eventData.Instance);
                    break;

                case EventParameter.MeterKvaHour:
                    eventPath = GetIndexedParameterPath(ModuleEvents.Meter_KvaHour, eventData.Instance);
                    break;

                case EventParameter.MeterWatt:
                    eventPath = GetIndexedParameterPath(ModuleEvents.Meter_Watts, eventData.Instance);
                    break;

                case EventParameter.MeterPulses:
                    eventPath = GetIndexedParameterPath(ModuleEvents.Meter_Pulses, eventData.Instance);
                    break;

                case EventParameter.MeterAcVolt:
                    eventPath = GetIndexedParameterPath(ModuleEvents.Meter_AcVoltage, eventData.Instance);
                    break;

                case EventParameter.MeterAcCurrent:
                    eventPath = GetIndexedParameterPath(ModuleEvents.Meter_AcCurrent, eventData.Instance);
                    break;

                case EventParameter.MeterPower:
                    eventPath = GetIndexedParameterPath(ModuleEvents.Sensor_Power, eventData.Instance);
                    break;

                case EventParameter.Battery:
                    OnInterfacePropertyChanged(this.GetDomain(), eventData.Node.Id.ToString(), "ZWave Node", EventPath_Battery, eventValue);
                    eventPath = ModuleEvents.Status_Battery;
                    break;

                case EventParameter.NodeInfo:
                    eventPath = EventPath_NodeInfo;
                    break;

                case EventParameter.RoutingInfo:
                    eventPath = EventPath_RoutingInfo;
                    break;

                case EventParameter.SensorGeneric:
                    eventPath = ModuleEvents.Sensor_Generic;
                    break;

                case EventParameter.SensorTemperature:
                    eventPath = ModuleEvents.Sensor_Temperature;
                    break;

                case EventParameter.SensorHumidity:
                    eventPath = ModuleEvents.Sensor_Humidity;
                    break;

                case EventParameter.SensorLuminance:
                    eventPath = ModuleEvents.Sensor_Luminance;
                    break;

                case EventParameter.SensorMotion:
                    eventPath = ModuleEvents.Sensor_MotionDetect;
                    break;

                case EventParameter.AlarmGeneric:
                    eventPath = ModuleEvents.Sensor_Alarm;
                    // Translate generic alarm into specific Door Lock event values if node is an entry control type device
                    //at this level the sender is the controller so get the node from eventData
                    if (eventData.Node.ProtocolInfo.GenericType == (byte)GenericType.EntryControl)
                    {
                        eventPath = ModuleEvents.Status_DoorLock;
                        //! do not convert to string since Alarms accept ONLY numbers a string would be outputed as NaN
                        //! for now let it as is.
                        //eventValue = ((DoorLock.Alarm)(byte)value).ToString();
                    }
                    break;

                case EventParameter.AlarmDoorWindow:
                    eventPath = ModuleEvents.Sensor_DoorWindow;
                    break;

                case EventParameter.AlarmTampered:
                    eventPath = ModuleEvents.Sensor_Tamper;
                    break;

                case EventParameter.AlarmSmoke:
                    eventPath = ModuleEvents.Sensor_Smoke;
                    break;

                case EventParameter.AlarmCarbonMonoxide:
                    eventPath = ModuleEvents.Sensor_CarbonMonoxide;
                    break;

                case EventParameter.AlarmCarbonDioxide:
                    eventPath = ModuleEvents.Sensor_CarbonDioxide;
                    break;

                case EventParameter.AlarmHeat:
                    eventPath = ModuleEvents.Sensor_Heat;
                    break;

                case EventParameter.AlarmFlood:
                    eventPath = ModuleEvents.Sensor_Flood;
                    break;

                case EventParameter.DoorLockStatus:
                    eventPath  = ModuleEvents.Status_DoorLock;
                    eventValue = ((DoorLock.Value)(byte) eventValue).ToString();
                    break;

                case EventParameter.ManufacturerSpecific:
                    ManufacturerSpecificInfo mf = (ManufacturerSpecificInfo)eventValue;
                    eventPath  = EventPath_ManufacturerSpecific;
                    eventValue = mf.ManufacturerId + ":" + mf.TypeId + ":" + mf.ProductId;
                    break;

                case EventParameter.Configuration:
                    eventPath = EventPath_ConfigVariables + "." + eventData.Instance;
                    break;

                case EventParameter.Association:
                    var associationResponse = (Association.AssociationResponse)eventValue;
                    OnInterfacePropertyChanged(this.GetDomain(), eventData.Node.Id.ToString(), "ZWave Node", EventPath_Associations + ".Max", associationResponse.Max);
                    OnInterfacePropertyChanged(this.GetDomain(), eventData.Node.Id.ToString(), "ZWave Node", EventPath_Associations + ".Count", associationResponse.Count);
                    eventPath  = EventPath_Associations + "." + associationResponse.GroupId; // TODO: implement generic group/node association instead of fixed one
                    eventValue = associationResponse.NodeList;
                    break;

                case EventParameter.MultiinstanceSwitchBinaryCount:
                    eventPath = EventPath_MultiInstance + ".SwitchBinary.Count";
                    break;

                case EventParameter.MultiinstanceSwitchMultilevelCount:
                    eventPath = EventPath_MultiInstance + ".SwitchMultiLevel.Count";
                    break;

                case EventParameter.MultiinstanceSensorBinaryCount:
                    eventPath = EventPath_MultiInstance + ".SensorBinary.Count";
                    break;

                case EventParameter.MultiinstanceSensorMultilevelCount:
                    eventPath = EventPath_MultiInstance + ".SensorMultiLevel.Count";
                    break;

                case EventParameter.MultiinstanceSwitchBinary:
                    eventPath = EventPath_MultiInstance + ".SwitchBinary." + eventData.Instance;
                    break;

                case EventParameter.MultiinstanceSwitchMultilevel:
                    eventPath = EventPath_MultiInstance + ".SwitchMultiLevel." + eventData.Instance;
                    break;

                case EventParameter.MultiinstanceSensorBinary:
                    eventPath = EventPath_MultiInstance + ".SensorBinary." + eventData.Instance;
                    break;

                case EventParameter.MultiinstanceSensorMultilevel:
                    eventPath = EventPath_MultiInstance + ".SensorMultiLevel." + eventData.Instance;
                    break;

                case EventParameter.WakeUpInterval:
                    eventPath = EventPath_WakeUpInterval;
                    break;

                case EventParameter.WakeUpSleepingStatus:
                    eventPath = "ZWaveNode.WakeUpSleepingStatus";
                    break;

                case EventParameter.WakeUpNotify:
                    eventPath = "ZWaveNode.WakeUpNotify";
                    break;

                case EventParameter.Basic:
                    eventPath = EventPath_Basic;
                    {
                        double normalizedLevel = GetNormalizedValue((double)eventValue);
                        OnInterfacePropertyChanged(this.GetDomain(), eventData.Node.Id.ToString(), "ZWave Node", ModuleEvents.Status_Level + (eventData.Instance == 0 ? "" : "." + eventData.Instance), normalizedLevel.ToString(CultureInfo.InvariantCulture));
                    }
                    SetNodeLevel(eventData.Node, Convert.ToByte((double)eventValue));
                    break;

                case EventParameter.SwitchBinary:
                    eventPath = EventPath_SwitchBinary;
                    {
                        double normalizedLevel = GetNormalizedValue((double)eventValue);
                        OnInterfacePropertyChanged(this.GetDomain(), eventData.Node.Id.ToString(), "ZWave Node", ModuleEvents.Status_Level + (eventData.Instance == 0 ? "" : "." + eventData.Instance), normalizedLevel.ToString(CultureInfo.InvariantCulture));
                    }
                    SetNodeLevel(eventData.Node, Convert.ToByte((double)eventValue));
                    break;

                case EventParameter.SwitchMultilevel:
                    eventPath = EventPath_SwitchMultilevel;
                    {
                        double normalizedLevel = GetNormalizedValue((double)eventValue);
                        OnInterfacePropertyChanged(this.GetDomain(), eventData.Node.Id.ToString(), "ZWave Node", ModuleEvents.Status_Level + (eventData.Instance == 0 ? "" : "." + eventData.Instance), normalizedLevel.ToString(CultureInfo.InvariantCulture));
                    }
                    SetNodeLevel(eventData.Node, Convert.ToByte((double)eventValue));
                    break;

                case EventParameter.ThermostatMode:
                    eventPath  = "Thermostat.Mode";
                    eventValue = ((ThermostatMode.Value)eventValue).ToString();
                    break;

                case EventParameter.ThermostatOperatingState:
                    eventPath  = "Thermostat.OperatingState";
                    eventValue = ((ThermostatOperatingState.Value)eventValue).ToString();
                    break;

                case EventParameter.ThermostatFanMode:
                    eventPath  = "Thermostat.FanMode";
                    eventValue = ((ThermostatFanMode.Value)eventValue).ToString();
                    break;

                case EventParameter.ThermostatFanState:
                    eventPath  = "Thermostat.FanState";
                    eventValue = ((ThermostatFanState.Value)eventValue).ToString();
                    break;

                case EventParameter.ThermostatHeating:
                    eventPath = "Thermostat.Heating";
                    break;

                case EventParameter.ThermostatSetBack:
                    eventPath = "Thermostat.SetBack";
                    break;

                case EventParameter.ThermostatSetPoint:
                    // value stores a dynamic object with Type and Value fields: value = { Type = ..., Value = ... }
                    eventPath  = "Thermostat.SetPoint." + ((ThermostatSetPoint.Value)((dynamic)eventValue).Type).ToString();
                    eventValue = ((dynamic)eventValue).Value;
                    break;

                case EventParameter.UserCode:
                    eventPath  = "EntryControl.UserCode";
                    eventValue = ((ZWaveLib.Values.UserCodeValue)eventValue).TagCodeToHexString();
                    break;

                case EventParameter.SecurityNodeInformationFrame:
                    eventPath = "ZWaveNode.SecuredNodeInfo";
                    break;

                case EventParameter.VersionCommandClass:
                    eventPath  = "ZWaveNode.Version." + (eventValue as ZWaveLib.Values.VersionValue).CmdClass;
                    eventValue = (eventValue as ZWaveLib.Values.VersionValue).Version;
                    break;

                default:
                    MigService.Log.Warn("Unhandled event from node {0} (Event={1}, Id={2}, Value={3})", eventData.Node.Id, eventData.Parameter, eventData.Instance, eventValue);
                    break;
                }

                OnInterfacePropertyChanged(this.GetDomain(), eventData.Node.Id.ToString(), "ZWave Node", eventPath, eventValue);

                eventData = eventData.NestedEvent;
            }
        }
        private void OnNodeUpdated(object sender, NodeUpdatedEventArgs e)
        {
            var node = e.Node;
            var viewModel = mStagingNodes.FirstOrDefault(n => n.Guid == node.Guid);

            if (node.IsInNetwork)
            {
                viewModel.Range.Visibility = Visibility.Collapsed;

                if (viewModel.Visibility == Visibility.Collapsed)
                    viewModel.Visibility = Visibility.Visible;

                if (!Nodes.Contains(viewModel))
                {
                    mNodeNetwork.FirstCollection = NodeNetwork.CollectionType.Nodes;
                    Nodes.Add(viewModel);
                }

                mNodeNetwork.NetworkElementsUpdated();
            }
            else if (!node.IsInNetwork)
            {
                if (Nodes.Contains(viewModel))
                {
                    mNodeNetwork.RemoveAllNodeLinks();
                    //Nodes.Remove(viewModel);
                    viewModel.Visibility = Visibility.Collapsed;
                }
            }
        }