applicationlayer.cs

来自「zwave 无线通讯协议 PC controller 控制器源码」· CS 代码 · 共 1,676 行 · 第 1/5 页

                nodeTable.clear();

                ZWaveMemoryGetId(out _controllerHomeId, out _controllerNodeId);

                NodeMask virtualNodeMask = ZWaveGetVirtualNodes();
                byte nodeIdx = 0;
                for (int i = 0; i < len; i++)
                {
                    byte availabilityMask = payload[3 + i];
                    for (byte bit = 0; bit < 8; bit++)
                    {
                        nodeIdx++;
                        if ((availabilityMask & (1 << bit)) > 0)
                        {
                            Node node = ZWaveGetNodeProtocolInfo(nodeIdx, false);
                            node.IsVirtual = virtualNodeMask.Get(nodeIdx);
                            nodeTable.add(node);
                        }
                    }
                }
                return nodeTable.getList();
            }
        }

        /// <summary>
        /// Get number of nodes in nodeTable
        /// </summary>
        /// <returns></returns>
        //   public int GetNodeCount()
        //  {
        //    return nodeTable.size();
        //  }
        public int GetNodeCount
        {
            get
            {
                return nodeTable.size();
            }
        }

        /// <summary>
        /// Remove Node from the nodeTable
        /// </summary>
        /// <param name="id"></param>
        public void NodeRemove(byte id)
        {
            nodeTable.remove(id);
        }

        /// <summary>
        /// Find out if node exist in nodeTable
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public bool IsNodePresent(byte id)
        {
            return nodeTable.contains(id);
        }

        /// <summary>
        /// Get a specific node from nodeTable
        /// </summary>
        /// <param name="nodeId"></param>
        /// <returns>node id</returns>
        public Node GetNode(byte nodeId)
        {
            if (!nodeTable.contains((int)nodeId))
                return null;
            else
                return nodeTable.get(nodeId);
        }

        /// <summary>
        /// Get All nodes from the nodeTable
        /// </summary>
        /// <returns></returns>
        public Node[] GetAllNodes()
        {
            return nodeTable.getList();
        }

        /// <summary>
        /// Capabilities flag:
        /// Bit 0: 0 = Controller API; 1 = Slave API
        /// Bit 1: 0 = Timer functions not supported; 1 = Timer functions supported.
        /// Bit 2: 0 = Primary Controller; 1 = Secondary Controller
        /// Bit 3-7: reserved   
        /// </summary>
        /// <returns></returns>
        public byte[] ZWaveGetControllerCapabilities(out bool slaveController)
        {
            DataPacket res;
            DataPacket req = new DataPacket();

            TXStatus rc = sessionLayer.RequestWithResponse(DataFrame.CommandType.CmdZWaveGetControllerCapabilities, req, out res);
            if (rc != TXStatus.CompleteOk) throw new ApplicationLayerException("CMD_ZWaveGET_CONTROLLER_CAPABILITIES");
            byte[] payload = res.GetPayload();
            ctrlCapabilities = payload;
            slaveController = ((payload[0] & (byte)CtrlCapabilities.IS_SECONDARY) != 0);
            return payload;
        }


        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        public byte[] ZWaveSerialApiGetCapabilities()
        {
            DataPacket res;
            DataPacket req = new DataPacket();

            TXStatus rc = sessionLayer.RequestWithResponse(DataFrame.CommandType.CmdSerialApiGetCapabilities, req, out res);
            if (rc != TXStatus.CompleteOk) throw new ApplicationLayerException("CMD_SERIAL_API_GET_CAPABILITIES");
            byte[] payload = res.GetPayload();
            ctrlCapabilities = payload;
            if (ctrlCapabilities.Length > 8)
            {
                serialCapabilityMask = new NodeBitmask();
                byte[] temp = new byte[ctrlCapabilities.Length - 8];
                for (int n = 0; n < temp.Length; n++)
                {
                    temp[n] = ctrlCapabilities[n + 8];
                }
                serialCapabilityMask.Store(temp);
            }
            return payload;
        }
        /// <summary>
        /// Checks if a given byte command ID is supported by embedded moule
        /// </summary>
        /// <param name="CommandId">id number to check</param>
        /// <returns>true if supported, false if not</returns>
        public bool IsSupportedSerialCmd(byte CommandId)
        {
            return serialCapabilityMask.ZWaveNodeMaskNodeIn(CommandId);
        }
        /// <summary>
        /// Returns a comma separated string which contains a list of commands supported by Embedded module
        /// Commands unhandled by ZWave.DLL are returned as the command number (Base 10)
        /// </summary>
        /// <returns>String of enumaration names</returns>
        public string ZWaveSupportedSerialCmds()
        {
            string retString = null;
            /* ctrlCapabilities format:
             *0 APPL_VERSION,1 APPL_REVISION,2 MAN_ID1, 3MAN_ID2, 
             *4 PRODUCT_TYPE1, 5 PRODUCT_TYPE2, 6 PRODUCT_ID1,7 PRODUCT_ID2, 8 FUNCID_SUPPORTED...*/
            if (serialCapabilityMask != null)
            {
                int i = 1;
                while (i < serialCapabilityMask.Length * 8)
                {
                    if (serialCapabilityMask.ZWaveNodeMaskNodeIn((byte)i))
                    {
                        retString += ((DataFrame.CommandType)i).ToString() + ",";
                    }
                    i++;
                }
            }
            return retString;
        }


        /// <summary>
        /// 
        /// </summary>
        public byte[] ZWaveSerialApiSetTimeout(byte acknowledgeTimeout, byte timeout)
        {
            DataPacket res;
            DataPacket req = new DataPacket();

            req.AddPayload(acknowledgeTimeout);
            req.AddPayload(timeout);
            TXStatus rc = sessionLayer.RequestWithResponse(DataFrame.CommandType.CmdSerialApiSetTimeouts, req, out res);
            if (rc != TXStatus.CompleteOk)
                throw new ApplicationLayerException("CMD_SERIAL_API_SET_TIMEOUTS");
            // Get the payload as it contains the old ackTimeout and byteTimeout which previously was present in the ZW module
            byte[] payload = res.GetPayload();
            return payload;
        }

        /// <summary>
        /// ZWaveSerialAPISoftReset()
        /// </summary>
        public void ZWaveSerialApiSoftReset()
        {
            DataPacket res;
            DataPacket req = new DataPacket();
            TXStatus rc = sessionLayer.RequestWithResponse(DataFrame.CommandType.CmdSerialApiSoftReset, req, out res, true);
            if (rc != TXStatus.CompleteOk) throw new ApplicationLayerException("CMD_SERIAL_API_SOFT_RESET");
        }


        /// <summary>
        /// Get Library version of the module
        /// </summary>
        /// <returns>version</returns>
        public VersionInfoType ZWaveVersion()
        {
            DataPacket res;
            DataPacket req = new DataPacket();

            TXStatus rc = sessionLayer.RequestWithResponse(DataFrame.CommandType.CmdZWaveGetVersion, req, out res);
            if (rc != TXStatus.CompleteOk) return libraryType;// throw new ApplicationLayerException("CmdZWaveGetVersion");  

            try
            {
                libraryType = new VersionInfoType();
            }
            catch
            { }

            System.Text.UTF7Encoding utf = new System.Text.UTF7Encoding();
            byte[] payload = res.GetPayload();
            libraryType.ver = utf.GetString(payload, 6, 6);
            if (libraryType.ver.EndsWith("\0"))
            {
                libraryType.ver = libraryType.ver.Remove(libraryType.ver.Length - 1, 1);
            }
            libraryType.lib = (Library)payload[12];

            return libraryType;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="nodeIdList"></param>
        /// <param name="data"></param>
        /// <param name="txOptions"></param>
        /// <returns></returns>
        public TXStatus ZWaveSendDataMulti(ArrayList nodeIdList, byte[] data, TXOption txOptions)
        {
            if (nodeIdList == null || data == null)
            {
                throw new ArgumentNullException("nodeIdList");
            }
            DataPacket[] res = new DataPacket[2];
            DataPacket req = new DataPacket();

            req.AddPayload((byte)nodeIdList.Count);
            req.AddPayload((byte[])nodeIdList.ToArray(typeof(byte)));
            req.AddPayload((byte)data.Length);
            req.AddPayload(data);
            req.AddPayload((byte)txOptions);
            TXStatus rc = sessionLayer.RequestWithMultipleResponses(DataFrame.CommandType.CmdZWaveSendDataMulti, req, ref res, true);
            if (rc == TXStatus.CompleteOk)
            {
                return (TXStatus)res[1].GetPayload()[0];
            }
            else
            {
                return rc;
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="nodeId"></param>
        /// <param name="data"></param>
        /// <param name="txOptions"></param>
        /// <returns></returns>
        public TXStatus ZWaveSendData(byte nodeId, byte[] data, TXOption txOptions)
        {
            if (data == null)
            {
                throw new ArgumentNullException("data");
            }
            return ZWaveSendData(nodeId, data, txOptions, TIMEOUT);
        }

        /// <summary>
        /// Zs the wave rediscovery needed.
        /// </summary>
        /// <param name="nodeId">The node id.</param>
        /// <returns></returns>
        public ZWaveRediscoveryNeededReturnValue ZWaveRediscoveryNeeded(byte nodeId)
        {
            DataPacket[] res = new DataPacket[3]; // We are receiving 2 responses...
            DataPacket req = new DataPacket();
            req.AddPayload(nodeId);
            TXStatus rc = sessionLayer.RequestWithVariableResponses(DataFrame.CommandType.CmdZWaveRediscoveryNeeded, req, ref res, new byte[] { 1, 4 }, true, 60000);
            ZWaveRediscoveryNeededReturnValue st = (ZWaveRediscoveryNeededReturnValue)res[1].GetPayload()[0];
            if (rc == TXStatus.CompleteOk)
            {
                if (st == ZWaveRediscoveryNeededReturnValue.LostAccepted)
                {
                    return (ZWaveRediscoveryNeededReturnValue)res[2].GetPayload()[0];
                }
                else
                {
                    return st;
                }

            }
            else
            {
                return ZWaveRediscoveryNeededReturnValue.LostFailed;
            }

        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="nodeId"></param>
        /// <param name="data"></param>
        /// <param name="txOptions"></param>
        /// <param name="timeout"></param>
        /// <returns></returns>
        public TXStatus ZWaveSendData(byte nodeId, byte[] data, TXOption txOptions, int timeout)
        {
            if (data == null)
            {
                throw new ArgumentNullException("data");
            }

            DataPacket[] res = new DataPacket[2]; // We are receiving 2 responses...
            DataPacket req = new DataPacket();
            req.AddPayload(nodeId);
            req.AddPayload((byte)data.Length);
            req.AddPayload(data);
            req.AddPayload((byte)txOptions);
            TXStatus rc = sessionLayer.RequestWithMultipleResponses(DataFrame.CommandType.CmdZWaveSendData, req, ref res, true, timeout);
            if (rc == TXStatus.CompleteOk)
            {
                return (TXStatus)res[1].GetPayload()[0];
            }
            else
            {
                return rc;
            }
        }

        /// <summary>