Beispiel #1
0
        private void ExecuteCommand(ProgramCommand programCommand)
        {
            string command          = programCommand.Domain + "/" + programCommand.Target + "/" + programCommand.CommandString + "/" + System.Uri.EscapeDataString(programCommand.CommandArguments);
            var    interfaceCommand = new MigInterfaceCommand(command);

            homegenie.InterfaceControl(interfaceCommand);
        }
Beispiel #2
0
        public static object TryApiCall(MigInterfaceCommand command)
        {
            // Dynamic Interface API
            var registeredApi = command.Domain + "/" + command.Address + "/" + command.Command;
            var handler       = Find(registeredApi);

            if (handler != null)
            {
                // explicit command API handlers registered in the form <domain>/<address>/<command>
                // receives only the remaining part of the request after the <command>
                var args = command.OriginalRequest.Substring(registeredApi.Length).Trim('/');
                return(handler(args));
            }
            else
            {
                handler = FindMatching(command.OriginalRequest.Trim('/'));
                if (handler != null)
                {
                    // other command API handlers
                    if (command.Data == null || (command.Data is byte[] && (command.Data as byte[]).Length == 0))
                    {
                        // receives the full request as string if there is no `request.Data` payload
                        return(handler(command.OriginalRequest.Trim('/')));
                    }
                    else
                    {
                        // receives the original MigInterfaceCommand if `request.Data` actually holds some data
                        // TODO: this might be be the only entry point in future releases (line #98 and #87 cases will be deprecated)
                        return(handler(command));
                    }
                }
            }
            return(null);
        }
Beispiel #3
0
        // TODO strong typing
        private object GetHourlyStats(MigInterfaceCommand migCommand)
        {
            var domain        = "";
            var address       = "";
            var deviceAddress = migCommand.GetOption(0).Split(':');

            if (deviceAddress.Length == 2)
            {
                domain  = deviceAddress[0];
                address = deviceAddress[1];
            }

            var dateStart      = Utility.JavascriptToDate(long.Parse(migCommand.GetOption(2)));
            var dateEnd        = Utility.JavascriptToDate(long.Parse(migCommand.GetOption(3)));
            var parameterName  = migCommand.GetOption(0);
            var hourlyStats    = _homegenie.Statistics.GetHourlyStats(domain, address, parameterName, dateStart, dateEnd);
            var todayStartDate = DateTime.Today;
            var todayEndDate   = todayStartDate.AddDays(1);
            var todayDetails   = _homegenie.Statistics.GetDetailedStats(domain, address, parameterName, todayStartDate, todayEndDate);

            return(new object[]
            {
                hourlyStats[0].ToJsStatsArray(),
                hourlyStats[1].ToJsStatsArray(),
                hourlyStats[2].ToJsStatsArray(),
                todayDetails.ToJsStatsArray()
            });
        }
Beispiel #4
0
        public object TryDynamicApi(MigInterfaceCommand command)
        {
            object response = "";
            // Dynamic Interface API
            var registeredApi = command.Domain + "/" + command.Address + "/" + command.Command;
            var handler       = ProgramDynamiApi.Find(registeredApi);

            if (handler != null)
            {
                // explicit command API handlers registered in the form <domain>/<address>/<command>
                // receives only the remaining part of the request after the <command>
                var args = command.OriginalRequest.Substring(registeredApi.Length).Trim('/');
                response = handler(args);
            }
            else
            {
                handler = ProgramDynamiApi.FindMatching(command.OriginalRequest.Trim('/'));
                if (handler != null)
                {
                    // other command API handlers
                    // receives the full request string
                    response = handler(command.OriginalRequest.Trim('/'));
                }
            }
            return(response);
        }
Beispiel #5
0
        public void AddCommand(MigInterfaceCommand cmd)
        {
            double delay = 0;

            switch (delayType)
            {
            case MacroDelayType.Mimic:
                // calculate pause between current and previous command
                delay = new TimeSpan(DateTime.Now.Ticks - currentTimestamp.Ticks).TotalSeconds;
                break;

            case MacroDelayType.Fixed:
                // put a fixed pause
                delay = delaySeconds;
                break;
            }
            //
            try
            {
                if (delay > 0 && macroCommands.Count > 0)
                {
                    // add a pause command to the macro
                    macroCommands.Add(new MigInterfaceCommand(Domains.HomeAutomation_HomeGenie + "/Automation/Program.Pause/" + delay.ToString(System.Globalization.CultureInfo.InvariantCulture)));
                }
                macroCommands.Add(cmd);
            }
            catch
            {
                //HomeGenieService.LogEvent(Domains.HomeAutomation_HomeGenie, "migservice_ServiceRequestPostProcess(...)", ex.Message, "Exception.StackTrace", ex.StackTrace);
            }
            //
            currentTimestamp = DateTime.Now;
        }
        /// <summary>
        /// Handles the control of the interface from the Mig / HG web interface
        /// </summary>
        /// <param name="request">request body</param>
        /// <returns>object</returns>
        /// <exception cref="ArgumentOutOfRangeException">Argument out of range</exception>
        public object InterfaceControl(MigInterfaceCommand request)
        {
            var response = new ResponseText("OK"); // default success value

            Commands command;

            Enum.TryParse <Commands>(request.Command.Replace(".", "_"), out command);

            var module = this.modules.Find(m => m.Address.Equals(request.Address));

            if (module != null)
            {
                switch (command)
                {
                case Commands.Control_On:
                    this.OnInterfacePropertyChanged(this.GetDomain(), request.Address, "Test Interface", "Status.Level",
                                                    1);
                    break;

                case Commands.Control_Off:
                    this.OnInterfacePropertyChanged(this.GetDomain(), request.Address, "Test Interface", "Status.Level",
                                                    0);
                    break;

                case Commands.Temperature_Get:
                    this.OnInterfacePropertyChanged(this.GetDomain(), request.Address, "Test Interface",
                                                    "Sensor.Temperature", 19.75);
                    break;

                case Commands.Greet_Hello:
                    this.OnInterfacePropertyChanged(this.GetDomain(), request.Address, "Test Interface",
                                                    "Sensor.Message", string.Format("Hello {0}", request.GetOption(0)));
                    response = new ResponseText("Hello World!");
                    break;

                case Commands.NotSet:
                    break;

                default:
                    Log.Error(new ArgumentOutOfRangeException(), "Command [{0}] not recognised", command);
                    break;
                }
            }
            else
            {
                response = new ResponseText("ERROR: invalid module address");
            }

            return(response);
        }
        private object InterfaceControl(Module module, MigInterfaceCommand migCommand)
        {
            object response = null;

            migCommand.Domain  = module.Domain;
            migCommand.Address = module.Address;
            try
            {
                response = homegenie.InterfaceControl(migCommand);
            }
            catch (Exception e)
            {
                // TODO: should report the error?
            }
            return(response);
        }
Beispiel #8
0
        // TODO strong typing
        private List <ModuleStatsDto> GetMultipleModulesStats(MigInterfaceCommand migCommand)
        {
            var dateStart     = Utility.JavascriptToDate(long.Parse(migCommand.GetOption(2)));
            var dateEnd       = Utility.JavascriptToDate(long.Parse(migCommand.GetOption(3)));
            var parameterName = migCommand.GetOption(0);
            var dailyStats    = _homegenie.Statistics.GetMultipleModulesDetailedStats(parameterName, dateStart, dateEnd);

            var result = new List <ModuleStatsDto>();

            foreach (var moduleStats in dailyStats)
            {
                result.Add(new ModuleStatsDto
                {
                    Name  = moduleStats.Key,
                    Stats = moduleStats.Value.ToJsStatsArray()
                });
            }
            return(result);
        }
Beispiel #9
0
        // TODO strong typing
        private object GetDailyStats(MigInterfaceCommand migCommand)
        {
            var domain        = "";
            var address       = "";
            var deviceAddress = migCommand.GetOption(0).Split(':');

            if (deviceAddress.Length == 2)
            {
                domain  = deviceAddress[0];
                address = deviceAddress[1];
            }

            var dateStart     = Utility.JavascriptToDate(long.Parse(migCommand.GetOption(2)));
            var dateEnd       = Utility.JavascriptToDate(long.Parse(migCommand.GetOption(3)));
            var parameterName = migCommand.GetOption(0);
            var dailyStats    = _homegenie.Statistics.GetDetailedStats(domain, address, parameterName, dateStart, dateEnd);

            return(dailyStats.ToJsStatsArray());
        }
Beispiel #10
0
        public object InterfaceControl(MigInterfaceCommand request)
        {
            var response = new ResponseText("OK"); //default success value

            Commands command;

            Enum.TryParse(request.Command.Replace(".", "_"), out command);

            var module = _modules.Find(m => m.Address.Equals(request.Address));

            if (module != null)
            {
                switch (command)
                {
                case Commands.Control_On:
                    _connection.Action(module.Address.Replace(".", "/"), true);
                    break;

                case Commands.Control_Off:
                    _connection.Action(module.Address.Replace(".", "/"), false);
                    // TODO: ...
                    break;

                case Commands.Dimmer_Up:
                    _connection.Action(module.Address.Replace(".", "/"), _connection.ToDataPoint("3.008", 3));
                    // TODO: ...
                    break;

                case Commands.Dimmer_Down:
                    _connection.Action(module.Address.Replace(".", "/"), _connection.ToDataPoint("3.008", -3));
                    // TODO: ...
                    break;
                }
            }
            else
            {
                response = new ResponseText("ERROR: invalid module address");
            }

            return(response);
        }
Beispiel #11
0
        /// <summary>
        /// InterfaceControl
        /// </summary>
        /// <param name="request">request from web interface</param>
        /// <returns>object</returns>
        public object InterfaceControl(MigInterfaceCommand request)
        {
            string response = string.Empty;

            Commands command;

            Enum.TryParse <Commands>(request.Command.Replace(".", "_"), out command);

            switch (command)
            {
            case Commands.Camera_GetPicture:
            {
                // get picture from camera <nodeid>
                // TODO: there is actually only single camera support
                if (this.cameraSource != IntPtr.Zero)
                {
                    lock (this.readPictureLock)
                    {
                        var pictureBuffer = CameraCaptureV4LInterop.GetFrame(this.cameraSource);
                        var data          = new byte[pictureBuffer.Size];
                        Marshal.Copy(pictureBuffer.Data, data, 0, pictureBuffer.Size);
                        return(data);
                    }
                }

                break;
            }

            case Commands.Camera_GetLuminance:
                // TODO: ....
                break;

            case Commands.Camera_SetDevice:
                this.GetOption("Configuration").Value = request.GetOption(0) + "," + request.GetOption(1) + "," + request.GetOption(2) + "," + request.GetOption(3);
                this.Connect();
                break;
            }

            return(response);
        }
        public object InterfaceControl(MigInterfaceCommand request)
        {
            var response = new ResponseText("OK"); //default success value

            //Commands command;
            //Enum.TryParse<Commands>(request.Command.Replace(".", "_"), out command);

            //var module = interfaceModules.Find (m => m.Address.Equals (request.Address));

            //if (module != null) {
            //    switch (command) {
            //    case Commands.Control_On:
            //    // TODO: ...
            //        OnInterfacePropertyChanged (this.GetDomain (), request.Address, "Test Interface", "Status.Level", 1);
            //        break;
            //    case Commands.Control_Off:
            //        OnInterfacePropertyChanged (this.GetDomain (), request.Address, "Test Interface", "Status.Level", 0);
            //    // TODO: ...
            //        break;
            //    case Commands.Temperature_Get:
            //        OnInterfacePropertyChanged (this.GetDomain (), request.Address, "Test Interface", "Sensor.Temperature", 19.75);
            //    // TODO: ...
            //        break;
            //    case Commands.Greet_Hello:
            //    // TODO: ...
            //        OnInterfacePropertyChanged (this.GetDomain (), request.Address, "Test Interface", "Sensor.Message", string.Format ("Hello {0}", request.GetOption (0)));
            //        response = new ResponseText ("Hello World!");
            //        break;
            //    }
            //}
            //else
            //{
            //    response = new ResponseText ("ERROR: invalid module address");
            //}

            return(response);
        }
Beispiel #13
0
 public object InterfaceControl(MigInterfaceCommand request)
 {
     return("");
 }
