private static void RunStressTest(ZWaveController controller) { ToggleDebug(true); // loop 10 times for (var x = 0; x < 10; x++) { foreach (var node in controller.Nodes) { Console.ForegroundColor = ConsoleColor.Cyan; Console.WriteLine("\nNode {0} Controller.GetNodeInformationFrame", node.Id); Console.ForegroundColor = ConsoleColor.White; controller.GetNodeInformationFrame(node.Id); Console.ForegroundColor = ConsoleColor.Cyan; Console.WriteLine("\nNode {0} Controller.GetNeighborsRoutingInfo", node.Id); Console.ForegroundColor = ConsoleColor.White; controller.GetNeighborsRoutingInfo(node.Id); Console.ForegroundColor = ConsoleColor.Cyan; Console.WriteLine("\nNode {0} CommandClass.ManufacturerSpecific.Get", node.Id); Console.ForegroundColor = ConsoleColor.White; ManufacturerSpecific.Get(node); Console.ForegroundColor = ConsoleColor.Cyan; Console.WriteLine("\nNode {0} CommandClass.Basic.Get", node.Id); Console.ForegroundColor = ConsoleColor.White; Basic.Get(node); } // Pause 2 secods between each test pass Thread.Sleep(2000); } ToggleDebug(false); }
public bool CanHandleProduct(ManufacturerSpecific productspecs) { return(productspecs.ManufacturerId == "0073" && productspecs.TypeId == "03E8" && productspecs.ProductId == "0003"); }
private void controller_UpdateNodeParameter(object sender, UpdateNodeParameterEventArgs upargs) { string path = "UnknwonParameter"; object value = upargs.Value; // switch (upargs.ParameterType) { case ParameterType.PARAMETER_WATTS: path = ModuleParameters.MODPAR_METER_WATTS; break; case ParameterType.PARAMETER_BATTERY: // _raisePropertyChanged(new InterfacePropertyChangedAction() { Domain = this.Domain, SourceId = upargs.NodeId.ToString(), SourceType = "ZWave Node", Path = "ZWaveNode.Battery", Value = value }); // path = ModuleParameters.MODPAR_STATUS_BATTERY; break; case ParameterType.PARAMETER_NODE_INFO: path = "ZWaveNode.NodeInfo"; break; case ParameterType.PARAMETER_GENERIC: path = ModuleParameters.MODPAR_SENSOR_GENERIC; break; case ParameterType.PARAMETER_ALARM_GENERIC: path = ModuleParameters.MODPAR_SENSOR_ALARM_GENERIC; break; case ParameterType.PARAMETER_ALARM_DOORWINDOW: path = ModuleParameters.MODPAR_SENSOR_DOORWINDOW; break; case ParameterType.PARAMETER_ALARM_TAMPERED: path = ModuleParameters.MODPAR_SENSOR_TAMPER; break; case ParameterType.PARAMETER_TEMPERATURE: path = ModuleParameters.MODPAR_SENSOR_TEMPERATURE; break; case ParameterType.PARAMETER_HUMIDITY: path = ModuleParameters.MODPAR_SENSOR_HUMIDITY; break; case ParameterType.PARAMETER_LUMINANCE: path = ModuleParameters.MODPAR_SENSOR_LUMINANCE; break; case ParameterType.PARAMETER_MOTION: path = ModuleParameters.MODPAR_SENSOR_MOTIONDETECT; break; case ParameterType.PARAMETER_ALARM_SMOKE: path = ModuleParameters.MODPAR_SENSOR_ALARM_SMOKE; break; case ParameterType.PARAMETER_ALARM_CARBONMONOXIDE: path = ModuleParameters.MODPAR_SENSOR_ALARM_CARBONMONOXIDE; break; case ParameterType.PARAMETER_ALARM_CARBONDIOXIDE: path = ModuleParameters.MODPAR_SENSOR_ALARM_CARBONDIOXIDE; break; case ParameterType.PARAMETER_ALARM_HEAT: path = ModuleParameters.MODPAR_SENSOR_ALARM_HEAT; break; case ParameterType.PARAMETER_ALARM_FLOOD: path = ModuleParameters.MODPAR_SENSOR_ALARM_FLOOD; break; case ParameterType.PARAMETER_ZWAVE_MANUFACTURER_SPECIFIC: ManufacturerSpecific mf = (ManufacturerSpecific)value; path = "ZWaveNode.ManufacturerSpecific"; //value = mf.ManufacturerId + ":" + mf.TypeId + ":" + mf.ProductId; break; case ParameterType.PARAMETER_CONFIG: path = "ZWaveNode.Variables." + upargs.ParameterId; break; case ParameterType.PARAMETER_ASSOC: switch (upargs.ParameterId) { // case 0: // path = "ZWaveNode.Associations.Group"; // break; case 1: path = "ZWaveNode.Associations.Max"; break; case 2: path = "ZWaveNode.Associations.Count"; break; case 3: string gid = value.ToString().Split(':')[0]; value = value.ToString().Split(':')[1]; path = "ZWaveNode.Associations." + gid; // TODO: implement generic group/node association instead of fixed one break; } break; case ParameterType.PARAMETER_MULTIINSTANCE_SWITCH_BINARY_COUNT: path = "ZWaveNode.MultiInstance.SwitchBinary.Count"; break; case ParameterType.PARAMETER_MULTIINSTANCE_SWITCH_MULTILEVEL_COUNT: path = "ZWaveNode.MultiInstance.SwitchMultiLevel.Count"; break; case ParameterType.PARAMETER_MULTIINSTANCE_SENSOR_BINARY_COUNT: path = "ZWaveNode.MultiInstance.SensorBinary.Count"; break; case ParameterType.PARAMETER_MULTIINSTANCE_SENSOR_MULTILEVEL_COUNT: path = "ZWaveNode.MultiInstance.SensorMultiLevel.Count"; break; case ParameterType.PARAMETER_MULTIINSTANCE_SWITCH_BINARY: path = "ZWaveNode.MultiInstance.SwitchBinary." + upargs.ParameterId; break; case ParameterType.PARAMETER_MULTIINSTANCE_SWITCH_MULTILEVEL: path = "ZWaveNode.MultiInstance.SwitchMultiLevel." + upargs.ParameterId; break; case ParameterType.PARAMETER_MULTIINSTANCE_SENSOR_BINARY: path = "ZWaveNode.MultiInstance.SensorBinary." + upargs.ParameterId; break; case ParameterType.PARAMETER_MULTIINSTANCE_SENSOR_MULTILEVEL: path = "ZWaveNode.MultiInstance.SensorMultiLevel." + upargs.ParameterId; break; case ParameterType.PARAMETER_WAKEUP_INTERVAL: path = "ZWaveNode.WakeUpInterval"; break; case ParameterType.PARAMETER_WAKEUP_NOTIFY: path = "ZWaveNode.WakeUpNotify"; break; case ParameterType.PARAMETER_BASIC: // _raisePropertyChanged(new InterfacePropertyChangedAction() { Domain = this.Domain, SourceId = upargs.NodeId.ToString(), SourceType = "ZWave Node", Path = "ZWaveNode.Basic", Value = value }); // double normalizedval = (Math.Round((double)value / 99D, 2)); if (normalizedval > 1.0) { normalizedval = 1.0; // binary switches have [0/255], while multilevel switches [0-99] } if (upargs.ParameterId == 0) { path = ModuleParameters.MODPAR_STATUS_LEVEL; } else { path = ModuleParameters.MODPAR_STATUS_LEVEL + "." + upargs.ParameterId; } value = normalizedval.ToString(System.Globalization.CultureInfo.InvariantCulture); break; default: Console.WriteLine("UNHANDLED PARAMETER CHANGE FROM NODE {0} ====> Param Type: {1} Param Id:{2} Value:{3}", upargs.NodeId, upargs.ParameterType, upargs.ParameterId, value); break; } //string type = upargs.ParameterType.ToString (); // _raisePropertyChanged(new InterfacePropertyChangedAction() { Domain = this.Domain, SourceId = upargs.NodeId.ToString(), SourceType = "ZWave Node", Path = path, Value = value }); }
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); }
private void ZwaveMessageReceived(object sender, ZWaveMessageReceivedEventArgs args) { // discard repeated messages within last 2 seconds time range bool repeated = false; if (lastMessage != null) { var elapsed = (DateTime.UtcNow - lastMessageTimestamp); if (elapsed.TotalSeconds <= 2 && lastMessage.SequenceEqual(args.Message)) { //Utility.DebugLog(DebugMessageType.Information, " lastMessage: " + Utility.ByteArrayToString(lastMessage)); //Utility.DebugLog(DebugMessageType.Information, "args.Message: " + Utility.ByteArrayToString(args.Message)); repeated = true; } } lastMessageTimestamp = DateTime.UtcNow; lastMessage = new byte[args.Message.Length]; //Utility.DebugLog(DebugMessageType.Information, " lastMessage2: " + Utility.ByteArrayToString(lastMessage)); //Utility.DebugLog(DebugMessageType.Information, "args.Message2: " + Utility.ByteArrayToString(args.Message)); Buffer.BlockCopy(args.Message, 0, lastMessage, 0, args.Message.Length * sizeof(byte)); if (repeated) { Utility.DebugLog(DebugMessageType.Warning, "Repeated message discarded."); return; } // int length = args.Message.Length; try { MessageHeader zwaveHeader = (MessageHeader)args.Message[0]; switch (zwaveHeader) { case MessageHeader.CAN: // RESEND ?!?! break; case MessageHeader.ACK: break; case MessageHeader.SOF: // start of zwave frame var messageType = MessageType.None; Enum.TryParse(args.Message[2].ToString(), out messageType); var functionType = Function.None; Enum.TryParse(args.Message[3].ToString(), out functionType); switch (messageType) { case MessageType.Request: if (devices.Count == 0) { break; } switch (functionType) { case Function.None: break; case Function.NodeAdd: var nodeAddStatus = NodeFunctionStatus.None; Enum.TryParse(args.Message[5].ToString(), out nodeAddStatus); switch (nodeAddStatus) { case NodeFunctionStatus.AddNodeAddingSlave: nodeOperationIdCheck = args.Message[6]; var newNode = CreateDevice(nodeOperationIdCheck, 0x00); // Extract node information frame int nodeInfoLength = (int)args.Message[7]; // we don't need to exclude the last 2 CommandClasses byte[] nodeInfo = new byte[nodeInfoLength]; Array.Copy(args.Message, 8, nodeInfo, 0, nodeInfoLength); newNode.NodeInformationFrame = nodeInfo; newNode.BasicClass = args.Message[8]; newNode.GenericClass = args.Message[9]; newNode.SpecificClass = args.Message[10]; devices.Add(newNode); if (newNode.SupportCommandClass(CommandClass.Security)) { var nodeSecurityData = Security.GetSecurityData(newNode); nodeSecurityData.IsAddingNode = true; Security.GetScheme(newNode); } else { NodeInformationFrameComplete(newNode); } break; //case NodeFunctionStatus.AddNodeDone: case NodeFunctionStatus.AddNodeProtocolDone: if (nodeOperationIdCheck == args.Message[6]) { Thread.Sleep(500); GetNodeCapabilities(args.Message[6]); var addedNode = devices.Find(n => n.Id == args.Message[6]); if (addedNode != null) { ManufacturerSpecific.Get(addedNode); } } OnControllerEvent(new ControllerEventArgs(0x00, ControllerStatus.NodeAdded)); // force refresh of nodelist sending DiscoverEnd event // TODO: deprecate this and update the Web UI to refresh modules list on NodeAdded event OnControllerEvent(new ControllerEventArgs(0x00, ControllerStatus.DiscoveryEnd)); break; case NodeFunctionStatus.AddNodeFailed: Utility.DebugLog(DebugMessageType.Warning, "ADDING NODE FAILED (" + args.Message[6] + ")"); break; } break; case Function.NodeRemove: var nodeRemoveStatus = NodeFunctionStatus.None; Enum.TryParse(args.Message[5].ToString(), out nodeRemoveStatus); switch (nodeRemoveStatus) { case NodeFunctionStatus.RemoveNodeRemovingSlave: nodeOperationIdCheck = args.Message[6]; break; case NodeFunctionStatus.RemoveNodeDone: if (nodeOperationIdCheck == args.Message[6]) { RemoveDevice(nodeOperationIdCheck); } OnControllerEvent(new ControllerEventArgs(0x00, ControllerStatus.NodeRemoved)); // force refresh of nodelist sending DiscoverEnd event // TODO: deprecate this and update the Web UI to refresh modules list on NodeRemoved event OnControllerEvent(new ControllerEventArgs(0x00, ControllerStatus.DiscoveryEnd)); break; case NodeFunctionStatus.RemoveNodeFailed: OnControllerEvent(new ControllerEventArgs(0x00, ControllerStatus.NodeError)); Utility.DebugLog(DebugMessageType.Warning, "REMOVING NODE FAILED (" + args.Message[6] + ")"); break; } break; case Function.ApplicationCommandHandler: var node = devices.Find(n => n.Id == args.Message[5]); if (node != null) { try { node.ApplicationCommandHandler(args.Message); } catch (Exception ex) { Utility.DebugLog(DebugMessageType.Error, "Exception occurred in node.ApplicationCommandHandler: " + ex.Message + "\n" + ex.StackTrace); } } else { Utility.DebugLog(DebugMessageType.Error, "Unknown node id " + args.Message[5]); } break; case Function.SendData: byte callbackId = args.Message[4]; if (callbackId == 0x01) // 0x01 is "SEND DATA OK" { // TODO: ... is there anything to be done here? } else { var status = CallbackStatus.Nack; Enum.TryParse(args.Message[5].ToString(), out status); switch (status) { case CallbackStatus.Ack: // Messaging complete, remove callbackid zwavePort.NodeRequestAck(callbackId); break; case CallbackStatus.Nack: var pendingMessage = zwavePort.NodeRequestNack(callbackId); if (pendingMessage != null && pendingMessage.ResendCount >= ZWaveMessage.ResendMaxAttempts) { // Resend timed out OnControllerEvent(new ControllerEventArgs(pendingMessage.Node.Id, ControllerStatus.NodeError)); // Check if node supports WakeUp class, and add message to wake up message queue if (pendingMessage != null) { var sleepingNode = pendingMessage.Node; if (sleepingNode != null && sleepingNode.SupportCommandClass(CommandClass.WakeUp)) { WakeUp.ResendOnWakeUp(sleepingNode, pendingMessage.Message); } } } break; case CallbackStatus.NeighborUpdateStarted: // Neighbour Update Options STARTED //var message = zwavePort.GetPendingMessage(commandId); // TODO: don't know what to do here... break; case CallbackStatus.NeighborUpdateDone: var message = zwavePort.GetPendingMessage(callbackId); if (message != null) { RequestNeighborsUpdate(message.Node); // send ack so the message is removed from the pending message list zwavePort.NodeRequestAck(callbackId); } break; } } break; case Function.ApplicationUpdate: int nifLength = (int)args.Message[6]; var znode = devices.Find(n => n.Id == args.Message[5]); if (znode != null) { // we don't need to exclude the last 2 CommandClasses byte[] nodeInfo = new byte[nifLength]; Array.Copy(args.Message, 7, nodeInfo, 0, nifLength); znode.NodeInformationFrame = nodeInfo; if (znode.SupportCommandClass(CommandClass.Security)) { // ask the node what security command classes are supported Security.GetSupported(znode); } else { NodeInformationFrameComplete(znode); } } break; case Function.RequestNodeNeighborsUpdateOptions: case Function.RequestNodeNeighborsUpdate: var neighborUpdateStatus = NeighborsUpdateStatus.None; Enum.TryParse(args.Message[5].ToString(), out neighborUpdateStatus); var pm = zwavePort.GetPendingMessage(args.Message[4]); switch (neighborUpdateStatus) { case NeighborsUpdateStatus.NeighborsUpdateStared: OnControllerEvent(new ControllerEventArgs(pm.Node.Id, ControllerStatus.NeighborUpdateStarted)); break; case NeighborsUpdateStatus.NeighborsUpdateDone: nodeOperationIdCheck = pm.Node.Id; OnControllerEvent(new ControllerEventArgs(nodeOperationIdCheck, ControllerStatus.NeighborUpdateDone)); GetNeighborsRoutingInfo(pm.Node); if (pm != null) { zwavePort.NodeRequestAck(pm.CallbackId); } break; case NeighborsUpdateStatus.NeighborsUpdateFailed: OnControllerEvent(new ControllerEventArgs(pm.Node.Id, ControllerStatus.NeighborUpdateFailed)); if (pm != null) { zwavePort.NodeRequestNack(pm.CallbackId); } break; default: Utility.DebugLog(DebugMessageType.Warning, "Unhandled Node Neighbor Update REQUEST " + Utility.ByteArrayToString(args.Message)); break; } break; default: Utility.DebugLog(DebugMessageType.Warning, "Unhandled REQUEST " + Utility.ByteArrayToString(args.Message)); break; } break; case MessageType.Response: switch (functionType) { case Function.DiscoveryNodes: NodeBitMaskResponseHandler(args.Message); break; case Function.GetNodeProtocolInfo: NodeCapabilitiesResponseHandler(args.Message); break; case Function.RequestNodeInfo: // TODO: shall we do something here? break; case Function.SendData: // TODO: shall we do something here? break; case Function.GetRoutingInfo: var routingInfo = ExtractRoutingFromBitMask(args.Message); if (routingInfo.Count > 0) { var routedNode = devices.Find(n => n.Id == nodeOperationIdCheck); if (routedNode != null) { // routedNode.RaiseUpdateParameterEvent(new ZWaveEvent(routedNode, EventParameter.RoutingInfo, String.Join(" ", routingInfo), 0)); } } else { Utility.DebugLog(DebugMessageType.Warning, "No routing nodes reported."); } break; default: Utility.DebugLog(DebugMessageType.Warning, "Unhandled RESPONSE " + Utility.ByteArrayToString(args.Message)); break; } break; default: Utility.DebugLog(DebugMessageType.Warning, "Unhandled MESSAGE TYPE " + Utility.ByteArrayToString(args.Message)); break; } break; } } catch (Exception ex) { Utility.DebugLog(DebugMessageType.Error, "Exception occurred :" + ex.Message + "\n" + ex.StackTrace); } }
public virtual bool CanHandleProduct(ManufacturerSpecific productspecs) { return false; // generic types must return false here }
public override bool CanHandleProduct(ManufacturerSpecific productspecs) { return((productspecs.ManufacturerId == "0086" && productspecs.TypeId == "0002" && productspecs.ProductId == "0004") || (productspecs.ManufacturerId == "0086" && productspecs.TypeId == "0002" && productspecs.ProductId == "001D")); }
public override bool CanHandleProduct(ManufacturerSpecific productspecs) { return (productspecs.ManufacturerId == "0086" && productspecs.TypeId == "0003" && productspecs.ProductId == "000C"); }
public ManufacturerSpecificCommand(byte address, ManufacturerSpecific manufacturerData) { Address = address; _manufacturerData = manufacturerData; }
public bool CanHandleProduct(ManufacturerSpecific productspecs) { return (productspecs.ManufacturerId == "0073" && productspecs.TypeId == "03E8" && productspecs.ProductId == "0003"); }
private void ZwaveMessageReceived(object sender, ZWaveMessageReceivedEventArgs args) { // discard repeated messages within last 2 seconds time range bool repeated = false; if (lastMessage != null) { var elapsed = (DateTime.UtcNow - lastMessageTimestamp); if (elapsed.TotalSeconds <= 2 && lastMessage.SequenceEqual(args.Message)) { //Utility.DebugLog(DebugMessageType.Information, " lastMessage: " + Utility.ByteArrayToString(lastMessage)); //Utility.DebugLog(DebugMessageType.Information, "args.Message: " + Utility.ByteArrayToString(args.Message)); repeated = true; } } lastMessageTimestamp = DateTime.UtcNow; lastMessage = new byte[args.Message.Length]; //Utility.DebugLog(DebugMessageType.Information, " lastMessage2: " + Utility.ByteArrayToString(lastMessage)); //Utility.DebugLog(DebugMessageType.Information, "args.Message2: " + Utility.ByteArrayToString(args.Message)); Buffer.BlockCopy(args.Message, 0, lastMessage, 0, args.Message.Length * sizeof(byte)); if (repeated) { Utility.DebugLog(DebugMessageType.Warning, "Repeated message discarded."); return; } // int length = args.Message.Length; try { MessageHeader zwaveHeader = (MessageHeader)args.Message[0]; switch (zwaveHeader) { case MessageHeader.CAN: // RESEND //Utility.DebugLog(DebugMessageType.Warning, "Received CAN, resending last message"); //zp.ResendLastMessage(); break; case MessageHeader.ACK: break; case MessageHeader.SOF: // start of zwave frame // // parse frame headers // //int msgLength = (int)args.Message[1]; var msgType = (MessageType)args.Message[2]; var function = (args.Message.Length > 3 ? (Function)args.Message[3] : 0); byte sourceNodeId = 0; byte nodeOperation = 0; // switch (msgType) { case MessageType.Request: if (devices.Count == 0) { break; } switch (function) { case Function.None: break; case Function.NodeAdd: nodeOperation = args.Message[5]; if (nodeOperation == (byte)NodeFunctionStatus.AddNodeAddingSlave) { nodeOperationIdCheck = args.Message[6]; var newNode = CreateDevice(nodeOperationIdCheck, 0x00); // Extract node information frame int nodeInfoLength = (int)args.Message[7]; // we don't need to exclude the last 2 CommandClasses byte[] nodeInfo = new byte[nodeInfoLength]; Array.Copy(args.Message, 8, nodeInfo, 0, nodeInfoLength); newNode.NodeInformationFrame = nodeInfo; newNode.BasicClass = args.Message[8]; newNode.GenericClass = args.Message[9]; newNode.SpecificClass = args.Message[10]; devices.Add(newNode); if (newNode.SupportCommandClass(CommandClass.Security)) { var nodeSecurityData = Security.GetSecurityData(newNode); nodeSecurityData.IsAddingNode = true; Security.GetScheme(newNode); } else { gotNodeUpdateInformation(newNode); } } else if (nodeOperation == (byte)NodeFunctionStatus.AddNodeProtocolDone /* || nodeOperation == (byte)NodeFunctionStatus.AddNodeDone */) { if (nodeOperationIdCheck == args.Message[6]) { Thread.Sleep(500); GetNodeCapabilities(args.Message[6]); var newNode = devices.Find(n => n.Id == args.Message[6]); if (newNode != null) { ManufacturerSpecific.Get(newNode); } } OnControllerEvent(new ControllerEventArgs(0x00, ControllerStatus.DiscoveryEnd)); } else if (nodeOperation == (byte)NodeFunctionStatus.AddNodeFailed) { Utility.DebugLog(DebugMessageType.Warning, "ADDING NODE FAILED (" + args.Message[6] + ")"); } break; case Function.NodeRemove: nodeOperation = args.Message[5]; if (nodeOperation == (byte)NodeFunctionStatus.RemoveNodeRemovingSlave) { nodeOperationIdCheck = args.Message[6]; } else if (nodeOperation == (byte)NodeFunctionStatus.RemoveNodeDone) { if (nodeOperationIdCheck == args.Message[6]) { RemoveDevice(args.Message[6]); } OnControllerEvent(new ControllerEventArgs(0x00, ControllerStatus.DiscoveryEnd)); } else if (nodeOperation == (byte)NodeFunctionStatus.RemoveNodeFailed) { Utility.DebugLog(DebugMessageType.Warning, "REMOVING NODE FAILED (" + args.Message[6] + ")"); } break; case Function.ApplicationCommand: sourceNodeId = args.Message[5]; var node = devices.Find(n => n.Id == sourceNodeId); if (node != null) { try { node.MessageRequestHandler(args.Message); } catch (Exception ex) { Utility.DebugLog(DebugMessageType.Error, "Exception occurred in node.MessageRequestHandler: " + ex.Message + "\n" + ex.StackTrace); } } else { Utility.DebugLog(DebugMessageType.Error, "Unknown node id " + sourceNodeId); } break; case Function.SendData: byte commandId = args.Message[4]; if (commandId == 0x01) // SEND DATA OK { // TODO: ... what does that mean? } else if (args.Message[5] == 0x00) { // Messaging complete, remove callbackid zwavePort.PendingMessages.RemoveAll(zm => zm.CallbackId == commandId); } else if (args.Message[5] == 0x01) { var unsentMessage = zwavePort.PendingMessages.Find(zm => zm.CallbackId == commandId); byte nodeID = zwavePort.ResendLastMessage(commandId); if (nodeID != 0) { // Resend timed out OnControllerEvent(new ControllerEventArgs(nodeID, ControllerStatus.NodeError)); // Check if node supports WakeUp class, and add message to wake up message queue if (unsentMessage != null) { var sleepingNode = devices.Find(n => n.Id == nodeID); if (sleepingNode != null && sleepingNode.SupportCommandClass(CommandClass.WakeUp)) { WakeUp.ResendOnWakeUp(sleepingNode, unsentMessage.Message); } } } } break; case Function.NodeUpdateInfo: sourceNodeId = args.Message[5]; int nifLength = (int)args.Message[6]; var znode = devices.Find(n => n.Id == sourceNodeId); if (znode != null) { // we don't need to exclude the last 2 CommandClasses byte[] nodeInfo = new byte[nifLength]; Array.Copy(args.Message, 7, nodeInfo, 0, nifLength); znode.NodeInformationFrame = nodeInfo; if (znode.SupportCommandClass(CommandClass.Security)) { // ask the node what security command classes are supported Security.GetSupported(znode); } else { gotNodeUpdateInformation(znode); } } break; default: Utility.DebugLog(DebugMessageType.Warning, "Unhandled REQUEST " + Utility.ByteArrayToString(args.Message)); break; } break; case MessageType.Response: switch (function) { case Function.DiscoveryNodes: MessageResponseNodeBitMaskHandler(args.Message); break; case Function.GetNodeProtocolInfo: MessageResponseNodeCapabilityHandler(args.Message); break; case Function.RequestNodeInfo: // TODO: shall we do something here? break; case Function.SendData: // TODO: shall we do something here? break; default: Utility.DebugLog(DebugMessageType.Warning, "Unhandled RESPONSE " + Utility.ByteArrayToString(args.Message)); break; } break; default: Utility.DebugLog(DebugMessageType.Warning, "Unhandled MESSAGE TYPE " + Utility.ByteArrayToString(args.Message)); break; } break; } } catch (Exception ex) { Utility.DebugLog(DebugMessageType.Error, "Exception occurred :" + ex.Message + "\n" + ex.StackTrace); } }
public override bool CanHandleProduct(ManufacturerSpecific productspecs) { return (productspecs.ManufacturerId == "010F" && productspecs.TypeId == "0800" && productspecs.ProductId == "1001"); }
public string BuildCommand_TestCases(byte address, bool useCrc, bool useSecureChannel, ManufacturerSpecific manufacturerSpecific) { var manufacturerSpecificCommand = new ManufacturerSpecificCommand(address, manufacturerSpecific); return(BitConverter.ToString(manufacturerSpecificCommand.BuildCommand(new Device(address, useCrc, useSecureChannel)))); }
private void ZwaveMessageReceived(object sender, ZWaveMessageReceivedEventArgs args) { // discard repeated messages within last 2 seconds time range bool repeated = false; if (lastMessage != null) { var elapsed = (DateTime.UtcNow - lastMessageTimestamp); if (elapsed.TotalSeconds <= 2 && lastMessage.SequenceEqual(args.Message)) { repeated = true; } } lastMessageTimestamp = DateTime.UtcNow; lastMessage = new byte[args.Message.Length]; Buffer.BlockCopy(args.Message, 0, lastMessage, 0, args.Message.Length * sizeof(byte)); if (repeated) { zwavePort.SendAck(); Console.WriteLine("ZWaveLib: repeated message discarded."); return; } // int length = args.Message.Length; try { MessageHeader zwaveHeader = (MessageHeader)args.Message[0]; switch (zwaveHeader) { case MessageHeader.CAN: zwavePort.SendAck(); // RESEND //Console.WriteLine("ZWaveLib: received CAN, resending last message"); //zp.ResendLastMessage(); break; case MessageHeader.ACK: zwavePort.SendAck(); break; case MessageHeader.SOF: // start of zwave frame // // parse frame headers // //int msgLength = (int)args.Message[1]; var msgType = (MessageType)args.Message[2]; var function = (args.Message.Length > 3 ? (Function)args.Message[3] : 0); byte sourceNodeId = 0; byte nodeOperation = 0; // switch (msgType) { case MessageType.Request: zwavePort.SendAck(); if (devices.Count == 0) { break; } switch (function) { case Function.None: break; case Function.NodeAdd: nodeOperation = args.Message[5]; if (nodeOperation == (byte)NodeFunctionStatus.AddNodeAddingSlave) { //Console.WriteLine("\n\nADDING NODE SLAVE {0}\n -> ", zp.ByteArrayToString(args.Message)); nodeOperationIdCheck = args.Message[6]; var newNode = CreateDevice(nodeOperationIdCheck, 0x00); // Extract node information frame int nodeInfoLength = (int)args.Message[7]; byte[] nodeInfo = new byte[nodeInfoLength - 2]; Array.Copy(args.Message, 8, nodeInfo, 0, nodeInfoLength - 2); newNode.NodeInformationFrame = nodeInfo; RaiseUpdateParameterEvent(new ZWaveEvent(newNode, EventParameter.NodeInfo, Utility.ByteArrayToString(nodeInfo), 0)); SaveNodesConfig(); } else if (nodeOperation == (byte)NodeFunctionStatus.AddNodeProtocolDone /* || nodeOperation == (byte)NodeFunctionStatus.AddNodeDone */) { if (nodeOperationIdCheck == args.Message[6]) { //Console.WriteLine("\n\nADDING NODE DONE {0} {1}\n\n", args.Message[6], callbackid); Thread.Sleep(500); GetNodeCapabilities(args.Message[6]); var newNode = devices.Find(n => n.Id == args.Message[6]); if (newNode != null) { ManufacturerSpecific.Get(newNode); } } OnControllerEvent(new ControllerEventArgs(0x00, ControllerStatus.DiscoveryEnd)); } else if (nodeOperation == (byte)NodeFunctionStatus.AddNodeFailed) { //Console.WriteLine("\n\nADDING NODE FAIL {0}\n\n", args.Message[6]); } break; case Function.NodeRemove: nodeOperation = args.Message[5]; if (nodeOperation == (byte)NodeFunctionStatus.RemoveNodeRemovingSlave) { //Console.WriteLine("\n\nREMOVING NODE SLAVE {0}\n\n", args.Message[6]); nodeOperationIdCheck = args.Message[6]; } else if (nodeOperation == (byte)NodeFunctionStatus.RemoveNodeDone) { if (nodeOperationIdCheck == args.Message[6]) { //Console.WriteLine("\n\nREMOVING NODE DONE {0} {1}\n\n", args.Message[6], callbackid); RemoveDevice(args.Message[6]); } OnControllerEvent(new ControllerEventArgs(0x00, ControllerStatus.DiscoveryEnd)); } else if (nodeOperation == (byte)NodeFunctionStatus.RemoveNodeFailed) { //Console.WriteLine("\n\nREMOVING NODE FAIL {0}\n\n", args.Message[6]); } break; case Function.ApplicationCommand: sourceNodeId = args.Message[5]; var node = devices.Find(n => n.Id == sourceNodeId); if (node == null) { CreateDevice(sourceNodeId, 0x00); GetNodeCapabilities(sourceNodeId); } try { node.MessageRequestHandler(args.Message); } catch (Exception ex) { Console.WriteLine("# " + ex.Message + "\n" + ex.StackTrace); } break; case Function.SendData: byte commandId = args.Message[4]; if (commandId == 0x01) // SEND DATA OK { // TODO: ... what does that mean? } else if (args.Message[5] == 0x00) { // Messaging complete, remove callbackid zwavePort.PendingMessages.RemoveAll(zm => zm.CallbackId == commandId); } else if (args.Message[5] == 0x01) { var unsentMessage = zwavePort.PendingMessages.Find(zm => zm.CallbackId == commandId); byte nodeID = zwavePort.ResendLastMessage(commandId); if (nodeID != 0) { // Resend timed out OnControllerEvent(new ControllerEventArgs(nodeID, ControllerStatus.NodeError)); // Check if node supports WakeUp class, and add message to wake up message queue if (unsentMessage != null) { var sleepingNode = devices.Find(n => n.Id == nodeID); if (sleepingNode != null && sleepingNode.SupportCommandClass(CommandClass.WakeUp)) { WakeUp.ResendOnWakeUp(sleepingNode, unsentMessage.Message); } } } } break; case Function.NodeUpdateInfo: sourceNodeId = args.Message[5]; int nifLength = (int)args.Message[6]; var znode = devices.Find(n => n.Id == sourceNodeId); if (znode != null) { byte[] nodeInfo = new byte[nifLength - 2]; //Console.WriteLine(ByteArrayToString(args.Message)); Array.Copy(args.Message, 7, nodeInfo, 0, nifLength - 2); znode.NodeInformationFrame = nodeInfo; // RaiseUpdateParameterEvent(new ZWaveEvent(znode, EventParameter.NodeInfo, Utility.ByteArrayToString(nodeInfo), 0)); RaiseUpdateParameterEvent(new ZWaveEvent(znode, EventParameter.WakeUpNotify, "1", 0)); SaveNodesConfig(); } break; default: Console.WriteLine("\nUNHANDLED Z-Wave REQUEST\n " + Utility.ByteArrayToString(args.Message) + "\n"); break; } break; case MessageType.Response: switch (function) { case Function.DiscoveryNodes: MessageResponseNodeBitMaskHandler(args.Message); break; case Function.GetNodeProtocolInfo: MessageResponseNodeCapabilityHandler(args.Message); break; case Function.RequestNodeInfo: // TODO: shall we do something here? break; case Function.SendData: // TODO: shall we do something here? break; default: Console.WriteLine("\nUNHANDLED Z-Wave RESPONSE\n " + Utility.ByteArrayToString(args.Message) + "\n"); break; } break; default: Console.WriteLine("\nUNHANDLED Z-Wave message TYPE\n " + Utility.ByteArrayToString(args.Message) + "\n"); break; } break; } } catch (Exception ex) { Console.WriteLine(ex.Message + "\n" + ex.StackTrace); } }
/// <summary> /// Query capabilities, Supported Classes and Manufacturer Specific of each node. /// </summary> public void Discovery() { // Discovery can be a long time consuming operation, so we ensure // that only one instance of this is running if (!discoveryRunning) { discoveryRunning = true; OnDiscoveryProgress(new DiscoveryProgressEventArgs(DiscoveryStatus.DiscoveryStart)); foreach (ZWaveNode zn in nodeList) { Utility.logger.Trace("Querying/Updating node {0}", zn.Id); // Get Generic/Basic/Specific Class if not already cached if (zn.ProtocolInfo.BasicType == 0 && zn.ProtocolInfo.GenericType == 0 && zn.ProtocolInfo.SpecificType == 0) { GetNodeProtocolInfo(zn.Id); } // TODO: should check for SecureNodeInformationFrame as well?? // NIF, if cached just return the cached value if (zn.NodeInformationFrame.Length == 0) { GetNodeInformationFrame(zn.Id); } else { OnNodeUpdated(new NodeUpdatedEventArgs(zn.Id, new NodeEvent(zn, EventParameter.NodeInfo, BitConverter.ToString(zn.NodeInformationFrame).Replace("-", " "), 0))); } // For nodes that support version command class, query each one for its version. if (zn.SupportCommandClass(CommandClass.Version)) { // Compile a list of all of our command class IDs foreach (var cmdClass in zn.CommandClasses) { // if not cached query the node. if (cmdClass.Version == 0) { ZWaveLib.CommandClasses.Version.Get(zn, cmdClass.CommandClass).Wait(); } } } // Manufacturer Specific, if cached just return the cached value if (String.IsNullOrWhiteSpace(zn.ManufacturerSpecific.ManufacturerId)) { ManufacturerSpecific.Get(zn); } else { zn.OnNodeUpdated(new NodeEvent(zn, EventParameter.ManufacturerSpecific, zn.ManufacturerSpecific, 0)); } // Raise the node updated event UpdateOperationProgress(zn.Id, NodeQueryStatus.NodeUpdated); } SaveNodesConfig(); OnDiscoveryProgress(new DiscoveryProgressEventArgs(DiscoveryStatus.DiscoveryEnd)); discoveryRunning = false; } else { Utility.logger.Warn("Discovery already running"); } }
public virtual bool CanHandleProduct(ManufacturerSpecific productspecs) { return(false); // generic types must return false here }
private void ReceiveMessage(ZWaveMessage msg) { if (DupeMessageCheck(msg)) { Utility.logger.Warn("Repeated message discarded."); return; } var rawData = msg.RawData; switch (msg.Type) { case MessageType.Request: if (nodeList.Count == 0) { break; } switch (msg.Function) { case ZWaveFunction.NotSet: break; case ZWaveFunction.NodeAdd: var nodeAddStatus = NodeAddStatus.None; Enum.TryParse(rawData[5].ToString(), out nodeAddStatus); switch (nodeAddStatus) { case NodeAddStatus.LearnReady: UpdateOperationProgress(0x01, NodeQueryStatus.NodeAddReady); SetQueryStage(QueryStage.Complete); break; case NodeAddStatus.AddingSlave: var newNode = AddNode(rawData[6], 0x00); // Extract node information frame int nodeInfoLength = (int)rawData[7]; // we don't need to exclude the last 2 CommandClasses byte[] nodeInfo = new byte[nodeInfoLength]; Array.Copy(rawData, 8, nodeInfo, 0, nodeInfoLength); newNode.NodeInformationFrame = nodeInfo; newNode.ProtocolInfo.BasicType = rawData[8]; newNode.ProtocolInfo.GenericType = rawData[9]; newNode.ProtocolInfo.SpecificType = rawData[10]; nodeList.Add(newNode); UpdateOperationProgress(newNode.Id, NodeQueryStatus.NodeAddStarted); if (newNode.SupportCommandClass(CommandClass.Security)) { var nodeSecurityData = Security.GetSecurityData(newNode); nodeSecurityData.IsAddingNode = true; Security.GetScheme(newNode); } else { NodeInformationFrameDone(newNode); } break; case NodeAddStatus.ProtocolDone: GetNodeProtocolInfo(rawData[6]); var addedNode = GetNode(rawData[6]); if (addedNode != null) { ManufacturerSpecific.Get(addedNode); UpdateOperationProgress(addedNode.Id, NodeQueryStatus.NodeAddDone); } else { UpdateOperationProgress(rawData[6], NodeQueryStatus.NodeAddFailed); } SetQueryStage(QueryStage.Complete); break; case NodeAddStatus.Done: UpdateOperationProgress(0x01, NodeQueryStatus.NodeAddDone); SetQueryStage(QueryStage.Complete); break; case NodeAddStatus.Failed: UpdateOperationProgress(rawData[6], NodeQueryStatus.NodeAddFailed); SetQueryStage(QueryStage.Complete); break; } break; case ZWaveFunction.NodeRemove: var nodeRemoveStatus = NodeRemoveStatus.None; Enum.TryParse(rawData[5].ToString(), out nodeRemoveStatus); switch (nodeRemoveStatus) { case NodeRemoveStatus.LearnReady: UpdateOperationProgress(0x01, NodeQueryStatus.NodeRemoveReady); SetQueryStage(QueryStage.Complete); break; case NodeRemoveStatus.RemovingSlave: UpdateOperationProgress(rawData[6], NodeQueryStatus.NodeRemoveStarted); break; case NodeRemoveStatus.Done: if (rawData[6] != 0x00) { RemoveNode(rawData[6]); } UpdateOperationProgress(rawData[6], NodeQueryStatus.NodeRemoveDone); SetQueryStage(QueryStage.Complete); break; case NodeRemoveStatus.Failed: UpdateOperationProgress(rawData[6], NodeQueryStatus.NodeRemoveFailed); SetQueryStage(QueryStage.Complete); break; } break; case ZWaveFunction.RequestNodeNeighborsUpdateOptions: case ZWaveFunction.RequestNodeNeighborsUpdate: var neighborUpdateStatus = NeighborsUpdateStatus.None; Enum.TryParse(rawData[5].ToString(), out neighborUpdateStatus); switch (neighborUpdateStatus) { case NeighborsUpdateStatus.NeighborsUpdateStared: UpdateOperationProgress(msg.NodeId, NodeQueryStatus.NeighborUpdateStarted); break; case NeighborsUpdateStatus.NeighborsUpdateDone: UpdateOperationProgress(msg.NodeId, NodeQueryStatus.NeighborUpdateDone); //GetNeighborsRoutingInfo(msg.NodeId); SetQueryStage(QueryStage.Complete); break; case NeighborsUpdateStatus.NeighborsUpdateFailed: UpdateOperationProgress(msg.NodeId, NodeQueryStatus.NeighborUpdateFailed); SetQueryStage(QueryStage.Complete); break; default: Utility.logger.Warn("Unhandled Node Neighbor Update request: {0}", BitConverter.ToString(rawData)); break; } break; case ZWaveFunction.SendData: byte callbackId = rawData[4]; if (callbackId == 0x01) // 0x01 is "SEND DATA OK" { // TODO: ... is there anything to be done here? } else { switch (msg.CallbackStatus) { case CallbackStatus.Ack: //System.Diagnostics.Debugger.Break(); break; case CallbackStatus.Nack: //System.Diagnostics.Debugger.Break(); break; } } break; case ZWaveFunction.ApplicationCommandHandler: var node = GetNode(rawData[5]); if (node != null) { try { node.ApplicationCommandHandler(rawData); } catch (Exception ex) { Utility.logger.Error(ex); } } else { Utility.logger.Error("Unknown node id {0}", rawData[5]); } break; case ZWaveFunction.ApplicationUpdate: int nifLength = (int)rawData[6]; var znode = GetNode(rawData[5]); if (znode != null) { // we don't need to exclude the last 2 CommandClasses byte[] nodeInfo = new byte[nifLength]; Array.Copy(rawData, 7, nodeInfo, 0, nifLength); znode.NodeInformationFrame = nodeInfo; if (znode.SupportCommandClass(CommandClass.Security)) { // ask the node what security command classes are supported Security.GetSupported(znode); } else { NodeInformationFrameDone(znode); SetQueryStage(QueryStage.Complete); } } else { SetQueryStage(QueryStage.Error); } break; default: Utility.logger.Warn("Unhandled request message: {0}", BitConverter.ToString(rawData)); break; } break; case MessageType.Response: switch (msg.Function) { case ZWaveFunction.GetInitData: InitializeNodes(rawData); SetQueryStage(QueryStage.Complete); break; case ZWaveFunction.GetNodeProtocolInfo: var node = GetNode(msg.NodeId); node.ProtocolInfo.BasicType = rawData[7]; node.ProtocolInfo.GenericType = rawData[8]; node.ProtocolInfo.SpecificType = rawData[9]; break; case ZWaveFunction.RequestNodeInfo: SetQueryStage(QueryStage.SendDataReady); break; case ZWaveFunction.SendData: // TODO: shall we do something here? break; case ZWaveFunction.GetRoutingInfo: var routingInfo = Utility.ExtractRoutingFromBitMask(rawData); if (routingInfo.Length > 0) { var routedNode = GetNode(msg.NodeId); if (routedNode != null) { routedNode.UpdateData("RoutingInfo", routingInfo); routedNode.OnNodeUpdated(new NodeEvent(routedNode, EventParameter.RoutingInfo, String.Join(" ", routingInfo), 0)); } } else { Utility.logger.Warn("No routing nodes reported."); } break; default: Utility.logger.Warn("Unhandled response message: {0}", BitConverter.ToString(rawData)); break; } break; default: Utility.logger.Warn("Unhandled message type: {0}", BitConverter.ToString(rawData)); break; } }
// Z-Wave.Me thermostat // 0115:0024:0001 public override bool CanHandleProduct(ManufacturerSpecific productspecs) { return(productspecs.ManufacturerId == "0115" && productspecs.TypeId == "0024" && productspecs.ProductId == "0001"); }
public virtual bool MessageRequestHandler(byte[] receivedMessage) { //Console.WriteLine("\n _z_ [" + this.NodeId + "] " + (this.DeviceHandler != null ? this.DeviceHandler.ToString() : "!" + this.GenericClass.ToString())); //Console.WriteLine(" >>> " + zp.ByteArrayToString(receivedMessage) + "\n"); ZWaveEvent messageEvent = null; int messageLength = receivedMessage.Length; if (messageLength > 8) { //byte commandLength = receivedMessage[6]; byte commandClass = receivedMessage[7]; switch (commandClass) { case (byte)CommandClass.Basic: messageEvent = Basic.GetEvent(this, receivedMessage); break; case (byte)CommandClass.Alarm: messageEvent = Alarm.GetEvent(this, receivedMessage); break; case (byte)CommandClass.SensorAlarm: messageEvent = SensorAlarm.GetEvent(this, receivedMessage); break; case (byte)CommandClass.SceneActivation: messageEvent = SceneActivation.GetEvent(this, receivedMessage); break; case (byte)CommandClass.SwitchBinary: messageEvent = SwitchBinary.GetEvent(this, receivedMessage); break; case (byte)CommandClass.SwitchMultilevel: messageEvent = SwitchMultilevel.GetEvent(this, receivedMessage); break; case (byte)CommandClass.SensorBinary: messageEvent = SensorBinary.GetEvent(this, receivedMessage); break; case (byte)CommandClass.SensorMultilevel: messageEvent = SensorMultilevel.GetEvent(this, receivedMessage); break; case (byte)CommandClass.Meter: messageEvent = Meter.GetEvent(this, receivedMessage); break; case (byte)CommandClass.ThermostatMode: case (byte)CommandClass.ThermostatFanMode: case (byte)CommandClass.ThermostatFanState: case (byte)CommandClass.ThermostatHeating: case (byte)CommandClass.ThermostatOperatingState: case (byte)CommandClass.ThermostatSetBack: case (byte)CommandClass.ThermostatSetPoint: messageEvent = Thermostat.GetEvent(this, receivedMessage); break; case (byte)CommandClass.UserCode: messageEvent = UserCode.GetEvent(this, receivedMessage); break; case (byte)CommandClass.Association: messageEvent = Association.GetEvent(this, receivedMessage); break; case (byte)CommandClass.Configuration: messageEvent = Configuration.GetEvent(this, receivedMessage); break; case (byte)CommandClass.WakeUp: messageEvent = WakeUp.GetEvent(this, receivedMessage); break; case (byte)CommandClass.Battery: messageEvent = Battery.GetEvent(this, receivedMessage); break; case (byte)CommandClass.Hail: Basic.Get(this); break; case (byte)CommandClass.MultiInstance: messageEvent = MultiInstance.GetEvent(this, receivedMessage); break; case (byte)CommandClass.ManufacturerSpecific: messageEvent = ManufacturerSpecific.GetEvent(this, receivedMessage); if (messageEvent != null) { var specs = (ManufacturerSpecificInfo)messageEvent.Value; this.ManufacturerId = specs.ManufacturerId; this.TypeId = specs.TypeId; this.ProductId = specs.ProductId; if (ManufacturerSpecificResponse != null) { try { ManufacturerSpecificResponse(this, new ManufacturerSpecificResponseEventArg() { NodeId = this.NodeId, ManufacturerSpecific = specs }); } catch (Exception ex) { Console.WriteLine("ZWaveLib: Error during ManufacturerSpecificResponse callback, " + ex.Message + "\n" + ex.StackTrace); } } } break; } } if (messageEvent != null) { this.RaiseUpdateParameterEvent(messageEvent.Instance, messageEvent.Event, messageEvent.Value); } else if (messageLength > 3) { if (receivedMessage[3] != 0x13) { bool log = true; if (messageLength > 7 && /* cmd_class */ receivedMessage[7] == (byte)CommandClass.ManufacturerSpecific) { log = false; } if (log) { Console.WriteLine("ZWaveLib UNHANDLED message: " + Utility.ByteArrayToString(receivedMessage)); } } } return(false); }