applicationlayer.cs

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

        /// 
        /// </summary>
        /// <param name="nodeId"></param>
        /// <param name="data"></param>
        /// <param name="txOptions"></param>
        /// <returns></returns>
        public TXStatus ZWaveSendDataMeta(byte nodeId, byte[] data, TXOption txOptions)
        {
            return ZWaveSendDataMeta(nodeId, data, txOptions, TIMEOUT);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="nodeId"></param>
        /// <param name="data"></param>
        /// <param name="txOptions"></param>
        /// <param name="timeout"></param>
        /// <returns></returns>
        public TXStatus ZWaveSendDataMeta(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.CmdZWaveSendDataMeta, req, ref res, true, timeout);
            if (rc != TXStatus.CompleteOk)
            {
                return rc;
            }
            return (TXStatus)res[1].GetPayload()[0];
        }



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


        /// <summary>
        /// Get the neighbors of the specified node
        /// </summary>
        /// <param name="nodeId">node id</param>
        /// <returns></returns>
        public RequestNeighbor ZWaveRequestNodeNeighborUpdate(byte nodeId)
        {
            DataPacket[] res = new DataPacket[2];
            DataPacket req = new DataPacket();
            req.AddPayload(nodeId);
            TXStatus rc = sessionLayer.RequestWithMultipleResponses(DataFrame.CommandType.CmdZWaveRequestNodeNeighborUpdate, req, ref res, true);

            if (rc == TXStatus.CompleteOk)
            {
                return (RequestNeighbor)res[1].GetPayload()[0];
            }
            else
            {
                return RequestNeighbor.UpdateFailed;
            }
        }

        /// <summary>
        /// This function request network update from the SUC
        /// </summary>
        /// <returns>Returns: TRUE - SUC is known to this controller, FALSE - SUC unknown</returns>
        public TXStatus ZWaveRequestNetworkUpdate()
        {
            DataPacket[] res = new DataPacket[2];
            DataPacket req = new DataPacket();
            TXStatus rc = sessionLayer.RequestWithMultipleResponses(DataFrame.CommandType.CmdZWaveRequestNetworkUpdate, req, ref res, true, TIMEOUT);
            if (rc == TXStatus.CompleteOk)
            {
                return (TXStatus)res[1].GetPayload()[0];
            }
            else
            {
                return rc;
            }
        }


        /// <summary>
        /// 
        /// </summary>
        /// <param name="nodeId"></param>
        /// <returns></returns>
        public TXStatus ZWaveRequestNodeInfo(byte nodeId)
        {
            DataPacket res;
            DataPacket req = new DataPacket();
            req.AddPayload(nodeId);
            TXStatus rc = sessionLayer.RequestWithResponse(DataFrame.CommandType.CmdZWaveRequestNodeInfo, req, out res, false);
            if (rc == TXStatus.CompleteOk)
            {
                _requestNodeInfo = true;
                TimerCallback wft = new TimerCallback(this.waitForNodeInfocallbackHandler);
                waitForNodeInfoTimer = new System.Threading.Timer(wft, this, TIMEOUT, System.Threading.Timeout.Infinite);
            }
            return rc;
        }


        private void waitForNodeInfocallbackHandler(object handler)
        {
            if (waitForNodeInfoTimer != null)
            {
                waitForNodeInfoTimer.Dispose();
            }
            _requestNodeInfo = false;
            RequestNodeInfoEventArgs e = new RequestNodeInfoEventArgs((Node)handler);
            // if (RequestNodeInfoEvent != null) RequestNodeInfoEvent((Node)handler);
            if (RequestNodeInfoEvent != null) RequestNodeInfoEvent(this, e);
        }

        /// <summary>
        /// Delete all static return routes from a Routing Slave node or Enhanced Slave node. 
        /// </summary>
        /// <param name="sourceNodeId">source node id</param>
        /// <returns></returns>
        public TXStatus ZWaveDeleteReturnRoute(byte sourceNodeId)
        {
            DataPacket[] res = new DataPacket[2];
            DataPacket req = new DataPacket();
            req.AddPayload(sourceNodeId);
            TXStatus rc = sessionLayer.RequestWithMultipleResponses(DataFrame.CommandType.CmdZWaveDeleteReturnRoute, req, ref res, true);
            if (rc == TXStatus.CompleteOk)
            {
                return (TXStatus)res[1].GetPayload()[0];
            }
            else
            {
                return rc;
            }
        }

        /// <summary>
        /// Used to assign a route between a routing slave and the SUC node. This route is 
        /// used when routing slave want to get routes updates from the SUC node.
        /// </summary>
        /// <param name="destinationNodeId">source nodeId</param>
        /// <returns>transmit status</returns>
        public TXStatus ZWaveAssignSucReturnRoute(byte destinationNodeId)
        {
            DataPacket[] res = new DataPacket[2];
            DataPacket req = new DataPacket();
            req.AddPayload(destinationNodeId);
            req.AddPayload(0);
            TXStatus rc = sessionLayer.RequestWithMultipleResponses(DataFrame.CommandType.CmdZWaveAssignSucReturnRoute, req, ref res, true);
            if (rc == TXStatus.CompleteOk)
            {
                return (TXStatus)res[1].GetPayload()[0];
            }
            else
            {
                return rc;
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="sourceNodeId"></param>
        /// <param name="destinationNodeId"></param>
        /// <returns></returns>
        public TXStatus ZWaveAssignReturnRoute(byte sourceNodeId, byte destinationNodeId)
        {
            DataPacket[] res = new DataPacket[2];
            DataPacket req = new DataPacket();
            req.AddPayload(sourceNodeId);
            req.AddPayload(destinationNodeId);
            TXStatus rc = sessionLayer.RequestWithMultipleResponses(DataFrame.CommandType.CmdZWaveAssignReturnRoute, req, ref res, true);
            if (rc == TXStatus.CompleteOk)
            {
                return (TXStatus)res[1].GetPayload()[0];
            }
            else
            {
                return rc;
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="sourceNodeId"></param>
        /// <returns></returns>
        public TXStatus ZWaveDeleteSucReturnRoute(byte sourceNodeId)
        {
            DataPacket[] res = new DataPacket[2];
            DataPacket req = new DataPacket();
            req.AddPayload(sourceNodeId);
            TXStatus rc = sessionLayer.RequestWithMultipleResponses(DataFrame.CommandType.CmdZWaveDeleteSucReturnRoute, req, ref res, true);
            if (rc == TXStatus.CompleteOk)
            {
                return (TXStatus)res[1].GetPayload()[0];
            }
            else
            {
                return rc;
            }
        }

        /// <summary>
        /// Used when the controller is in replication mode. It sends the payload and 
        /// expects the receiver to respond with a command complete message 
        /// (ZWaveREPLICATION_COMMAND_COMPLETE). Messages sent using this command should always 
        /// be part of the Z-Wave controller replication command class.
        /// </summary>
        /// <param name="nodeId"></param>
        /// <param name="data"></param>
        /// <param name="txOptions"></param>
        /// <returns></returns>
        public TXStatus ZWaveReplicationSend(byte nodeId, byte[] data, TXOption txOptions)
        {
            if (data == null)
            {
                throw new ArgumentNullException("data");
            }
            DataPacket[] res = new DataPacket[2];
            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.CmdZWaveReplicationSendData, req, ref res, true);
            if (rc == TXStatus.CompleteOk)
            {
                return (TXStatus)res[1].GetPayload()[0];
            }
            else
            {
                return rc;
            }
        }


        /// <summary>
        /// If the controller is primary it is possible to set itself as SUC using this function
        /// </summary>
        /// <param name="sucState">true if this should be SUC false if not</param>
        /// <param name="capabilities">true if succesfull false if not</param>
        /// <param name="suc"></param>
        /// <returns></returns>
        public bool ZWaveSetSelfAsSuc(bool sucState, byte capabilities, out byte suc)
        {
            suc = 0;
            if (SlaveController) return false;

            ZWaveMemoryGetId(out _controllerHomeId, out _controllerNodeId);
            if (_controllerNodeId == 0) return false;

            if (ZWaveSetSucNodeId(_controllerNodeId, sucState, 0, capabilities))
            {
                suc = _controllerNodeId;
                return true;
            }
            return false;
        }

        /// <summary>
        /// Enable/ Disable the SUC functionality
        /// </summary>
        /// <param name="enable"></param>
        /// <param name="capabilities"></param>
        /// <returns>if SUC is avaliable it returns 1 otherwise if not available it returns 0</returns>
        public bool ZWaveEnableSuc(bool enable, byte capabilities)
        {
            DataPacket res;
            DataPacket req = new DataPacket();
            req.AddPayload(Convert.ToByte(enable));
            req.AddPayload(capabilities);
            TXStatus rc = sessionLayer.RequestWithResponse(DataFrame.CommandType.CmdZWaveEnableSuc, req, out res);
            if (rc == TXStatus.CompleteOk)
            {
                if (res.GetPayload()[0] != 0)
                {
                    return true;
                }
            }

            return false;
        }

        private bool ThisSUCNodeId(byte nodeId, bool sucState, TXOption txOptions, byte capabilities)
        {
            DataPacket res;
            DataPacket req = AddPayloadToSUCNodeId(nodeId, sucState, txOptions, capabilities);
            TXStatus rc = sessionLayer.RequestWithResponse(DataFrame.CommandType.CmdZWaveSetSucNodeId, req, out res);
            if ((rc == TXStatus.CompleteOk) && ((nodeId == _controllerNodeId) || ((res.Length >= 1) && (res.GetPayload()[0] == (byte)SetSucReturnValue.SucSetSucceeded))))
            {
                return true;
            }
            else
            {
                return false;
            }
        }


        private bool OtherSUCNodeId(byte nodeId, bool sucState, TXOption txOptions, byte capabilities)
        {
            DataPacket[] res = new DataPacket[2];
            DataPacket req = AddPayloadToSUCNodeId(nodeId, sucState, txOptions, capabilities);
            TXStatus rc = sessionLayer.RequestWithMultipleResponses(DataFrame.CommandType.CmdZWaveSetSucNodeId, req, ref res, true);
            if ((rc == TXStatus.CompleteOk))
            {
                if (((res[1].Length >= 1) && (res[1].GetPayload()[0] == (byte)SetSucReturnValue.SucSetSucceeded)))
                {
                    return true;
                }
            }
            return false;
        }

        private DataPacket AddPayloadToSUCNodeId(byte nodeId, bool sucState, TXOption txOptions, byte capabilities)
        {
            DataPacket req = new DataPacket();
            req.AddPayload(nodeId);
            req.AddPayload(Convert.ToByte(sucState));
            req.AddPayload((byte)txOptions);
            req.AddPayload(capabilities);
            return req;