Beispiel #14
0
        public object InterfaceControl(MigInterfaceCommand request)
        {
            ResponseText returnValue = new ResponseText("OK");
            bool raiseEvent = false;
            string eventParameter = ModuleEvents.Status_Level;
            string eventValue = "";

            string nodeId = request.Address;
            Commands command;
            Enum.TryParse<Commands>(request.Command.Replace(".", "_"), out command);
            ZWaveNode node = null;

            byte nodeNumber = 0;
            if (byte.TryParse(nodeId, out nodeNumber))
            {
                if (nodeNumber > 0)
                    node = controller.GetNode(nodeNumber);
                switch (command)
                {

                case Commands.Controller_Discovery:
                    controller.Discovery();
                    break;

                case Commands.Controller_SoftReset:
                    controller.SoftReset();
                    break;

                case Commands.Controller_HardReset:
                    controller.HardReset();
                    controller.Discovery();
                    break;

                case Commands.Controller_HealNetwork:
                    controller.HealNetwork();
                    break;

                case Commands.Controller_NodeNeighborUpdate:
                    controller.RequestNeighborsUpdateOptions(nodeNumber);
                    controller.RequestNeighborsUpdate(nodeNumber);
                    controller.GetNeighborsRoutingInfo(nodeNumber);
                    returnValue = GetResponseValue(nodeNumber, EventPath_RoutingInfo);
                    break;

                case Commands.Controller_NodeRoutingInfo:
                    controller.GetNeighborsRoutingInfo(nodeNumber);
                    returnValue = GetResponseValue(nodeNumber, EventPath_RoutingInfo);
                    break;

                case Commands.Controller_NodeAdd:
                    lastAddedNode = 0;
                    controller.BeginNodeAdd();
                    for (int i = 0; i < 20; i++)
                    {
                        if (lastAddedNode > 0)
                        {
                            break;
                        }
                        Thread.Sleep(500);
                    }
                    controller.StopNodeAdd();
                    returnValue = new ResponseText(lastAddedNode.ToString());
                    break;

                case Commands.Controller_NodeRemove:
                    lastRemovedNode = 0;
                    controller.BeginNodeRemove();
                    for (int i = 0; i < 20; i++)
                    {
                        if (lastRemovedNode > 0)
                        {
                            break;
                        }
                        Thread.Sleep(500);
                    }
                    controller.StopNodeRemove();
                    returnValue = new ResponseText(lastRemovedNode.ToString());
                    break;

                case Commands.Basic_Set:
                    {
                        raiseEvent = true;
                        var level = int.Parse(request.GetOption(0));
                        eventValue = level.ToString(CultureInfo.InvariantCulture);
                        Basic.Set(node, (byte)level);
                    }
                    break;

                case Commands.Basic_Get:
                    Basic.Get(node);
                    returnValue = GetResponseValue(nodeNumber, EventPath_Basic);
                    break;

                case Commands.SwitchBinary_Set:
                    {
                        raiseEvent = true;
                        var level = int.Parse(request.GetOption(0));
                        eventValue = level.ToString(CultureInfo.InvariantCulture);
                        SwitchBinary.Set(node, (byte)level);
                    }
                    break;

                case Commands.SwitchBinary_Get:
                    SwitchBinary.Get(node);
                    returnValue = GetResponseValue(nodeNumber, EventPath_SwitchBinary);
                    break;

                case Commands.SwitchMultilevel_Set:
                    {
                        raiseEvent = true;
                        var level = int.Parse(request.GetOption(0));
                        eventValue = level.ToString(CultureInfo.InvariantCulture);
                        SwitchMultilevel.Set(node, (byte)level);
                    }
                    break;

                case Commands.SwitchMultilevel_Get:
                    SwitchMultilevel.Get(node);
                    returnValue = GetResponseValue(nodeNumber, EventPath_SwitchMultilevel);
                    break;

                case Commands.MultiInstance_GetCount:
                    {
                        string commandType = request.GetOption(0).Replace(".", "");
                        switch (commandType)
                        {
                        case "SwitchBinary":
                            MultiInstance.GetCount(node, (byte)ZWaveLib.CommandClass.SwitchBinary);
                            break;
                        case "SwitchMultiLevel":
                            MultiInstance.GetCount(node, (byte)ZWaveLib.CommandClass.SwitchMultilevel);
                            break;
                        case "SensorBinary":
                            MultiInstance.GetCount(node, (byte)ZWaveLib.CommandClass.SensorBinary);
                            break;
                        case "SensorMultiLevel":
                            MultiInstance.GetCount(node, (byte)ZWaveLib.CommandClass.SensorMultilevel);
                            break;
                        }
                        returnValue = GetResponseValue(nodeNumber, EventPath_MultiInstance + "." + commandType + ".Count");
                    }
                    break;

                case Commands.MultiInstance_Get:
                    {
                        byte instance = (byte)int.Parse(request.GetOption(1));
                        string commandType = request.GetOption(0).Replace(".", "");
                        switch (commandType)
                        {
                        case "SwitchBinary":
                            MultiInstance.SwitchBinaryGet(node, instance);
                            break;
                        case "SwitchMultiLevel":
                            MultiInstance.SwitchMultiLevelGet(node, instance);
                            break;
                        case "SensorBinary":
                            MultiInstance.SensorBinaryGet(node, instance);
                            break;
                        case "SensorMultiLevel":
                            MultiInstance.SensorMultiLevelGet(node, instance);
                            break;
                        }
                        returnValue = GetResponseValue(nodeNumber, EventPath_MultiInstance + "." + commandType + "." + instance);
                    }
                    break;

                case Commands.MultiInstance_Set:
                    {
                        byte instance = (byte)int.Parse(request.GetOption(1));
                        int value = int.Parse(request.GetOption(2));
                        //
                        //raisepropchanged = true;
                        //parampath += "." + instance; // Status.Level.<instance>
                        //
                        switch (request.GetOption(0))
                        {
                        case "Switch.Binary":
                            MultiInstance.SwitchBinarySet(node, instance, value);
                        //raiseparam = (double.Parse(request.GetOption(2)) / 255).ToString();
                            break;
                        case "Switch.MultiLevel":
                            MultiInstance.SwitchMultiLevelSet(node, instance, value);
                        //raiseparam = (double.Parse(request.GetOption(2)) / 100).ToString(); // TODO: should it be 99 ?
                            break;
                        }
                    }
                    break;

                case Commands.SensorBinary_Get:
                    SensorBinary.Get(node);
                    break;

                case Commands.SensorMultiLevel_Get:
                    SensorMultilevel.Get(node);
                    break;

                case Commands.Meter_Get:
                // see ZWaveLib Sensor.cs for EnergyMeterScale options
                    int scaleType = 0;
                    int.TryParse(request.GetOption(0), out scaleType);
                    Meter.Get(node, (byte)(scaleType << 0x03));
                    break;

                case Commands.Meter_SupportedGet:
                    Meter.GetSupported(node);
                    break;

                case Commands.Meter_Reset:
                    Meter.Reset(node);
                    break;

                case Commands.NodeInfo_Get:
                    controller.GetNodeInformationFrame(nodeNumber);
                    returnValue = GetResponseValue(nodeNumber, EventPath_NodeInfo);
                    break;

                case Commands.Version_Report:
                    ZWaveLib.CommandClasses.Version.Report(node);
                    returnValue = GetResponseValue(nodeNumber, EventPath_VersionReport);
                    break;

                case Commands.Battery_Get:
                    Battery.Get(node);
                    returnValue = GetResponseValue(nodeNumber, EventPath_Battery);
                    break;

                case Commands.Association_Set:
                    Association.Set(node, (byte)int.Parse(request.GetOption(0)), (byte)int.Parse(request.GetOption(1)));
                    break;

                case Commands.Association_Get:
                    byte group = (byte)int.Parse(request.GetOption(0));
                    Association.Get(node, group);
                    returnValue = GetResponseValue(nodeNumber, EventPath_Associations + "." + group);
                    break;

                case Commands.Association_Remove:
                    Association.Remove(node, (byte)int.Parse(request.GetOption(0)), (byte)int.Parse(request.GetOption(1)));
                    break;

                case Commands.ManufacturerSpecific_Get:
                    ManufacturerSpecific.Get(node);
                    returnValue = GetResponseValue(nodeNumber, EventPath_ManufacturerSpecific);
                    break;

                case Commands.Config_ParameterSet:
                    Configuration.Set(node, (byte)int.Parse(request.GetOption(0)), int.Parse(request.GetOption(1)));
                    break;

                case Commands.Config_ParameterGet:
                    byte position = (byte)int.Parse(request.GetOption(0));
                    Configuration.Get(node, position);
                    returnValue = GetResponseValue(nodeNumber, EventPath_ConfigVariables + "." + position);
                    break;

                case Commands.WakeUp_Get:
                    WakeUp.Get(node);
                    returnValue = GetResponseValue(nodeNumber, EventPath_WakeUpInterval);
                    break;

                case Commands.WakeUp_Set:
                    WakeUp.Set(node, uint.Parse(request.GetOption(0)));
                    break;

                case Commands.WakeUp_SendToSleep:
                    WakeUp.SendToSleep(node);
                    break;

                case Commands.WakeUp_GetAlwaysAwake:
                    returnValue = new ResponseText(WakeUp.GetAlwaysAwake(node) ? "1" : "0");
                    break;

                case Commands.WakeUp_SetAlwaysAwake:
                    WakeUp.SetAlwaysAwake(node, uint.Parse(request.GetOption(0)) == 1 ? true : false);
                    break;

                case Commands.Version_Get:
                    returnValue = new ResponseText("ERROR");
                    CommandClass cclass;
                    Enum.TryParse<CommandClass>(request.GetOption(0), out cclass);
                    if (cclass != CommandClass.NotSet)
                    {
                        var nodeCclass = node.GetCommandClass(cclass);
                        if (nodeCclass != null && nodeCclass.Version != 0)
                        {
                            returnValue = new ResponseText(nodeCclass.Version.ToString());
                        }
                        else
                        {
                            ZWaveLib.CommandClasses.Version.Get(node, cclass);
                            returnValue = GetResponseValue(nodeNumber, "ZWaveNode.Version." + cclass);
                        }
                    }
                    break;

                case Commands.Version_GetAll:
                    controller.GetNodeCcsVersion(node);
                    break;

                case Commands.Control_On:
                    raiseEvent = true;
                    double lastLevel = GetNormalizedValue((double)GetNodeLastLevel(node));
                    eventValue = lastLevel > 0 ? lastLevel.ToString(CultureInfo.InvariantCulture) : "1";
                    if (node.SupportCommandClass(CommandClass.SwitchMultilevel))
                        SwitchMultilevel.Set(node, 0xFF);
                    else if (node.SupportCommandClass(CommandClass.SwitchBinary))
                        SwitchBinary.Set(node, 0xFF);
                    else
                        Basic.Set(node, 0xFF);
                    SetNodeLevel(node, 0xFF);
                    break;

                case Commands.Control_Off:
                    raiseEvent = true;
                    eventValue = "0";
                    if (node.SupportCommandClass(CommandClass.SwitchMultilevel))
                        SwitchMultilevel.Set(node, 0x00);
                    else if (node.SupportCommandClass(CommandClass.SwitchBinary))
                        SwitchBinary.Set(node, 0x00);
                    else
                        Basic.Set(node, 0x00);
                    SetNodeLevel(node, 0x00);
                    break;

                case Commands.Control_Level:
                    {
                        raiseEvent = true;
                        var level = int.Parse(request.GetOption(0));
                        eventValue = Math.Round(level / 100D, 2).ToString(CultureInfo.InvariantCulture);
                        // the max value should be obtained from node parameters specifications,
                        // here we assume that the commonly used interval is [0-99] for most multilevel switches
                        if (level >= 100)
                            level = 99;
                        if (node.SupportCommandClass(CommandClass.SwitchMultilevel))
                            SwitchMultilevel.Set(node, (byte)level);
                        else
                            Basic.Set(node, (byte)level);
                        SetNodeLevel(node, (byte)level);
                    }
                    break;

                case Commands.Control_Toggle:
                    raiseEvent = true;
                    if (GetNodeLevel(node) == 0)
                    {
                        double lastOnLevel = GetNormalizedValue((double)GetNodeLastLevel(node));
                        eventValue = lastOnLevel > 0 ? lastOnLevel.ToString(CultureInfo.InvariantCulture) : "1";
                        if (node.SupportCommandClass(CommandClass.SwitchMultilevel))
                            SwitchMultilevel.Set(node, 0xFF);
                        else if (node.SupportCommandClass(CommandClass.SwitchBinary))
                            SwitchBinary.Set(node, 0xFF);
                        else
                            Basic.Set(node, 0xFF);
                        SetNodeLevel(node, 0xFF);
                    }
                    else
                    {
                        eventValue = "0";
                        if (node.SupportCommandClass(CommandClass.SwitchMultilevel))
                            SwitchMultilevel.Set(node, 0x00);
                        else if (node.SupportCommandClass(CommandClass.SwitchBinary))
                            SwitchBinary.Set(node, 0x00);
                        else
                            Basic.Set(node, 0x00);
                        SetNodeLevel(node, 0x00);
                    }
                    break;

                case Commands.Thermostat_ModeGet:
                    ThermostatMode.Get(node);
                    break;

                case Commands.Thermostat_ModeSet:
                    {
                        ThermostatMode.Value mode = (ThermostatMode.Value)Enum.Parse(typeof(ThermostatMode.Value), request.GetOption(0));
                        //
                        raiseEvent = true;
                        eventParameter = "Thermostat.Mode";
                        eventValue = request.GetOption(0);
                        //
                        ThermostatMode.Set(node, mode);
                    }
                    break;

                case Commands.Thermostat_SetPointGet:
                    {
                        ThermostatSetPoint.Value mode = (ThermostatSetPoint.Value)Enum.Parse(typeof(ThermostatSetPoint.Value), request.GetOption(0));
                        ThermostatSetPoint.Get(node, mode);
                    }
                    break;

                case Commands.Thermostat_SetPointSet:
                    {
                        ThermostatSetPoint.Value mode = (ThermostatSetPoint.Value)Enum.Parse(typeof(ThermostatSetPoint.Value), request.GetOption(0));
                        double temperature = double.Parse(request.GetOption(1).Replace(',', '.'), CultureInfo.InvariantCulture);
                        //
                        raiseEvent = true;
                        eventParameter = "Thermostat.SetPoint." + request.GetOption(0);
                        eventValue = temperature.ToString(CultureInfo.InvariantCulture);
                        //
                        ThermostatSetPoint.Set(node, mode, temperature);
                    }
                    break;

                case Commands.Thermostat_FanModeGet:
                    ThermostatFanMode.Get(node);
                    break;

                case Commands.Thermostat_FanModeSet:
                    {
                        ThermostatFanMode.Value mode = (ThermostatFanMode.Value)Enum.Parse(typeof(ThermostatFanMode.Value), request.GetOption(0));
                        //
                        raiseEvent = true;
                        eventParameter = "Thermostat.FanMode";
                        eventValue = request.GetOption(0);
                        //
                        ThermostatFanMode.Set(node, mode);
                    }
                    break;

                case Commands.Thermostat_FanStateGet:
                    ThermostatFanState.Get(node);
                    break;

                case Commands.Thermostat_OperatingStateGet:
                    ThermostatOperatingState.GetOperatingState(node);
                    break;

                case Commands.UserCode_Set:
                    byte userId = byte.Parse(request.GetOption(0));
                    byte userIdStatus = byte.Parse(request.GetOption(1));
                    byte[] tagCode = ZWaveLib.Utility.HexStringToByteArray(request.GetOption(2));
                    UserCode.Set(node, new ZWaveLib.Values.UserCodeValue(userId, userIdStatus, tagCode));
                    break;

                case Commands.DoorLock_Get:
                    DoorLock.Get(node);
                    returnValue = GetResponseValue(nodeNumber, ModuleEvents.Status_DoorLock);
                    break;

                case Commands.DoorLock_Set:
                    {
                        DoorLock.Value mode = (DoorLock.Value)Enum.Parse(typeof(DoorLock.Value), request.GetOption(0));
                        DoorLock.Set(node, mode);
                    }
                    break;

                case Commands.Db_Update:
                    {
                        var p1db = new Pepper1Db();
                        p1db.Update(request.GetOption(0));
                        break;
                    }
                case Commands.Db_GetDevice:
                    {
                        var p1db = new Pepper1Db();
                        returnValue = new ResponseText(p1db.GetDeviceInfo(request.GetOption(0), request.GetOption(1)));
                        break;
                    }
                }
            }

            if (raiseEvent)
            {
                //ZWaveNode node = _controller.GetDevice ((byte)int.Parse (nodeid));
                OnInterfacePropertyChanged(this.GetDomain(), nodeId, "ZWave Node", eventParameter, eventValue);
            }
            //
            return returnValue;
        }
 public object InterfaceControl(MigInterfaceCommand request)
 {
     return "";
 }
Beispiel #16
0
        public object InterfaceControl(MigInterfaceCommand request)
        {
            ResponseText response = new ResponseText("OK");

            string nodeId = request.Address;
            string option = request.GetOption(0);

            Commands command;
            Enum.TryParse<Commands>(request.Command.Replace(".", "_"), out command);

            // Parse house/unit
            var houseCode = XTenLib.Utility.HouseCodeFromString(nodeId);
            var unitCode = XTenLib.Utility.UnitCodeFromString(nodeId);

            switch (command)
            {
            case Commands.Parameter_Status:
                x10lib.StatusRequest(houseCode, unitCode);
                break;
            case Commands.Control_On:
                x10lib.UnitOn(houseCode, unitCode);
                break;
            case Commands.Control_Off:
                x10lib.UnitOff(houseCode, unitCode);
                break;
            case Commands.Control_Bright:
                x10lib.Bright(houseCode, unitCode, int.Parse(option));
                break;
            case Commands.Control_Dim:
                x10lib.Dim(houseCode, unitCode, int.Parse(option));
                break;
            case Commands.Control_Level_Adjust:
                int adjvalue = int.Parse(option);
                //x10lib.Modules[nodeId].Level = ((double)adjvalue/100D);
                OnInterfacePropertyChanged(this.GetDomain(), nodeId, "X10 Module", ModuleEvents.Status_Level, x10lib.Modules[nodeId].Level);
                throw(new NotImplementedException("X10 CONTROL_LEVEL_ADJUST Not Implemented"));
                break;
            case Commands.Control_Level:
                int dimvalue = int.Parse(option) - (int)(x10lib.Modules[nodeId].Level * 100.0);
                if (dimvalue > 0)
                {
                    x10lib.Bright(houseCode, unitCode, dimvalue);
                }
                else if (dimvalue < 0)
                {
                    x10lib.Dim(houseCode, unitCode, -dimvalue);
                }
                break;
            case Commands.Control_Toggle:
                string huc = XTenLib.Utility.HouseUnitCodeFromEnum(houseCode, unitCode);
                if (x10lib.Modules[huc].Level == 0)
                {
                    x10lib.UnitOn(houseCode, unitCode);
                }
                else
                {
                    x10lib.UnitOff(houseCode, unitCode);
                }
                break;
            case Commands.Control_AllLightsOn:
                x10lib.AllLightsOn(houseCode);
                break;
            case Commands.Control_AllLightsOff:
                x10lib.AllUnitsOff(houseCode);
                break;
            }

            return response;
        }
        public object InterfaceControl(MigInterfaceCommand command)
        {
            string returnValue          = "";
            bool   raisePropertyChanged = false;
            string parameterPath        = "Status.Level";
            string raiseParameter       = "";

            switch (command.Command)
            {
            case "Control.On":
                var oldActivity = controller.StartActivity(command.Address);
                if (!string.IsNullOrEmpty(oldActivity))
                {
                    OnInterfacePropertyChanged(this.GetDomain(), oldActivity, Event_Node_Description, parameterPath, "0");
                }
                raisePropertyChanged = true;
                raiseParameter       = "1";
                break;

            case "Control.Off":
                raisePropertyChanged = true;
                bool isOff = controller.TurnOff(command.Address);
                if (isOff)
                {
                    raiseParameter = "0";
                }
                else
                {
                    returnValue = isOff.ToString();
                }
                break;

            case "Control.Toggle":
                controller.Toggle(command.Address);
                raisePropertyChanged = true;
                break;

            case "Control.Reset":
                controller.Reset();
                raiseParameter       = "Reset";
                raisePropertyChanged = true;
                break;

            default:
                Console.WriteLine("TS:" + command.Command + " | " + command.Address);
                break;
            }

            if (raisePropertyChanged)
            {
                try
                {
                    OnInterfacePropertyChanged(this.GetDomain(), command.Address, Event_Node_Description, parameterPath, raiseParameter);
                }
                catch (Exception ex)
                {
                    Console.WriteLine("Exception catched on OnInterfacePropertyChanged. Message: {0}", ex.Message);
                }
            }

            return(returnValue);
        }
        public object InterfaceControl(MigInterfaceCommand command)
        {
            string returnValue          = "";
            bool   raisePropertyChanged = false;
            string parameterPath        = "Status.Level";
            string raiseParameter       = "";

            switch (command.Command)
            {
            case "Control.On":
                controller.TurnOn(int.Parse(command.Address));
                raisePropertyChanged = true;
                raiseParameter       = "1";
                break;

            case "Control.Off":
                raisePropertyChanged = true;
                controller.TurnOff(int.Parse(command.Address));
                raiseParameter = "0";
                break;

            case "Control.Level":
                var dimValue = double.Parse(command.GetOption(0));
                if (dimValue == 0)
                {
                    controller.TurnOff(int.Parse(command.Address));
                    raisePropertyChanged = true;
                    raiseParameter       = "0";
                }
                else
                {
                    controller.Dim(int.Parse(command.Address), (int)Math.Round(dimValue));
                    raisePropertyChanged = true;
                    raiseParameter       = (dimValue / 100.0).ToString(CultureInfo.InvariantCulture);
                }
                break;

            case "Control.Toggle":
                int status = controller.LastSentCommand(int.Parse(command.Address), (int)(Command.DIM | Command.TURNON | Command.TURNOFF));

                if (status == (int)Command.TURNOFF)
                {
                    controller.TurnOn(int.Parse(command.Address));
                    raiseParameter = "1";
                }
                else
                {
                    controller.TurnOff(int.Parse(command.Address));
                    raiseParameter = "0";
                }
                raisePropertyChanged = true;
                break;

            default:
                Console.WriteLine("TS:" + command.Command + " | " + command.Address);
                break;
            }

            if (raisePropertyChanged)
            {
                try
                {
                    OnInterfacePropertyChanged(this.GetDomain(), command.Address, Event_Node_Description, parameterPath, raiseParameter);
                }
                catch (Exception ex)
                {
                    Console.WriteLine("Exception catched on OnInterfacePropertyChanged. Message: {0}", ex.Message);
                }
            }
            return(returnValue);
        }
Beispiel #19
0
        private void HandleScheduling(MigInterfaceCommand migCommand, MigClientRequest request)
        {
            switch (migCommand.Command)
            {
            case "Scheduling.Add":
            case "Scheduling.Update":
                var newSchedule = JsonConvert.DeserializeObject <SchedulerItem>(request.RequestText);
                var item        = homegenie.ProgramManager.SchedulerService.AddOrUpdate(
                    newSchedule.Name,
                    newSchedule.CronExpression,
                    newSchedule.Data,
                    newSchedule.Description,
                    newSchedule.Script
                    );
                if (newSchedule.BoundDevices != null)
                {
                    item.BoundDevices = newSchedule.BoundDevices;
                }
                if (newSchedule.BoundModules != null)
                {
                    item.BoundModules = newSchedule.BoundModules;
                }
                homegenie.UpdateSchedulerDatabase();
                break;

            case "Scheduling.Delete":
                homegenie.ProgramManager.SchedulerService.Remove(migCommand.GetOption(0));
                homegenie.UpdateSchedulerDatabase();
                break;

            case "Scheduling.Enable":
                homegenie.ProgramManager.SchedulerService.Enable(migCommand.GetOption(0));
                homegenie.UpdateSchedulerDatabase();
                break;

            case "Scheduling.Disable":
                homegenie.ProgramManager.SchedulerService.Disable(migCommand.GetOption(0));
                homegenie.UpdateSchedulerDatabase();
                break;

            case "Scheduling.Get":
                request.ResponseData = homegenie.ProgramManager.SchedulerService.Get(migCommand.GetOption(0));
                break;

            case "Scheduling.ListOccurrences":
                var hours = 24;
                int.TryParse(migCommand.GetOption(0), out hours);
                var dateStart = DateTime.Today.ToUniversalTime();
                var startFrom = migCommand.GetOption(1);
                if (!string.IsNullOrWhiteSpace(startFrom))
                {
                    dateStart = Utility.JavascriptToDate(long.Parse(startFrom));
                }

                var nextList = new List <dynamic>();
                foreach (var schedulerItem in homegenie.ProgramManager.SchedulerService.Items)
                {
                    if (!schedulerItem.IsEnabled)
                    {
                        continue;
                    }

                    var evt = new
                    {
                        Name        = schedulerItem.Name, Description = schedulerItem.Description,
                        RunScript   = !string.IsNullOrWhiteSpace(schedulerItem.Script),
                        Occurrences = new List <double>()
                    };

                    var dateEnd = dateStart.AddHours(hours);
                    var occurs  = homegenie.ProgramManager.SchedulerService.GetScheduling(
                        dateStart, dateEnd, schedulerItem.CronExpression);
                    occurs.Sort();
                    foreach (var dt in occurs)
                    {
                        evt.Occurrences.Add(Utility.DateToJavascript(dt.ToUniversalTime()));
                    }

                    if (evt.Occurrences.Count > 0)
                    {
                        nextList.Add(evt);
                    }
                }

                request.ResponseData = nextList;
                break;

            case "Scheduling.List":
                homegenie.ProgramManager.SchedulerService.Items.Sort((s1, s2) => s1.Name.CompareTo(s2.Name));
                request.ResponseData = homegenie.ProgramManager.SchedulerService.Items;
                break;

            case "Scheduling.Describe":
                var cronDescription = "";
                try
                {
                    cronDescription = ExpressionDescriptor.GetDescription(migCommand.GetOption(0).Trim());
                    cronDescription = char.ToLowerInvariant(cronDescription[0]) + cronDescription.Substring(1);
                }
                catch
                {
                }

                request.ResponseData = new ResponseText(cronDescription);
                break;

            case "Scheduling.SolarTimes":
                var solarTimes = new SolarTimes(DateTime.Now,
                                                homegenie.ProgramManager.SchedulerService.Location["latitude"].Value,
                                                homegenie.ProgramManager.SchedulerService.Location["longitude"].Value);
                request.ResponseData = solarTimes;
                break;
            }
        }
        /// <summary>
        /// Handles the control of the interface from the Mig / HG web interface
        /// </summary>
        /// <param name="request">request body</param>
        /// <returns>object</returns>
        /// <exception cref="ArgumentOutOfRangeException">Argument out of range</exception>
        public object InterfaceControl(MigInterfaceCommand request)
        {
            var returnValue = new ResponseText("OK");

            var raiseEvent = false;

            // TODO use / update this param
            var eventParameter = "Status.Level";

            var eventValue = string.Empty;

            Enum.TryParse(request.Command.Replace(".", "_"), out Commands command);
            var dc = new DeviceController(Convert.ToInt64(request.Address), this.gatewayConnection.Client);

            Log.Debug("Command: {0}", command);

            switch (command)
            {
            case Commands.Control_On:
                raiseEvent = true;
                dc.TurnOn();
                break;

            case Commands.Control_Off:
                raiseEvent = true;
                dc.TurnOff();
                break;

            case Commands.Control_Toggle:
                throw new NotImplementedException();

            case Commands.Control_Colour:
                raiseEvent = true;
                var colour = request.GetOption(0);

                // todo parse enum
                Log.Debug("Setting Colour to {0}", colour);
                dc.SetColor(colour);
                break;

            case Commands.Controller_Reboot:
                this.gatewayController.Reboot();
                Log.Info("Rebooting controller");
                break;

            case Commands.Battery_Get:
                var dev = dc.GetTradFriDevice();
                returnValue = new ResponseText(dev.Info.Battery.ToString());
                break;

            default:
                Log.Error(new ArgumentOutOfRangeException(), "Command [{0}] not recognised", command);
                break;
            }

            if (raiseEvent)
            {
                this.OnInterfacePropertyChanged(this.GetDomain(), request.Address, "Tradfri Node", eventParameter, eventValue);
            }

            return(returnValue);
        }
Beispiel #21
0
        public object InterfaceControl(MigInterfaceCommand request)
        {
            var response = new ResponseText("OK");

            string nodeId = lastAddressedModule = request.Address;
            string option = request.GetOption(0);

            Commands command;

            Enum.TryParse <Commands>(request.Command.Replace(".", "_"), out command);

            if (portName == Cm19LibDriverPort)
            {
                // Parse house/unit
                var houseCode = CM19Lib.Utility.HouseCodeFromString(nodeId);
                var unitCode  = CM19Lib.Utility.UnitCodeFromString(nodeId);
                var module    = GetSecurityModuleByAddress(nodeId, ModuleTypes.Switch);
                // module.CustomData is used to store the current level
                switch (command)
                {
                case Commands.Control_On:
                    cm19Lib.UnitOn(houseCode, unitCode);
                    module.CustomData = 1D;
                    UpdateModuleLevel(module);
                    break;

                case Commands.Control_Off:
                    cm19Lib.UnitOff(houseCode, unitCode);
                    module.CustomData = 0D;
                    UpdateModuleLevel(module);
                    break;

                case Commands.Control_Bright:
                    cm19Lib.Bright(houseCode);
                    module.CustomData = module.CustomData + (5 / 100D);
                    if (module.CustomData > 1)
                    {
                        module.CustomData = 1D;
                    }
                    UpdateModuleLevel(module);
                    break;

                case Commands.Control_Dim:
                    cm19Lib.Dim(houseCode);
                    module.CustomData = module.CustomData - (5 / 100D);
                    if (module.CustomData < 0)
                    {
                        module.CustomData = 0D;
                    }
                    UpdateModuleLevel(module);
                    break;

                case Commands.Control_Level:
                    int dimValue = (int.Parse(option) - (int)(module.CustomData * 100.0)) / 5;
                    if (dimValue > 0)
                    {
                        cm19Lib.Bright(houseCode);
                        for (int i = 0; i < (dimValue / Cm19Manager.SendRepeatCount); i++)
                        {
                            cm19Lib.Bright(houseCode);
                        }
                    }
                    else if (dimValue < 0)
                    {
                        cm19Lib.Dim(houseCode);
                        for (int i = 0; i < -(dimValue / Cm19Manager.SendRepeatCount); i++)
                        {
                            cm19Lib.Dim(houseCode);
                        }
                    }
                    module.CustomData = module.CustomData + (dimValue * 5 / 100D);
                    UpdateModuleLevel(module);
                    break;

                case Commands.Control_Toggle:
                    if (module.CustomData == 0D)
                    {
                        cm19Lib.UnitOn(houseCode, unitCode);
                        UpdateModuleLevel(module);
                    }
                    else
                    {
                        cm19Lib.UnitOff(houseCode, unitCode);
                        UpdateModuleLevel(module);
                    }
                    break;

                case Commands.Control_AllLightsOn:
                    cm19Lib.AllLightsOn(houseCode);
                    // TODO: update modules status
                    break;

                case Commands.Control_AllUnitsOff:
                    cm19Lib.AllUnitsOff(houseCode);
                    // TODO: update modules status
                    break;

                case Commands.Control_RfSend:
                    byte[] data = CM19Lib.Utility.StringToByteArray(option.Replace(" ", ""));
                    cm19Lib.SendMessage(data);
                    break;
                }
            }
            else
            {
                // Parse house/unit
                var houseCode = XTenLib.Utility.HouseCodeFromString(nodeId);
                var unitCode  = XTenLib.Utility.UnitCodeFromString(nodeId);
                switch (command)
                {
                case Commands.Parameter_Status:
                    x10Lib.StatusRequest(houseCode, unitCode);
                    break;

                case Commands.Control_On:
                    x10Lib.UnitOn(houseCode, unitCode);
                    break;

                case Commands.Control_Off:
                    x10Lib.UnitOff(houseCode, unitCode);
                    break;

                case Commands.Control_Bright:
                    x10Lib.Bright(houseCode, unitCode, int.Parse(option));
                    break;

                case Commands.Control_Dim:
                    x10Lib.Dim(houseCode, unitCode, int.Parse(option));
                    break;

                case Commands.Control_Level_Adjust:
                    //int adjvalue = int.Parse(option);
                    //x10Lib.Modules[nodeId].Level = ((double)adjvalue/100D);
                    OnInterfacePropertyChanged(this.GetDomain(), nodeId, "X10 Module", ModuleEvents.Status_Level, x10Lib.Modules[nodeId].Level);
                    throw(new NotImplementedException("X10 CONTROL_LEVEL_ADJUST Not Implemented"));
                    break;

                case Commands.Control_Level:
                    int dimvalue = int.Parse(option) - (int)(x10Lib.Modules[nodeId].Level * 100.0);
                    if (dimvalue > 0)
                    {
                        x10Lib.Bright(houseCode, unitCode, dimvalue);
                    }
                    else if (dimvalue < 0)
                    {
                        x10Lib.Dim(houseCode, unitCode, -dimvalue);
                    }
                    break;

                case Commands.Control_Toggle:
                    string huc = XTenLib.Utility.HouseUnitCodeFromEnum(houseCode, unitCode);
                    if (x10Lib.Modules[huc].Level == 0)
                    {
                        x10Lib.UnitOn(houseCode, unitCode);
                    }
                    else
                    {
                        x10Lib.UnitOff(houseCode, unitCode);
                    }
                    break;

                case Commands.Control_AllLightsOn:
                    x10Lib.AllLightsOn(houseCode);
                    break;

                case Commands.Control_AllUnitsOff:
                    x10Lib.AllUnitsOff(houseCode);
                    break;

                case Commands.Control_RfSend:
                    byte[] data = CM19Lib.Utility.StringToByteArray("EB" + option.Replace(" ", ""));
                    // SendRepeatCount is not implemented in XTenLib, so a for loop in required here
                    for (int i = 0; i < Cm19Manager.SendRepeatCount; i++)
                    {
                        x10Lib.SendMessage(data);
                        Thread.Sleep(Cm19Manager.SendPauseMs);
                    }
                    break;
                }
            }

            return(response);
        }
Beispiel #22
0
        public object InterfaceControl(MigInterfaceCommand request)
        {
            ResponseText response = new ResponseText("OK");

            string nodeId = request.Address;
            string option = request.GetOption(0);

            Commands command;

            Enum.TryParse <Commands>(request.Command.Replace(".", "_"), out command);

            // Parse house/unit
            var houseCode = XTenLib.Utility.HouseCodeFromString(nodeId);
            var unitCode  = XTenLib.Utility.UnitCodeFromString(nodeId);

            switch (command)
            {
            case Commands.Parameter_Status:
                x10lib.StatusRequest(houseCode, unitCode);
                break;

            case Commands.Control_On:
                x10lib.UnitOn(houseCode, unitCode);
                break;

            case Commands.Control_Off:
                x10lib.UnitOff(houseCode, unitCode);
                break;

            case Commands.Control_Bright:
                x10lib.Bright(houseCode, unitCode, int.Parse(option));
                break;

            case Commands.Control_Dim:
                x10lib.Dim(houseCode, unitCode, int.Parse(option));
                break;

            case Commands.Control_Level_Adjust:
                int adjvalue = int.Parse(option);
                //x10lib.Modules[nodeId].Level = ((double)adjvalue/100D);
                OnInterfacePropertyChanged(this.GetDomain(), nodeId, "X10 Module", ModuleEvents.Status_Level, x10lib.Modules[nodeId].Level);
                throw(new NotImplementedException("X10 CONTROL_LEVEL_ADJUST Not Implemented"));
                break;

            case Commands.Control_Level:
                int dimvalue = int.Parse(option) - (int)(x10lib.Modules[nodeId].Level * 100.0);
                if (dimvalue > 0)
                {
                    x10lib.Bright(houseCode, unitCode, dimvalue);
                }
                else if (dimvalue < 0)
                {
                    x10lib.Dim(houseCode, unitCode, -dimvalue);
                }
                break;

            case Commands.Control_Toggle:
                string huc = XTenLib.Utility.HouseUnitCodeFromEnum(houseCode, unitCode);
                if (x10lib.Modules[huc].Level == 0)
                {
                    x10lib.UnitOn(houseCode, unitCode);
                }
                else
                {
                    x10lib.UnitOff(houseCode, unitCode);
                }
                break;

            case Commands.Control_AllLightsOn:
                x10lib.AllLightsOn(houseCode);
                break;

            case Commands.Control_AllLightsOff:
                x10lib.AllUnitsOff(houseCode);
                break;
            }

            return(response);
        }
Beispiel #23
0
        public object InterfaceControl(MigInterfaceCommand request)
        {
            string returnValue = "";
            bool raiseEvent = false;
            string eventParameter = "Status.Unhandled";
            string eventValue = "";
            //
            var device = GetUpnpDevice(request.Address);

            Commands command;
            Enum.TryParse<Commands>(request.Command.Replace(".", "_"), out command);

            // TODO: ??? Commands: SwitchPower, Dimming

            switch (command)
            {
            case Commands.Control_On:
            case Commands.Control_Off:
                {
                    bool commandValue = (command == Commands.Control_On ? true : false);
                    var newValue = new UPnPArgument("newTargetValue", commandValue);
                    var args = new UPnPArgument[] {
                        newValue
                    };
                    InvokeUpnpDeviceService(device, "SwitchPower", "SetTarget", args);
                    //
                    raiseEvent = true;
                    eventParameter = "Status.Level";
                    eventValue = (commandValue ? "1" : "0");
                }
                break;
            case Commands.Control_Level:
                {
                    var newvalue = new UPnPArgument("NewLoadLevelTarget", (byte)uint.Parse(request.GetOption(0)));
                    var args = new UPnPArgument[] {
                        newvalue
                    };
                    InvokeUpnpDeviceService(device, "Dimming", "SetLoadLevelTarget", args);
                    //
                    raiseEvent = true;
                    eventParameter = "Status.Level";
                    eventValue = (double.Parse(request.GetOption(0)) / 100d).ToString(System.Globalization.CultureInfo.InvariantCulture);
                }
                break;
            case Commands.Control_Toggle:
                // TODO: not implemented yet
                break;
            case Commands.AvMedia_GetUri:
                {
                    string deviceId = request.Address;
                    string id = request.GetOption(0);
                    //
                    var objectId = new UPnPArgument("ObjectID", id);
                    var flags = new UPnPArgument("BrowseFlag", "BrowseMetadata");
                    var filter = new UPnPArgument("Filter", "upnp:album,upnp:artist,upnp:genre,upnp:title,res@size,res@duration,res@bitrate,res@sampleFrequency,res@bitsPerSample,res@nrAudioChannels,res@protocolInfo,res@protection,res@importUri");
                    var startIndex = new UPnPArgument("StartingIndex", (uint)0);
                    var requestedCount = new UPnPArgument("RequestedCount", (uint)1);
                    var sortCriteria = new UPnPArgument("SortCriteria", "");
                    //
                    var result = new UPnPArgument("Result", "");
                    var returnedNumber = new UPnPArgument("NumberReturned", "");
                    var totalMatches = new UPnPArgument("TotalMatches", "");
                    var updateId = new UPnPArgument("UpdateID", "");
                    //
                    InvokeUpnpDeviceService(device, "ContentDirectory", "Browse", new UPnPArgument[] {
                        objectId,
                        flags,
                        filter,
                        startIndex,
                        requestedCount,
                        sortCriteria,
                        result,
                        returnedNumber,
                        totalMatches,
                        updateId
                    });
                    //
                    try
                    {
                        string ss = result.DataValue.ToString();
                        var item = XDocument.Parse(ss, LoadOptions.SetBaseUri).Descendants().Where(ii => ii.Name.LocalName == "item").First();
                        //
                        foreach (var i in item.Elements())
                        {
                            var protocolUri = i.Attribute("protocolInfo");
                            if (protocolUri != null)
                            {
                                returnValue = i.Value;
                                break;
                            }
                        }
                    }
                    catch
                    {
                    }
                }
                break;
            case Commands.AvMedia_Browse:
                {
                    string deviceId = request.Address;
                    string id = request.GetOption(0);
                    //
                    var objectId = new UPnPArgument("ObjectID", id);
                    var flags = new UPnPArgument("BrowseFlag", "BrowseDirectChildren");
                    var filter = new UPnPArgument("Filter", "upnp:album,upnp:artist,upnp:genre,upnp:title,res@size,res@duration,res@bitrate,res@sampleFrequency,res@bitsPerSample,res@nrAudioChannels,res@protocolInfo,res@protection,res@importUri");
                    var startIndex = new UPnPArgument("StartingIndex", (uint)0);
                    var requestedCount = new UPnPArgument("RequestedCount", (uint)0);
                    var sortCriteria = new UPnPArgument("SortCriteria", "");
                    //
                    var result = new UPnPArgument("Result", "");
                    var returnedNumber = new UPnPArgument("NumberReturned", "");
                    var totalMatches = new UPnPArgument("TotalMatches", "");
                    var updateId = new UPnPArgument("UpdateID", "");
                    //
                    InvokeUpnpDeviceService(device, "ContentDirectory", "Browse", new UPnPArgument[] {
                        objectId,
                        flags,
                        filter,
                        startIndex,
                        requestedCount,
                        sortCriteria,
                        result,
                        returnedNumber,
                        totalMatches,
                        updateId
                    });
                    //
                    try
                    {
                        string ss = result.DataValue.ToString();
                        var root = XDocument.Parse(ss, LoadOptions.SetBaseUri).Elements();
                        //
                        string jsonres = "[";
                        foreach (var i in root.Elements())
                        {
                            string itemId = i.Attribute("id").Value;
                            string itemTitle = i.Descendants().Where(n => n.Name.LocalName == "title").First().Value;
                            string itemClass = i.Descendants().Where(n => n.Name.LocalName == "class").First().Value;
                            jsonres += "{ \"Id\" : \"" + itemId + "\", \"Title\" : \"" + itemTitle.Replace("\"", "\\\"") + "\", \"Class\" : \"" + itemClass + "\" },\n";
                        }
                        jsonres = jsonres.TrimEnd(',', '\n') + "]";
                        //
                        returnValue = jsonres;
                    }
                    catch
                    {
                    }
                }
                break;
            case Commands.AvMedia_GetTransportInfo:
                {
                    var instanceId = new UPnPArgument("InstanceID", (uint)0);
                    var transportState = new UPnPArgument("CurrentTransportState", "");
                    var transportStatus = new UPnPArgument("CurrentTransportStatus", "");
                    var currentSpeed = new UPnPArgument("CurrentSpeed", "");
                    var args = new UPnPArgument[] {
                        instanceId,
                        transportState,
                        transportStatus,
                        currentSpeed
                    };
                    InvokeUpnpDeviceService(device, "AVTransport", "GetTransportInfo", args);
                    //
                    string jsonres = "[{ ";
                    jsonres += "\"CurrentTransportState\" : \"" + transportState.DataValue + "\", ";
                    jsonres += "\"CurrentTransportStatus\" : \"" + transportStatus.DataValue + "\", ";
                    jsonres += "\"CurrentSpeed\" : \"" + currentSpeed.DataValue + "\"";
                    jsonres += " }]";
                    //
                    returnValue = jsonres;
                }
                break;
            case Commands.AvMedia_GetMediaInfo:
                {
                    var instanceId = new UPnPArgument("InstanceID", (uint)0);
                    var nrTracks = new UPnPArgument("NrTracks", (uint)0);
                    var mediaDuration = new UPnPArgument("MediaDuration", "");
                    var currentUri = new UPnPArgument("CurrentURI", "");
                    var currentUriMetadata = new UPnPArgument("CurrentURIMetaData", "");
                    var nextUri = new UPnPArgument("NextURI", "");
                    var nextUriMetadata = new UPnPArgument("NextURIMetaData", "");
                    var playMedium = new UPnPArgument("PlayMedium", "");
                    var recordMedium = new UPnPArgument("RecordMedium", "");
                    var writeStatus = new UPnPArgument("WriteStatus", "");
                    var args = new UPnPArgument[] {
                        instanceId,
                        nrTracks,
                        mediaDuration,
                        currentUri,
                        currentUriMetadata,
                        nextUri,
                        nextUriMetadata,
                        playMedium,
                        recordMedium,
                        writeStatus
                    };
                    InvokeUpnpDeviceService(device, "AVTransport", "GetMediaInfo", args);
                    //
                    string jsonres = "[{ ";
                    jsonres += "\"NrTracks\" : \"" + nrTracks.DataValue + "\", ";
                    jsonres += "\"MediaDuration\" : \"" + mediaDuration.DataValue + "\", ";
                    jsonres += "\"CurrentURI\" : \"" + currentUri.DataValue + "\", ";
                    jsonres += "\"CurrentURIMetaData\" : \"" + currentUriMetadata.DataValue.ToString().Replace("\"", "\\\"") + "\", ";
                    jsonres += "\"NextURI\" : \"" + nextUri.DataValue + "\", ";
                    jsonres += "\"NextURIMetaData\" : \"" + nextUriMetadata.DataValue.ToString().Replace("\"", "\\\"") + "\", ";
                    jsonres += "\"PlayMedium\" : \"" + playMedium.DataValue + "\", ";
                    jsonres += "\"RecordMedium\" : \"" + recordMedium.DataValue + "\", ";
                    jsonres += "\"WriteStatus\" : \"" + writeStatus.DataValue + "\"";
                    jsonres += " }]";
                    //
                    returnValue = jsonres;
                }
                break;
            case Commands.AvMedia_GetPositionInfo:
                {
                    var instanceId = new UPnPArgument("InstanceID", (uint)0);
                    var currentTrack = new UPnPArgument("Track", (uint)0);
                    var trackDuration = new UPnPArgument("TrackDuration", "");
                    var trackMetadata = new UPnPArgument("TrackMetaData", "");
                    var trackUri = new UPnPArgument("TrackURI", "");
                    var relativeTime = new UPnPArgument("RelTime", "");
                    var absoluteTime = new UPnPArgument("AbsTime", "");
                    var relativeCount = new UPnPArgument("RelCount", (uint)0);
                    var absoluteCount = new UPnPArgument("AbsCount", (uint)0);
                    var args = new UPnPArgument[] {
                        instanceId,
                        currentTrack,
                        trackDuration,
                        trackMetadata,
                        trackUri,
                        relativeTime,
                        absoluteTime,
                        relativeCount,
                        absoluteCount
                    };
                    InvokeUpnpDeviceService(device, "AVTransport", "GetPositionInfo", args);
                    //
                    string jsonres = "[{";
                    jsonres += "\"Track\" : \"" + currentTrack.DataValue + "\",";
                    jsonres += "\"TrackDuration\" : \"" + trackDuration.DataValue + "\",";
                    jsonres += "\"TrackMetaData\" : \"" + trackMetadata.DataValue.ToString().Replace("\"", "\\\"") + "\",";
                    jsonres += "\"TrackURI\" : \"" + trackUri.DataValue + "\",";
                    jsonres += "\"RelTime\" : \"" + relativeTime.DataValue + "\",";
                    jsonres += "\"AbsTime\" : \"" + absoluteTime.DataValue + "\",";
                    jsonres += "\"RelCount\" : \"" + relativeCount.DataValue + "\",";
                    jsonres += "\"AbsCount\" : \"" + absoluteCount.DataValue + "\"";
                    jsonres += "}]";
                    //
                    returnValue = jsonres;
                }
                break;
            case Commands.AvMedia_SetUri:
                {
                    var instanceId = new UPnPArgument("InstanceID", (uint)0);
                    var currentUri = new UPnPArgument("CurrentURI", request.GetOption(0));
                    var uriMetadata = new UPnPArgument("CurrentURIMetaData", "");
                    var args = new UPnPArgument[] {
                        instanceId,
                        currentUri,
                        uriMetadata
                    };
                    InvokeUpnpDeviceService(device, "AVTransport", "SetAVTransportURI", args);
                }
                break;
            case Commands.AvMedia_Play:
                {
                    var instanceId = new UPnPArgument("InstanceID", (uint)0);
                    var speed = new UPnPArgument("Speed", "1");
                    var args = new UPnPArgument[] {
                        instanceId,
                        speed
                    };
                    InvokeUpnpDeviceService(device, "AVTransport", "Play", args);
                }
                break;
            case Commands.AvMedia_Pause:
                {
                    var instanceId = new UPnPArgument("InstanceID", (uint)0);
                    var args = new UPnPArgument[] {
                        instanceId
                    };
                    InvokeUpnpDeviceService(device, "AVTransport", "Pause", args);
                }
                break;
            case Commands.AvMedia_Stop:
                {
                    var instanceId = new UPnPArgument("InstanceID", (uint)0);
                    var args = new UPnPArgument[] {
                        instanceId
                    };
                    InvokeUpnpDeviceService(device, "AVTransport", "Stop", args);
                }
                break;
            case Commands.AvMedia_Prev:
                {
                    var instanceId = new UPnPArgument("InstanceID", (uint)0);
                    var args = new UPnPArgument[] {
                        instanceId
                    };
                    InvokeUpnpDeviceService(device, "AVTransport", "Previous", args);
                }
                break;
            case Commands.AvMedia_Next:
                {
                    var instanceId = new UPnPArgument("InstanceID", (uint)0);
                    var args = new UPnPArgument[] {
                        instanceId
                    };
                    InvokeUpnpDeviceService(device, "AVTransport", "Next", args);
                }
                break;
            case Commands.AvMedia_GetMute:
                {
                    var instanceId = new UPnPArgument("InstanceID", (uint)0);
                    var channel = new UPnPArgument("Channel", "Master");
                    var currentMute = new UPnPArgument("CurrentMute", "");
                    var args = new UPnPArgument[] {
                        instanceId,
                        channel,
                        currentMute
                    };
                    InvokeUpnpDeviceService(device, "RenderingControl", "GetMute", args);
                    returnValue = currentMute.DataValue.ToString();
                }
                break;
            case Commands.AvMedia_SetMute:
                {
                    var instanceId = new UPnPArgument("InstanceID", (uint)0);
                    var channel = new UPnPArgument("Channel", "Master");
                    var mute = new UPnPArgument("DesiredMute", request.GetOption(0) == "1" ? true : false);
                    var args = new UPnPArgument[] {
                        instanceId,
                        channel,
                        mute
                    };
                    InvokeUpnpDeviceService(device, "RenderingControl", "SetMute", args);
                }
                break;
            case Commands.AvMedia_GetVolume:
                {
                    var instanceId = new UPnPArgument("InstanceID", (uint)0);
                    var channel = new UPnPArgument("Channel", "Master");
                    var currentVolume = new UPnPArgument("CurrentVolume", "");
                    var args = new UPnPArgument[] {
                        instanceId,
                        channel,
                        currentVolume
                    };
                    InvokeUpnpDeviceService(device, "RenderingControl", "GetVolume", args);
                    returnValue = currentVolume.DataValue.ToString();
                }
                break;
            case Commands.AvMedia_SetVolume:
                {
                    var instanceId = new UPnPArgument("InstanceID", (uint)0);
                    var channel = new UPnPArgument("Channel", "Master");
                    var volume = new UPnPArgument("DesiredVolume", UInt16.Parse(request.GetOption(0)));
                    var args = new UPnPArgument[] {
                        instanceId,
                        channel,
                        volume
                    };
                    InvokeUpnpDeviceService(device, "RenderingControl", "SetVolume", args);
                }
                break;
            }

            // raise event
            if (raiseEvent)
            {
                OnInterfacePropertyChanged(this.GetDomain(), device.UniqueDeviceName, "UPnP " + (device != null ? device.StandardDeviceType : "device"), eventParameter, eventValue);
            }

            return returnValue;
        }
        public object InterfaceControl(MigInterfaceCommand request)
        {
            string response = ""; //default success value

            Commands command;
            Enum.TryParse<Commands>(request.Command.Replace(".", "_"), out command);

            switch (command)
            {
            case Commands.Camera_GetPicture:
                // get picture from camera <nodeid>
                // TODO: there is actually only single camera support
                if (cameraSource != IntPtr.Zero)
                {
                    lock (readPictureLock)
                    {
                        var pictureBuffer = CameraCaptureV4LInterop.GetFrame(cameraSource);
                        var data = new byte[pictureBuffer.Size];
                        Marshal.Copy(pictureBuffer.Data, data, 0, pictureBuffer.Size);
                        return data;
                    }
                }
                break;
            case Commands.Camera_GetLuminance:
                // TODO: ....
                break;
            case Commands.Camera_SetDevice:
                this.GetOption("Configuration").Value = request.GetOption(0) + "," + request.GetOption(1) + "," + request.GetOption(2) + "," + request.GetOption(3);
                Connect();
                break;
            }

            return response;
        }
Beispiel #25
0
        public object InterfaceControl(MigInterfaceCommand request)
        {
            bool raisePropertyChanged = false;
            string parameterPath = ModuleEvents.Status_Level;
            string raiseParameter = "";
            //
            string nodeId = request.Address;

            Commands command;
            Enum.TryParse<Commands>(request.Command.Replace(".", "_"), out command);
            string option = request.GetOption(0);

            bool isDottedHexId = (nodeId.IndexOf(".") > 0);

            if (isDottedHexId)
            {
                // Standard Insteon device

                DeviceBase device = null;
                insteonPlm.Network.TryConnectToDevice(nodeId, out device);

                //TODO: handle types IrrigationControl and PoolAndSpaControl

                switch (command)
                {
                case Commands.Parameter_Status:
                    break;
                case Commands.Control_On:
                    raisePropertyChanged = true;
                    raiseParameter = "1";
                    //
                    if (device != null)
                        switch (device.GetType().Name)
                    {
                    case "LightingControl":
                        (device as LightingControl).TurnOn();
                        break;
                    case "DimmableLightingControl":
                        (device as DimmableLightingControl).TurnOn();
                        break;
                    case "SwitchedLightingControl":
                        (device as SwitchedLightingControl).TurnOn();
                        break;
                    case "SensorsActuators":
                        (device as SensorsActuators).TurnOnOutput(byte.Parse(option));
                        break;
                    case "WindowCoveringControl":
                        (device as WindowCoveringControl).Open();
                        break;
                    case "PoolAndSpaControl":
                        break;
                    case "IrrigationControl":
                        (device as IrrigationControl).TurnOnSprinklerValve(byte.Parse(option));
                        break;
                    }
                    break;
                case Commands.Control_Off:
                    raisePropertyChanged = true;
                    raiseParameter = "0";
                    //
                    if (device != null)
                        switch (device.GetType().Name)
                    {
                    case "LightingControl":
                        (device as LightingControl).TurnOff();
                        break;
                    case "DimmableLightingControl":
                        (device as DimmableLightingControl).TurnOff();
                        break;
                    case "SwitchedLightingControl":
                        (device as SwitchedLightingControl).TurnOff();
                        break;
                    case "SensorsActuators":
                        (device as SensorsActuators).TurnOffOutput(byte.Parse(option));
                        break;
                    case "WindowCoveringControl":
                        (device as WindowCoveringControl).Close();
                        break;
                    case "PoolAndSpaControl":
                        break;
                    case "IrrigationControl":
                        (device as IrrigationControl).TurnOffSprinklerValve(byte.Parse(option));
                        break;
                    }
                    break;
                case Commands.Control_Bright:
                    // TODO: raise parameter change event
                    if (device != null && device is DimmableLightingControl)
                    {
                        (device as DimmableLightingControl).BrightenOneStep();
                    }
                    break;
                case Commands.Control_Dim:
                    // TODO: raise parameter change event
                    if (device != null && device is DimmableLightingControl)
                    {
                        (device as DimmableLightingControl).DimOneStep();
                    }
                    break;
                case Commands.Control_Level:
                    double adjustedLevel = (double.Parse(option) / 100D);
                    raisePropertyChanged = true;
                    raiseParameter = adjustedLevel.ToString(CultureInfo.InvariantCulture);
                    //
                    byte level = (byte)((double.Parse(option) / 100D) * 255);
                    if (device != null)
                        switch (device.GetType().Name)
                    {
                    case "DimmableLightingControl":
                        (device as DimmableLightingControl).TurnOn(level);
                        break;
                    case "WindowCoveringControl":
                        (device as WindowCoveringControl).MoveToPosition(level);
                        break;
                    }
                    break;
                case Commands.Control_Toggle:
                    break;
                case Commands.Control_AllLightsOn:
                    break;
                case Commands.Control_AllLightsOff:
                    break;
                }
            }
            else
            {
                // It is not a dotted hex addres, so fallback to X10 device control
                var x10plm = insteonPlm.Network.X10;

                // Parse house/unit
                string houseCode = nodeId.Substring(0, 1);
                byte unitCode = 0x00;
                if (nodeId.Length > 1) unitCode = byte.Parse(nodeId.Substring(1));

                switch (command)
                {
                case Commands.Parameter_Status:
                    x10plm
                        .House(houseCode.ToString())
                        .Unit(unitCode)
                        .Command(X10Command.StatusRequest);
                    break;
                case Commands.Control_On:
                    raisePropertyChanged = true;
                    raiseParameter = "1";
                    //
                    x10plm
                        .House(houseCode)
                        .Unit(unitCode)
                        .Command(X10Command.On);
                    break;
                case Commands.Control_Off:
                    raisePropertyChanged = true;
                    raiseParameter = "0";
                    //
                    x10plm
                        .House(houseCode)
                        .Unit(unitCode)
                        .Command(X10Command.Off);
                    break;
                case Commands.Control_Bright:
                    // TODO: raise parameter change event
                    //int amount = int.Parse(option);
                    // TODO: how to specify bright amount parameter???
                    x10plm
                        .House(houseCode)
                        .Unit(unitCode)
                        .Command(X10Command.Bright);
                    break;
                case Commands.Control_Dim:
                    // TODO: raise parameter change event
                    //int amount = int.Parse(option);
                    // TODO: how to specify dim amount parameter???
                    x10plm
                        .House(houseCode)
                        .Unit(unitCode)
                        .Command(X10Command.Dim);
                    break;
                case Commands.Control_Level:
                    double adjustedLevel = (double.Parse(option) / 100D);
                    raisePropertyChanged = true;
                    raiseParameter = adjustedLevel.ToString(CultureInfo.InvariantCulture);
                    //
                    /*int dimvalue = int.Parse(option) - (int)(x10lib.ModulesStatus[ nodeId ].Level * 100.0);
                    if (dimvalue > 0)
                    {
                        x10lib.Bright(houseCode, unitCode, dimvalue);
                    }
                    else if (dimvalue < 0)
                    {
                        x10lib.Dim(houseCode, unitCode, -dimvalue);
                    }*/
                    break;
                case Commands.Control_Toggle:
                    /*
                    string huc = XTenLib.Utility.HouseUnitCodeFromEnum(houseCode, unitCode);
                    if (x10lib.ModulesStatus[ huc ].Level == 0)
                    {
                        x10lib.LightOn(houseCode, unitCode);
                    }
                    else
                    {
                        x10lib.LightOff(houseCode, unitCode);
                    }
                    */
                    break;
                case Commands.Control_AllLightsOn:
                    // TODO: ...
                    x10plm
                        .House(houseCode)
                        .Command(X10Command.AllLightsOn);
                    break;
                case Commands.Control_AllLightsOff:
                    // TODO: ...
                    x10plm
                        .House(houseCode)
                        .Command(X10Command.AllLightsOff);
                    break;
                }
            }

            if (raisePropertyChanged)
            {
                OnInterfacePropertyChanged(this.GetDomain(), nodeId, "Insteon Device", parameterPath, raiseParameter);
            }

            return new ResponseText("OK");
        }
Beispiel #26
0
        public object InterfaceControl(MigInterfaceCommand request)
        {
            object returnValue    = null;
            bool   raiseEvent     = false;
            string eventParameter = "Status.Unhandled";
            string eventValue     = "";
            //
            var device = GetUpnpDevice(request.Address);

            Commands command;

            Enum.TryParse <Commands>(request.Command.Replace(".", "_"), out command);

            // TODO: ??? Commands: SwitchPower, Dimming

            switch (command)
            {
            case Commands.Control_On:
            case Commands.Control_Off:
            {
                bool commandValue = (command == Commands.Control_On ? true : false);
                var  newValue     = new UPnPArgument("newTargetValue", commandValue);
                var  args         = new UPnPArgument[] {
                    newValue
                };
                InvokeUpnpDeviceService(device, "SwitchPower", "SetTarget", args);
                //
                raiseEvent     = true;
                eventParameter = "Status.Level";
                eventValue     = (commandValue ? "1" : "0");
            }
            break;

            case Commands.Control_Level:
            {
                var newvalue = new UPnPArgument("NewLoadLevelTarget", (byte)uint.Parse(request.GetOption(0)));
                var args     = new UPnPArgument[] {
                    newvalue
                };
                InvokeUpnpDeviceService(device, "Dimming", "SetLoadLevelTarget", args);
                //
                raiseEvent     = true;
                eventParameter = "Status.Level";
                eventValue     = (double.Parse(request.GetOption(0)) / 100d).ToString(System.Globalization.CultureInfo.InvariantCulture);
            }
            break;

            case Commands.Control_Toggle:
                // TODO: not implemented yet
                break;

            case Commands.AvMedia_GetItem:
            {
                string deviceId = request.Address;
                string id       = request.GetOption(0);
                //
                var objectId       = new UPnPArgument("ObjectID", id);
                var flags          = new UPnPArgument("BrowseFlag", "BrowseMetadata");
                var filter         = new UPnPArgument("Filter", "upnp:album,upnp:artist,upnp:genre,upnp:title,res@size,res@duration,res@bitrate,res@sampleFrequency,res@bitsPerSample,res@nrAudioChannels,res@protocolInfo,res@protection,res@importUri");
                var startIndex     = new UPnPArgument("StartingIndex", (uint)0);
                var requestedCount = new UPnPArgument("RequestedCount", (uint)1);
                var sortCriteria   = new UPnPArgument("SortCriteria", "");
                //
                var result         = new UPnPArgument("Result", "");
                var returnedNumber = new UPnPArgument("NumberReturned", "");
                var totalMatches   = new UPnPArgument("TotalMatches", "");
                var updateId       = new UPnPArgument("UpdateID", "");
                //
                InvokeUpnpDeviceService(device, "ContentDirectory", "Browse", new UPnPArgument[] {
                        objectId,
                        flags,
                        filter,
                        startIndex,
                        requestedCount,
                        sortCriteria,
                        result,
                        returnedNumber,
                        totalMatches,
                        updateId
                    });
                //
                try
                {
                    string ss   = result.DataValue.ToString();
                    var    item = XDocument.Parse(ss, LoadOptions.SetBaseUri).Descendants().Where(ii => ii.Name.LocalName == "item").First();
                    returnValue = MIG.Utility.Serialization.JsonSerialize(item, true);
                }
                catch
                {
                    // TODO: MigService.Log.Error(e);
                }
            }
            break;

            case Commands.AvMedia_GetUri:
            {
                string deviceId = request.Address;
                string id       = request.GetOption(0);
                //
                var objectId       = new UPnPArgument("ObjectID", id);
                var flags          = new UPnPArgument("BrowseFlag", "BrowseMetadata");
                var filter         = new UPnPArgument("Filter", "upnp:album,upnp:artist,upnp:genre,upnp:title,res@size,res@duration,res@bitrate,res@sampleFrequency,res@bitsPerSample,res@nrAudioChannels,res@protocolInfo,res@protection,res@importUri");
                var startIndex     = new UPnPArgument("StartingIndex", (uint)0);
                var requestedCount = new UPnPArgument("RequestedCount", (uint)1);
                var sortCriteria   = new UPnPArgument("SortCriteria", "");
                //
                var result         = new UPnPArgument("Result", "");
                var returnedNumber = new UPnPArgument("NumberReturned", "");
                var totalMatches   = new UPnPArgument("TotalMatches", "");
                var updateId       = new UPnPArgument("UpdateID", "");
                //
                InvokeUpnpDeviceService(device, "ContentDirectory", "Browse", new UPnPArgument[] {
                        objectId,
                        flags,
                        filter,
                        startIndex,
                        requestedCount,
                        sortCriteria,
                        result,
                        returnedNumber,
                        totalMatches,
                        updateId
                    });
                //
                try
                {
                    string ss   = result.DataValue.ToString();
                    var    item = XDocument.Parse(ss, LoadOptions.SetBaseUri).Descendants().Where(ii => ii.Name.LocalName == "item").First();
                    //
                    foreach (var i in item.Elements())
                    {
                        var protocolUri = i.Attribute("protocolInfo");
                        if (protocolUri != null)
                        {
                            returnValue = new ResponseText(i.Value);
                            break;
                        }
                    }
                }
                catch
                {
                    // TODO: MigService.Log.Error(e);
                }
            }
            break;

            case Commands.AvMedia_Browse:
            {
                string deviceId = request.Address;
                string id       = request.GetOption(0);
                //
                var objectId       = new UPnPArgument("ObjectID", id);
                var flags          = new UPnPArgument("BrowseFlag", "BrowseDirectChildren");
                var filter         = new UPnPArgument("Filter", "upnp:album,upnp:artist,upnp:genre,upnp:title,res@size,res@duration,res@bitrate,res@sampleFrequency,res@bitsPerSample,res@nrAudioChannels,res@protocolInfo,res@protection,res@importUri");
                var startIndex     = new UPnPArgument("StartingIndex", (uint)0);
                var requestedCount = new UPnPArgument("RequestedCount", (uint)0);
                var sortCriteria   = new UPnPArgument("SortCriteria", "");
                //
                var result         = new UPnPArgument("Result", "");
                var returnedNumber = new UPnPArgument("NumberReturned", "");
                var totalMatches   = new UPnPArgument("TotalMatches", "");
                var updateId       = new UPnPArgument("UpdateID", "");
                //
                InvokeUpnpDeviceService(device, "ContentDirectory", "Browse", new UPnPArgument[] {
                        objectId,
                        flags,
                        filter,
                        startIndex,
                        requestedCount,
                        sortCriteria,
                        result,
                        returnedNumber,
                        totalMatches,
                        updateId
                    });
                //
                try
                {
                    string ss   = result.DataValue.ToString();
                    var    root = XDocument.Parse(ss, LoadOptions.SetBaseUri).Elements();
                    //
                    string jsonres = "[";
                    foreach (var i in root.Elements())
                    {
                        string itemId    = i.Attribute("id").Value;
                        string itemTitle = i.Descendants().Where(n => n.Name.LocalName == "title").First().Value;
                        string itemClass = i.Descendants().Where(n => n.Name.LocalName == "class").First().Value;
                        jsonres += "{ \"Id\" : \"" + itemId + "\", \"Title\" : \"" + itemTitle.Replace("\"", "\\\"") + "\", \"Class\" : \"" + itemClass + "\" },\n";
                    }
                    jsonres = jsonres.TrimEnd(',', '\n') + "]";
                    //
                    returnValue = jsonres;
                }
                catch
                {
                    // TODO: MigService.Log.Error(e);
                }
            }
            break;

            case Commands.AvMedia_GetTransportInfo:
            {
                var instanceId      = new UPnPArgument("InstanceID", (uint)0);
                var transportState  = new UPnPArgument("CurrentTransportState", "");
                var transportStatus = new UPnPArgument("CurrentTransportStatus", "");
                var currentSpeed    = new UPnPArgument("CurrentSpeed", "");
                var args            = new UPnPArgument[] {
                    instanceId,
                    transportState,
                    transportStatus,
                    currentSpeed
                };
                InvokeUpnpDeviceService(device, "AVTransport", "GetTransportInfo", args);
                //
                string jsonres = "{ ";
                jsonres += "\"CurrentTransportState\" : \"" + transportState.DataValue + "\", ";
                jsonres += "\"CurrentTransportStatus\" : \"" + transportStatus.DataValue + "\", ";
                jsonres += "\"CurrentSpeed\" : \"" + currentSpeed.DataValue + "\"";
                jsonres += " }";
                //
                returnValue = jsonres;
            }
            break;

            case Commands.AvMedia_GetMediaInfo:
            {
                var instanceId         = new UPnPArgument("InstanceID", (uint)0);
                var nrTracks           = new UPnPArgument("NrTracks", (uint)0);
                var mediaDuration      = new UPnPArgument("MediaDuration", "");
                var currentUri         = new UPnPArgument("CurrentURI", "");
                var currentUriMetadata = new UPnPArgument("CurrentURIMetaData", "");
                var nextUri            = new UPnPArgument("NextURI", "");
                var nextUriMetadata    = new UPnPArgument("NextURIMetaData", "");
                var playMedium         = new UPnPArgument("PlayMedium", "");
                var recordMedium       = new UPnPArgument("RecordMedium", "");
                var writeStatus        = new UPnPArgument("WriteStatus", "");
                var args = new UPnPArgument[] {
                    instanceId,
                    nrTracks,
                    mediaDuration,
                    currentUri,
                    currentUriMetadata,
                    nextUri,
                    nextUriMetadata,
                    playMedium,
                    recordMedium,
                    writeStatus
                };
                InvokeUpnpDeviceService(device, "AVTransport", "GetMediaInfo", args);
                //
                string jsonres = "{ ";
                jsonres += "\"NrTracks\" : \"" + nrTracks.DataValue + "\", ";
                jsonres += "\"MediaDuration\" : \"" + mediaDuration.DataValue + "\", ";
                jsonres += "\"CurrentURI\" : \"" + currentUri.DataValue + "\", ";
                jsonres += "\"CurrentURIMetaData\" : " + MIG.Utility.Serialization.JsonSerialize(GetJsonFromXmlItem(currentUriMetadata.DataValue.ToString())) + ", ";
                jsonres += "\"NextURI\" : \"" + nextUri.DataValue + "\", ";
                jsonres += "\"NextURIMetaData\" : " + MIG.Utility.Serialization.JsonSerialize(GetJsonFromXmlItem(nextUriMetadata.DataValue.ToString())) + ", ";
                jsonres += "\"PlayMedium\" : \"" + playMedium.DataValue + "\", ";
                jsonres += "\"RecordMedium\" : \"" + recordMedium.DataValue + "\", ";
                jsonres += "\"WriteStatus\" : \"" + writeStatus.DataValue + "\"";
                jsonres += " }";
                //
                returnValue = jsonres;
            }
            break;

            case Commands.AvMedia_GetPositionInfo:
            {
                var instanceId    = new UPnPArgument("InstanceID", (uint)0);
                var currentTrack  = new UPnPArgument("Track", (uint)0);
                var trackDuration = new UPnPArgument("TrackDuration", "");
                var trackMetadata = new UPnPArgument("TrackMetaData", "");
                var trackUri      = new UPnPArgument("TrackURI", "");
                var relativeTime  = new UPnPArgument("RelTime", "");
                var absoluteTime  = new UPnPArgument("AbsTime", "");
                var relativeCount = new UPnPArgument("RelCount", (uint)0);
                var absoluteCount = new UPnPArgument("AbsCount", (uint)0);
                var args          = new UPnPArgument[] {
                    instanceId,
                    currentTrack,
                    trackDuration,
                    trackMetadata,
                    trackUri,
                    relativeTime,
                    absoluteTime,
                    relativeCount,
                    absoluteCount
                };
                InvokeUpnpDeviceService(device, "AVTransport", "GetPositionInfo", args);
                //
                string jsonres = "{";
                jsonres += "\"Track\" : \"" + currentTrack.DataValue + "\",";
                jsonres += "\"TrackDuration\" : \"" + trackDuration.DataValue + "\",";
                jsonres += "\"TrackMetaData\" : " + MIG.Utility.Serialization.JsonSerialize(GetJsonFromXmlItem(trackMetadata.DataValue.ToString())) + ",";
                jsonres += "\"TrackURI\" : \"" + trackUri.DataValue + "\",";
                jsonres += "\"RelTime\" : \"" + relativeTime.DataValue + "\",";
                jsonres += "\"AbsTime\" : \"" + absoluteTime.DataValue + "\",";
                jsonres += "\"RelCount\" : \"" + relativeCount.DataValue + "\",";
                jsonres += "\"AbsCount\" : \"" + absoluteCount.DataValue + "\"";
                jsonres += "}";
                //
                returnValue = jsonres;
            }
            break;

            case Commands.AvMedia_SetUri:
            {
                var instanceId  = new UPnPArgument("InstanceID", (uint)0);
                var currentUri  = new UPnPArgument("CurrentURI", request.GetOption(0));
                var uriMetadata = new UPnPArgument("CurrentURIMetaData", "");
                var args        = new UPnPArgument[] {
                    instanceId,
                    currentUri,
                    uriMetadata
                };
                InvokeUpnpDeviceService(device, "AVTransport", "SetAVTransportURI", args);
            }
            break;

            case Commands.AvMedia_Play:
            {
                var instanceId = new UPnPArgument("InstanceID", (uint)0);
                var speed      = new UPnPArgument("Speed", "1");
                var args       = new UPnPArgument[] {
                    instanceId,
                    speed
                };
                InvokeUpnpDeviceService(device, "AVTransport", "Play", args);
            }
            break;

            case Commands.AvMedia_Pause:
            {
                var instanceId = new UPnPArgument("InstanceID", (uint)0);
                var args       = new UPnPArgument[] {
                    instanceId
                };
                InvokeUpnpDeviceService(device, "AVTransport", "Pause", args);
            }
            break;

            case Commands.AvMedia_Seek:
            {
                var instanceId = new UPnPArgument("InstanceID", (uint)0);
                var unit       = new UPnPArgument("Unit", "REL_TIME");
                var target     = new UPnPArgument("Target", request.GetOption(0));
                var args       = new UPnPArgument[] {
                    instanceId,
                    unit,
                    target
                };
                InvokeUpnpDeviceService(device, "AVTransport", "Seek", args);
            }
            break;

            case Commands.AvMedia_Stop:
            {
                var instanceId = new UPnPArgument("InstanceID", (uint)0);
                var args       = new UPnPArgument[] {
                    instanceId
                };
                InvokeUpnpDeviceService(device, "AVTransport", "Stop", args);
            }
            break;

            case Commands.AvMedia_Prev:
            {
                var instanceId = new UPnPArgument("InstanceID", (uint)0);
                var args       = new UPnPArgument[] {
                    instanceId
                };
                InvokeUpnpDeviceService(device, "AVTransport", "Previous", args);
            }
            break;

            case Commands.AvMedia_Next:
            {
                var instanceId = new UPnPArgument("InstanceID", (uint)0);
                var args       = new UPnPArgument[] {
                    instanceId
                };
                InvokeUpnpDeviceService(device, "AVTransport", "Next", args);
            }
            break;

            case Commands.AvMedia_GetMute:
            {
                var instanceId  = new UPnPArgument("InstanceID", (uint)0);
                var channel     = new UPnPArgument("Channel", "Master");
                var currentMute = new UPnPArgument("CurrentMute", "");
                var args        = new UPnPArgument[] {
                    instanceId,
                    channel,
                    currentMute
                };
                InvokeUpnpDeviceService(device, "RenderingControl", "GetMute", args);
                returnValue = new ResponseText(currentMute.DataValue.ToString());
            }
            break;

            case Commands.AvMedia_SetMute:
            {
                var instanceId = new UPnPArgument("InstanceID", (uint)0);
                var channel    = new UPnPArgument("Channel", "Master");
                var mute       = new UPnPArgument("DesiredMute", request.GetOption(0) == "1" ? true : false);
                var args       = new UPnPArgument[] {
                    instanceId,
                    channel,
                    mute
                };
                InvokeUpnpDeviceService(device, "RenderingControl", "SetMute", args);
            }
            break;

            case Commands.AvMedia_GetVolume:
            {
                var instanceId    = new UPnPArgument("InstanceID", (uint)0);
                var channel       = new UPnPArgument("Channel", "Master");
                var currentVolume = new UPnPArgument("CurrentVolume", "");
                var args          = new UPnPArgument[] {
                    instanceId,
                    channel,
                    currentVolume
                };
                InvokeUpnpDeviceService(device, "RenderingControl", "GetVolume", args);
                returnValue = new ResponseText(currentVolume.DataValue.ToString());
            }
            break;

            case Commands.AvMedia_SetVolume:
            {
                var instanceId = new UPnPArgument("InstanceID", (uint)0);
                var channel    = new UPnPArgument("Channel", "Master");
                var volume     = new UPnPArgument("DesiredVolume", UInt16.Parse(request.GetOption(0)));
                var args       = new UPnPArgument[] {
                    instanceId,
                    channel,
                    volume
                };
                InvokeUpnpDeviceService(device, "RenderingControl", "SetVolume", args);
            }
            break;
            }

            // raise event
            if (raiseEvent)
            {
                OnInterfacePropertyChanged(this.GetDomain(), device.UniqueDeviceName, "UPnP " + (device != null ? device.StandardDeviceType : "device"), eventParameter, eventValue);
            }

            return(returnValue);
        }
Beispiel #27
0
        public object InterfaceControl(MigInterfaceCommand request)
        {
            ResponseText returnValue    = new ResponseText("OK");
            bool         raiseEvent     = false;
            string       eventParameter = ModuleEvents.Status_Level;
            string       eventValue     = "";

            string   nodeId = request.Address;
            Commands command;

            Enum.TryParse <Commands>(request.Command.Replace(".", "_"), out command);
            ZWaveNode node = null;

            byte nodeNumber = 0;

            if (byte.TryParse(nodeId, out nodeNumber))
            {
                if (nodeNumber > 0)
                {
                    node = controller.GetNode(nodeNumber);
                }
                switch (command)
                {
                case Commands.Controller_Discovery:
                    controller.Discovery();
                    break;

                case Commands.Controller_SoftReset:
                    controller.SoftReset();
                    break;

                case Commands.Controller_HardReset:
                    controller.HardReset();
                    controller.Discovery();
                    break;

                case Commands.Controller_HealNetwork:
                    controller.HealNetwork();
                    break;

                case Commands.Controller_NodeNeighborUpdate:
                    controller.RequestNeighborsUpdateOptions(nodeNumber);
                    controller.RequestNeighborsUpdate(nodeNumber);
                    controller.GetNeighborsRoutingInfo(nodeNumber);
                    returnValue = GetResponseValue(nodeNumber, EventPath_RoutingInfo);
                    break;

                case Commands.Controller_NodeRoutingInfo:
                    controller.GetNeighborsRoutingInfo(nodeNumber);
                    returnValue = GetResponseValue(nodeNumber, EventPath_RoutingInfo);
                    break;

                case Commands.Controller_NodeAdd:
                    lastAddedNode = 0;
                    controller.BeginNodeAdd();
                    for (int i = 0; i < 20; i++)
                    {
                        if (lastAddedNode > 0)
                        {
                            break;
                        }
                        Thread.Sleep(500);
                    }
                    controller.StopNodeAdd();
                    returnValue = new ResponseText(lastAddedNode.ToString());
                    break;

                case Commands.Controller_NodeRemove:
                    lastRemovedNode = 0;
                    controller.BeginNodeRemove();
                    for (int i = 0; i < 20; i++)
                    {
                        if (lastRemovedNode > 0)
                        {
                            break;
                        }
                        Thread.Sleep(500);
                    }
                    controller.StopNodeRemove();
                    returnValue = new ResponseText(lastRemovedNode.ToString());
                    break;

                case Commands.Basic_Set:
                {
                    raiseEvent = true;
                    var level = int.Parse(request.GetOption(0));
                    eventValue = level.ToString(CultureInfo.InvariantCulture);
                    Basic.Set(node, (byte)level);
                }
                break;

                case Commands.Basic_Get:
                    Basic.Get(node);
                    returnValue = GetResponseValue(nodeNumber, EventPath_Basic);
                    break;

                case Commands.SwitchBinary_Set:
                {
                    raiseEvent = true;
                    var level = int.Parse(request.GetOption(0));
                    eventValue = level.ToString(CultureInfo.InvariantCulture);
                    SwitchBinary.Set(node, (byte)level);
                }
                break;

                case Commands.SwitchBinary_Get:
                    SwitchBinary.Get(node);
                    returnValue = GetResponseValue(nodeNumber, EventPath_SwitchBinary);
                    break;

                case Commands.SwitchMultilevel_Set:
                {
                    raiseEvent = true;
                    var level = int.Parse(request.GetOption(0));
                    eventValue = level.ToString(CultureInfo.InvariantCulture);
                    SwitchMultilevel.Set(node, (byte)level);
                }
                break;

                case Commands.SwitchMultilevel_Get:
                    SwitchMultilevel.Get(node);
                    returnValue = GetResponseValue(nodeNumber, EventPath_SwitchMultilevel);
                    break;

                case Commands.MultiInstance_GetCount:
                {
                    string commandType = request.GetOption(0).Replace(".", "");
                    switch (commandType)
                    {
                    case "SwitchBinary":
                        MultiInstance.GetCount(node, (byte)ZWaveLib.CommandClass.SwitchBinary);
                        break;

                    case "SwitchMultiLevel":
                        MultiInstance.GetCount(node, (byte)ZWaveLib.CommandClass.SwitchMultilevel);
                        break;

                    case "SensorBinary":
                        MultiInstance.GetCount(node, (byte)ZWaveLib.CommandClass.SensorBinary);
                        break;

                    case "SensorMultiLevel":
                        MultiInstance.GetCount(node, (byte)ZWaveLib.CommandClass.SensorMultilevel);
                        break;
                    }
                    returnValue = GetResponseValue(nodeNumber, EventPath_MultiInstance + "." + commandType + ".Count");
                }
                break;

                case Commands.MultiInstance_Get:
                {
                    byte   instance    = (byte)int.Parse(request.GetOption(1));
                    string commandType = request.GetOption(0).Replace(".", "");
                    switch (commandType)
                    {
                    case "SwitchBinary":
                        MultiInstance.SwitchBinaryGet(node, instance);
                        break;

                    case "SwitchMultiLevel":
                        MultiInstance.SwitchMultiLevelGet(node, instance);
                        break;

                    case "SensorBinary":
                        MultiInstance.SensorBinaryGet(node, instance);
                        break;

                    case "SensorMultiLevel":
                        MultiInstance.SensorMultiLevelGet(node, instance);
                        break;
                    }
                    returnValue = GetResponseValue(nodeNumber, EventPath_MultiInstance + "." + commandType + "." + instance);
                }
                break;

                case Commands.MultiInstance_Set:
                {
                    byte instance = (byte)int.Parse(request.GetOption(1));
                    int  value    = int.Parse(request.GetOption(2));
                    //
                    //raisepropchanged = true;
                    //parampath += "." + instance; // Status.Level.<instance>
                    //
                    switch (request.GetOption(0))
                    {
                    case "Switch.Binary":
                        MultiInstance.SwitchBinarySet(node, instance, value);
                        //raiseparam = (double.Parse(request.GetOption(2)) / 255).ToString();
                        break;

                    case "Switch.MultiLevel":
                        MultiInstance.SwitchMultiLevelSet(node, instance, value);
                        //raiseparam = (double.Parse(request.GetOption(2)) / 100).ToString(); // TODO: should it be 99 ?
                        break;
                    }
                }
                break;

                case Commands.SensorBinary_Get:
                    SensorBinary.Get(node);
                    break;

                case Commands.SensorMultiLevel_Get:
                    SensorMultilevel.Get(node);
                    break;

                case Commands.Meter_Get:
                    // see ZWaveLib Sensor.cs for EnergyMeterScale options
                    int scaleType = 0;
                    int.TryParse(request.GetOption(0), out scaleType);
                    Meter.Get(node, (byte)(scaleType << 0x03));
                    break;

                case Commands.Meter_SupportedGet:
                    Meter.GetSupported(node);
                    break;

                case Commands.Meter_Reset:
                    Meter.Reset(node);
                    break;

                case Commands.NodeInfo_Get:
                    controller.GetNodeInformationFrame(nodeNumber);
                    returnValue = GetResponseValue(nodeNumber, EventPath_NodeInfo);
                    break;

                case Commands.Battery_Get:
                    Battery.Get(node);
                    returnValue = GetResponseValue(nodeNumber, EventPath_Battery);
                    break;

                case Commands.Association_Set:
                    Association.Set(node, (byte)int.Parse(request.GetOption(0)), (byte)int.Parse(request.GetOption(1)));
                    break;

                case Commands.Association_Get:
                    byte group = (byte)int.Parse(request.GetOption(0));
                    Association.Get(node, group);
                    returnValue = GetResponseValue(nodeNumber, EventPath_Associations + "." + group);
                    break;

                case Commands.Association_Remove:
                    Association.Remove(node, (byte)int.Parse(request.GetOption(0)), (byte)int.Parse(request.GetOption(1)));
                    break;

                case Commands.ManufacturerSpecific_Get:
                    ManufacturerSpecific.Get(node);
                    returnValue = GetResponseValue(nodeNumber, EventPath_ManufacturerSpecific);
                    break;

                case Commands.Config_ParameterSet:
                    Configuration.Set(node, (byte)int.Parse(request.GetOption(0)), int.Parse(request.GetOption(1)));
                    break;

                case Commands.Config_ParameterGet:
                    byte position = (byte)int.Parse(request.GetOption(0));
                    Configuration.Get(node, position);
                    returnValue = GetResponseValue(nodeNumber, EventPath_ConfigVariables + "." + position);
                    break;

                case Commands.WakeUp_Get:
                    WakeUp.Get(node);
                    returnValue = GetResponseValue(nodeNumber, EventPath_WakeUpInterval);
                    break;

                case Commands.WakeUp_Set:
                    WakeUp.Set(node, uint.Parse(request.GetOption(0)));
                    break;

                case Commands.WakeUp_SendToSleep:
                    WakeUp.SendToSleep(node);
                    break;

                case Commands.WakeUp_GetAlwaysAwake:
                    returnValue = new ResponseText(WakeUp.GetAlwaysAwake(node) ? "1" : "0");
                    break;

                case Commands.WakeUp_SetAlwaysAwake:
                    WakeUp.SetAlwaysAwake(node, uint.Parse(request.GetOption(0)) == 1 ? true : false);
                    break;

                case Commands.Version_Get:
                    returnValue = new ResponseText("ERROR");
                    CommandClass cclass;
                    Enum.TryParse <CommandClass>(request.GetOption(0), out cclass);
                    if (cclass != CommandClass.NotSet)
                    {
                        var nodeCclass = node.GetCommandClass(cclass);
                        if (nodeCclass != null && nodeCclass.Version != 0)
                        {
                            returnValue = new ResponseText(nodeCclass.Version.ToString());
                        }
                        else
                        {
                            ZWaveLib.CommandClasses.Version.Get(node, cclass);
                            returnValue = GetResponseValue(nodeNumber, "ZWaveNode.Version." + cclass);
                        }
                    }
                    break;

                case Commands.Version_GetAll:
                    controller.GetNodeCcsVersion(node);
                    break;

                case Commands.Control_On:
                    raiseEvent = true;
                    double lastLevel = GetNormalizedValue((double)GetNodeLastLevel(node));
                    eventValue = lastLevel > 0 ? lastLevel.ToString(CultureInfo.InvariantCulture) : "1";
                    if (node.SupportCommandClass(CommandClass.SwitchMultilevel))
                    {
                        SwitchMultilevel.Set(node, 0xFF);
                    }
                    else if (node.SupportCommandClass(CommandClass.SwitchBinary))
                    {
                        SwitchBinary.Set(node, 0xFF);
                    }
                    else
                    {
                        Basic.Set(node, 0xFF);
                    }
                    SetNodeLevel(node, 0xFF);
                    break;

                case Commands.Control_Off:
                    raiseEvent = true;
                    eventValue = "0";
                    if (node.SupportCommandClass(CommandClass.SwitchMultilevel))
                    {
                        SwitchMultilevel.Set(node, 0x00);
                    }
                    else if (node.SupportCommandClass(CommandClass.SwitchBinary))
                    {
                        SwitchBinary.Set(node, 0x00);
                    }
                    else
                    {
                        Basic.Set(node, 0x00);
                    }
                    SetNodeLevel(node, 0x00);
                    break;

                case Commands.Control_Level:
                {
                    raiseEvent = true;
                    var level = int.Parse(request.GetOption(0));
                    eventValue = Math.Round(level / 100D, 2).ToString(CultureInfo.InvariantCulture);
                    // the max value should be obtained from node parameters specifications,
                    // here we assume that the commonly used interval is [0-99] for most multilevel switches
                    if (level >= 100)
                    {
                        level = 99;
                    }
                    if (node.SupportCommandClass(CommandClass.SwitchMultilevel))
                    {
                        SwitchMultilevel.Set(node, (byte)level);
                    }
                    else
                    {
                        Basic.Set(node, (byte)level);
                    }
                    SetNodeLevel(node, (byte)level);
                }
                break;

                case Commands.Control_Toggle:
                    raiseEvent = true;
                    if (GetNodeLevel(node) == 0)
                    {
                        double lastOnLevel = GetNormalizedValue((double)GetNodeLastLevel(node));
                        eventValue = lastOnLevel > 0 ? lastOnLevel.ToString(CultureInfo.InvariantCulture) : "1";
                        if (node.SupportCommandClass(CommandClass.SwitchMultilevel))
                        {
                            SwitchMultilevel.Set(node, 0xFF);
                        }
                        else if (node.SupportCommandClass(CommandClass.SwitchBinary))
                        {
                            SwitchBinary.Set(node, 0xFF);
                        }
                        else
                        {
                            Basic.Set(node, 0xFF);
                        }
                        SetNodeLevel(node, 0xFF);
                    }
                    else
                    {
                        eventValue = "0";
                        if (node.SupportCommandClass(CommandClass.SwitchMultilevel))
                        {
                            SwitchMultilevel.Set(node, 0x00);
                        }
                        else if (node.SupportCommandClass(CommandClass.SwitchBinary))
                        {
                            SwitchBinary.Set(node, 0x00);
                        }
                        else
                        {
                            Basic.Set(node, 0x00);
                        }
                        SetNodeLevel(node, 0x00);
                    }
                    break;

                case Commands.Thermostat_ModeGet:
                    ThermostatMode.Get(node);
                    break;

                case Commands.Thermostat_ModeSet:
                {
                    ThermostatMode.Value mode = (ThermostatMode.Value)Enum.Parse(typeof(ThermostatMode.Value), request.GetOption(0));
                    //
                    raiseEvent     = true;
                    eventParameter = "Thermostat.Mode";
                    eventValue     = request.GetOption(0);
                    //
                    ThermostatMode.Set(node, mode);
                }
                break;

                case Commands.Thermostat_SetPointGet:
                {
                    ThermostatSetPoint.Value mode = (ThermostatSetPoint.Value)Enum.Parse(typeof(ThermostatSetPoint.Value), request.GetOption(0));
                    ThermostatSetPoint.Get(node, mode);
                }
                break;

                case Commands.Thermostat_SetPointSet:
                {
                    ThermostatSetPoint.Value mode = (ThermostatSetPoint.Value)Enum.Parse(typeof(ThermostatSetPoint.Value), request.GetOption(0));
                    double temperature            = double.Parse(request.GetOption(1).Replace(',', '.'), CultureInfo.InvariantCulture);
                    //
                    raiseEvent     = true;
                    eventParameter = "Thermostat.SetPoint." + request.GetOption(0);
                    eventValue     = temperature.ToString(CultureInfo.InvariantCulture);
                    //
                    ThermostatSetPoint.Set(node, mode, temperature);
                }
                break;

                case Commands.Thermostat_FanModeGet:
                    ThermostatFanMode.Get(node);
                    break;

                case Commands.Thermostat_FanModeSet:
                {
                    ThermostatFanMode.Value mode = (ThermostatFanMode.Value)Enum.Parse(typeof(ThermostatFanMode.Value), request.GetOption(0));
                    //
                    raiseEvent     = true;
                    eventParameter = "Thermostat.FanMode";
                    eventValue     = request.GetOption(0);
                    //
                    ThermostatFanMode.Set(node, mode);
                }
                break;

                case Commands.Thermostat_FanStateGet:
                    ThermostatFanState.Get(node);
                    break;

                case Commands.Thermostat_OperatingStateGet:
                    ThermostatOperatingState.GetOperatingState(node);
                    break;

                case Commands.UserCode_Set:
                    byte   userId       = byte.Parse(request.GetOption(0));
                    byte   userIdStatus = byte.Parse(request.GetOption(1));
                    byte[] tagCode      = ZWaveLib.Utility.HexStringToByteArray(request.GetOption(2));
                    UserCode.Set(node, new ZWaveLib.Values.UserCodeValue(userId, userIdStatus, tagCode));
                    break;

                case Commands.DoorLock_Get:
                    DoorLock.Get(node);
                    returnValue = GetResponseValue(nodeNumber, ModuleEvents.Status_DoorLock);
                    break;

                case Commands.DoorLock_Set:
                {
                    DoorLock.Value mode = (DoorLock.Value)Enum.Parse(typeof(DoorLock.Value), request.GetOption(0));
                    DoorLock.Set(node, mode);
                }
                break;
                }
            }

            if (raiseEvent)
            {
                //ZWaveNode node = _controller.GetDevice ((byte)int.Parse (nodeid));
                OnInterfacePropertyChanged(this.GetDomain(), nodeId, "ZWave Node", eventParameter, eventValue);
            }
            //
            return(returnValue);
        }
Beispiel #28
0
 private object InterfaceControl(Module module, MigInterfaceCommand migCommand)
 {
     migCommand.Domain  = module.Domain;
     migCommand.Address = module.Address;
     return(homegenie.InterfaceControl(migCommand));
 }
Beispiel #29
0
        public object InterfaceControl(MigInterfaceCommand request)
        {
            string response = ""; //default success value

            Commands command;

            Enum.TryParse <Commands>(request.Command.Replace(".", "_"), out command);

            switch (command)
            {
            case Commands.Remotes_Search:
                response = MigService.JsonSerialize(SearchRemotes(request.GetOption(0)));
                break;

            case Commands.Remotes_Add:
            {
                var remote = remotesData.Find(r => r.Manufacturer.ToLower() == request.GetOption(0).ToLower() && r.Model.ToLower() == request.GetOption(1).ToLower());
                if (remote != null && remotesConfig.Find(r => r.Model.ToLower() == remote.Model.ToLower() && r.Manufacturer.ToLower() == remote.Manufacturer.ToLower()) == null)
                {
                    var    webClient = new WebClient();
                    string config    = webClient.DownloadString("http://lirc.sourceforge.net/remotes/" + remote.Manufacturer + "/" + remote.Model);
                    remote.Configuration = GetBytes(config);
                    remotesConfig.Add(remote);
                    SaveConfig();
                }
            }
            break;

            case Commands.Remotes_Remove:
            {
                var remote = remotesConfig.Find(r => r.Manufacturer.ToLower() == request.GetOption(0).ToLower() && r.Model.ToLower() == request.GetOption(1).ToLower());
                if (remote != null)
                {
                    remotesConfig.Remove(remote);
                    SaveConfig();
                }
            }
            break;

            case Commands.Remotes_List:
                response = MigService.JsonSerialize(remotesConfig);
                break;

            case Commands.Control_IrSend:
                string commands = "";
                int    c        = 0;
                while (request.GetOption(c) != "")
                {
                    var options = request.GetOption(c).Split('/');
                    foreach (string o in options)
                    {
                        commands += "\"" + o + "\" ";
                    }
                    c++;
                }
                MigService.ShellCommand("irsend", "SEND_ONCE " + commands);
                break;
            }

            return(response);
        }
        public object InterfaceControl(MigInterfaceCommand request)
        {
            string response = ""; //default success value

            Commands command;
            Enum.TryParse<Commands>(request.Command.Replace(".", "_"), out command);

            switch (command)
            {
            case Commands.Remotes_Search:
                response = MigService.JsonSerialize(SearchRemotes(request.GetOption(0)));
                break;
            case Commands.Remotes_Add:
                {
                    var remote = remotesData.Find(r => r.Manufacturer.ToLower() == request.GetOption(0).ToLower() && r.Model.ToLower() == request.GetOption(1).ToLower());
                    if (remote != null && remotesConfig.Find(r => r.Model.ToLower() == remote.Model.ToLower() && r.Manufacturer.ToLower() == remote.Manufacturer.ToLower()) == null)
                    {
                        var webClient = new WebClient();
                        string config = webClient.DownloadString("http://lirc.sourceforge.net/remotes/" + remote.Manufacturer + "/" + remote.Model);
                        remote.Configuration = GetBytes(config);
                        remotesConfig.Add(remote);
                        SaveConfig();
                    }
                }
                break;
            case Commands.Remotes_Remove:
                {
                    var remote = remotesConfig.Find(r => r.Manufacturer.ToLower() == request.GetOption(0).ToLower() && r.Model.ToLower() == request.GetOption(1).ToLower());
                    if (remote != null)
                    {
                        remotesConfig.Remove(remote);
                        SaveConfig();
                    }
                }
                break;
            case Commands.Remotes_List:
                response = MigService.JsonSerialize(remotesConfig);
                break;
            case Commands.Control_IrSend:
                string commands = "";
                int c = 0;
                while (request.GetOption(c) != "")
                {
                    var options = request.GetOption(c).Split('/');
                    foreach (string o in options)
                    {
                        commands += "\"" + o + "\" ";
                    }
                    c++;
                }
                MigService.ShellCommand("irsend", "SEND_ONCE " + commands);
                break;
            }

            return response;
        }
        public object InterfaceControl(MigInterfaceCommand command)
        {
            string returnValue = "";
            bool raisePropertyChanged = false;
            string parameterPath = "Status.Level";
            string raiseParameter = "";
            switch (command.Command)
            {
                case "Control.On":
                    controller.TurnOn(int.Parse(command.Address));
                    raisePropertyChanged = true;
                    raiseParameter = "1";
                    break;
                case "Control.Off":
                    raisePropertyChanged = true;
                    controller.TurnOff(int.Parse(command.Address));
                    raiseParameter = "0";
                    break;
                case "Control.Level":
                    raisePropertyChanged = true;
                    raiseParameter = (double.Parse(command.GetOption(0)) / 100).ToString();
                    controller.Dim(int.Parse(command.Address), (int)Math.Round(double.Parse(command.GetOption(0))));
                    break;
                default:
                    Console.WriteLine("TS:" + command.Command + " | " + command.Address);
                    break;
            }

            if (raisePropertyChanged)
            {
                try
                {
                    OnInterfacePropertyChanged(this.GetDomain(), command.Address, Event_Node_Description, parameterPath, raiseParameter);
                }
                catch
                {
                }
            }
            return returnValue;
        }
Beispiel #32
0
        public object InterfaceControl(MigInterfaceCommand request)
        {
            bool   raisePropertyChanged = false;
            string parameterPath        = ModuleEvents.Status_Level;
            string raiseParameter       = "";
            //
            string nodeId = request.Address;

            Commands command;

            Enum.TryParse <Commands>(request.Command.Replace(".", "_"), out command);
            string option = request.GetOption(0);

            bool isDottedHexId = (nodeId.IndexOf(".") > 0);

            if (isDottedHexId)
            {
                // Standard Insteon device

                DeviceBase device = null;
                insteonPlm.Network.TryConnectToDevice(nodeId, out device);

                //TODO: handle types IrrigationControl and PoolAndSpaControl

                switch (command)
                {
                case Commands.Parameter_Status:
                    break;

                case Commands.Control_On:
                    raisePropertyChanged = true;
                    raiseParameter       = "1";
                    //
                    if (device != null)
                    {
                        switch (device.GetType().Name)
                        {
                        case "LightingControl":
                            (device as LightingControl).TurnOn();
                            break;

                        case "DimmableLightingControl":
                            (device as DimmableLightingControl).TurnOn();
                            break;

                        case "SwitchedLightingControl":
                            (device as SwitchedLightingControl).TurnOn();
                            break;

                        case "SensorsActuators":
                            (device as SensorsActuators).TurnOnOutput(byte.Parse(option));
                            break;

                        case "WindowCoveringControl":
                            (device as WindowCoveringControl).Open();
                            break;

                        case "PoolAndSpaControl":
                            break;

                        case "IrrigationControl":
                            (device as IrrigationControl).TurnOnSprinklerValve(byte.Parse(option));
                            break;
                        }
                    }
                    break;

                case Commands.Control_Off:
                    raisePropertyChanged = true;
                    raiseParameter       = "0";
                    //
                    if (device != null)
                    {
                        switch (device.GetType().Name)
                        {
                        case "LightingControl":
                            (device as LightingControl).TurnOff();
                            break;

                        case "DimmableLightingControl":
                            (device as DimmableLightingControl).TurnOff();
                            break;

                        case "SwitchedLightingControl":
                            (device as SwitchedLightingControl).TurnOff();
                            break;

                        case "SensorsActuators":
                            (device as SensorsActuators).TurnOffOutput(byte.Parse(option));
                            break;

                        case "WindowCoveringControl":
                            (device as WindowCoveringControl).Close();
                            break;

                        case "PoolAndSpaControl":
                            break;

                        case "IrrigationControl":
                            (device as IrrigationControl).TurnOffSprinklerValve(byte.Parse(option));
                            break;
                        }
                    }
                    break;

                case Commands.Control_Bright:
                    // TODO: raise parameter change event
                    if (device != null && device is DimmableLightingControl)
                    {
                        (device as DimmableLightingControl).BrightenOneStep();
                    }
                    break;

                case Commands.Control_Dim:
                    // TODO: raise parameter change event
                    if (device != null && device is DimmableLightingControl)
                    {
                        (device as DimmableLightingControl).DimOneStep();
                    }
                    break;

                case Commands.Control_Level:
                    double adjustedLevel = (double.Parse(option) / 100D);
                    raisePropertyChanged = true;
                    raiseParameter       = adjustedLevel.ToString(CultureInfo.InvariantCulture);
                    //
                    byte level = (byte)((double.Parse(option) / 100D) * 255);
                    if (device != null)
                    {
                        switch (device.GetType().Name)
                        {
                        case "DimmableLightingControl":
                            (device as DimmableLightingControl).TurnOn(level);
                            break;

                        case "WindowCoveringControl":
                            (device as WindowCoveringControl).MoveToPosition(level);
                            break;
                        }
                    }
                    break;

                case Commands.Control_Toggle:
                    break;

                case Commands.Control_AllLightsOn:
                    break;

                case Commands.Control_AllLightsOff:
                    break;
                }
            }
            else
            {
                // It is not a dotted hex addres, so fallback to X10 device control
                var x10plm = insteonPlm.Network.X10;

                // Parse house/unit
                string houseCode = nodeId.Substring(0, 1);
                byte   unitCode  = 0x00;
                if (nodeId.Length > 1)
                {
                    unitCode = byte.Parse(nodeId.Substring(1));
                }


                switch (command)
                {
                case Commands.Parameter_Status:
                    x10plm
                    .House(houseCode.ToString())
                    .Unit(unitCode)
                    .Command(X10Command.StatusRequest);
                    break;

                case Commands.Control_On:
                    raisePropertyChanged = true;
                    raiseParameter       = "1";
                    //
                    x10plm
                    .House(houseCode)
                    .Unit(unitCode)
                    .Command(X10Command.On);
                    break;

                case Commands.Control_Off:
                    raisePropertyChanged = true;
                    raiseParameter       = "0";
                    //
                    x10plm
                    .House(houseCode)
                    .Unit(unitCode)
                    .Command(X10Command.Off);
                    break;

                case Commands.Control_Bright:
                    // TODO: raise parameter change event
                    //int amount = int.Parse(option);
                    // TODO: how to specify bright amount parameter???
                    x10plm
                    .House(houseCode)
                    .Unit(unitCode)
                    .Command(X10Command.Bright);
                    break;

                case Commands.Control_Dim:
                    // TODO: raise parameter change event
                    //int amount = int.Parse(option);
                    // TODO: how to specify dim amount parameter???
                    x10plm
                    .House(houseCode)
                    .Unit(unitCode)
                    .Command(X10Command.Dim);
                    break;

                case Commands.Control_Level:
                    double adjustedLevel = (double.Parse(option) / 100D);
                    raisePropertyChanged = true;
                    raiseParameter       = adjustedLevel.ToString(CultureInfo.InvariantCulture);
                    //

                    /*int dimvalue = int.Parse(option) - (int)(x10lib.ModulesStatus[ nodeId ].Level * 100.0);
                     * if (dimvalue > 0)
                     * {
                     *  x10lib.Bright(houseCode, unitCode, dimvalue);
                     * }
                     * else if (dimvalue < 0)
                     * {
                     *  x10lib.Dim(houseCode, unitCode, -dimvalue);
                     * }*/
                    break;

                case Commands.Control_Toggle:
                    /*
                     * string huc = XTenLib.Utility.HouseUnitCodeFromEnum(houseCode, unitCode);
                     * if (x10lib.ModulesStatus[ huc ].Level == 0)
                     * {
                     *  x10lib.LightOn(houseCode, unitCode);
                     * }
                     * else
                     * {
                     *  x10lib.LightOff(houseCode, unitCode);
                     * }
                     */
                    break;

                case Commands.Control_AllLightsOn:
                    // TODO: ...
                    x10plm
                    .House(houseCode)
                    .Command(X10Command.AllLightsOn);
                    break;

                case Commands.Control_AllLightsOff:
                    // TODO: ...
                    x10plm
                    .House(houseCode)
                    .Command(X10Command.AllLightsOff);
                    break;
                }
            }

            if (raisePropertyChanged)
            {
                OnInterfacePropertyChanged(this.GetDomain(), nodeId, "Insteon Device", parameterPath, raiseParameter);
            }

            return(new ResponseText("OK"));
        }
        public object InterfaceControl(MigInterfaceCommand request)
        {
            var response = new ResponseText("OK"); //default success value

            Commands command;
            Enum.TryParse<Commands>(request.Command.Replace(".", "_"), out command);

            var module = modules.Find (m => m.Address.Equals (request.Address));

            if (module != null) {
                switch (command) {
                case Commands.Control_On:
                // TODO: ...
                    OnInterfacePropertyChanged (this.GetDomain (), request.Address, "Test Interface", "Status.Level", 1);
                    break;
                case Commands.Control_Off:
                    OnInterfacePropertyChanged (this.GetDomain (), request.Address, "Test Interface", "Status.Level", 0);
                // TODO: ...
                    break;
                case Commands.Temperature_Get:
                    OnInterfacePropertyChanged (this.GetDomain (), request.Address, "Test Interface", "Sensor.Temperature", 19.75);
                // TODO: ...
                    break;
                case Commands.Greet_Hello:
                // TODO: ...
                    OnInterfacePropertyChanged (this.GetDomain (), request.Address, "Test Interface", "Sensor.Message", String.Format ("Hello {0}", request.GetOption (0)));
                    response = new ResponseText ("Hello World!");
                    break;
                }
            }
            else 
            {
                response = new ResponseText ("ERROR: invalid module address");
            }

            return response;
        }