iapplicationlayer.cs

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

        private byte status;
        private byte id;
    }
    /// <summary>
    /// 
    /// </summary>
    public class NodeFailedEventArgs : EventArgs
    {
        /// <summary>
        /// 
        /// </summary>
        /// <param name="status"></param>
        public NodeFailedEventArgs(byte status, bool returnValue)
        {
            this.status = status;
            this.returnValue = returnValue;
        }

        /// <summary>
        /// 
        /// </summary>
        public byte Status
        {
            get { return status; }
        }
        private byte status;

        private bool returnValue;
        /// <summary>
        /// Gets a value indicating whether [return value].
        /// </summary>
        /// <value><c>true</c> if [return value]; otherwise, <c>false</c>.</value>
        public bool ReturnValue
        {
            get { return returnValue; }
        }
        

    }
    /// <summary>
    /// 
    /// </summary>
    public class SlaveEventArgs : EventArgs
    {
        /// <summary>
        /// 
        /// </summary>
        /// <param name="status"></param>
        /// <param name="orgId"></param>
        /// <param name="newId"></param>
        public SlaveEventArgs(byte status, byte orgId, byte newId)
        {
            this.status = status;
            this.orgId = orgId;
            this.newId = newId;
        }

        /// <summary>
        /// 
        /// </summary>
        public byte Status
        {
            get { return status; }
        }

        /// <summary>
        /// 
        /// </summary>
        public byte OriginalId
        {
            get { return orgId; }
        }

        /// <summary>
        /// 
        /// </summary>
        public byte NewId
        {
            get { return newId; }
        }
        private byte status;
        private byte orgId;
        private byte newId;
    }
    /// <summary>
    /// 
    /// </summary>
    public class TestEventArgs : EventArgs
    {
        /// <summary>
        /// 
        /// </summary>
        /// <param name="testCommand"></param>
        /// <param name="state"></param>
        /// <param name="nodeId"></param>
        /// <param name="status"></param>
        /// <param name="testCounter"></param>
        public TestEventArgs(byte testCommand, byte state, byte nodeId, byte status, uint testCounter)
        {
            this.testCommand = testCommand;
            this.state = state;
            this.nodeId = nodeId;
            this.status = status;
            this.testCounter = testCounter;
        }

        /// <summary>
        /// 
        /// </summary>
        public byte GetCommand
        {
            get { return testCommand; }
        }

        /// <summary>
        /// 
        /// </summary>
        public byte GetState
        {
            get { return state; }
        }

        /// <summary>
        /// 
        /// </summary>
        public byte NodeId
        {
            get { return nodeId; }
        }

        /// <summary>
        /// 
        /// </summary>
        public byte Status
        {
            get { return status; }
        }
        private byte testCommand, state, nodeId, status;
        private uint testCounter;
    }
    /// <summary>
    /// IApplicationLayer Interface
    /// </summary>
    public interface IApplicationLayer
    {
        /// <summary>
        /// Configure and connect the Applicationlayer to a ZWave module
        /// </summary>
        /// <param name="transportLayerLibrary">Name of transportLayer</param>
        /// <param name="connectionString">String used to pass connection information to transportLayer</param>
        void Open(String transportLayerLibrary, String connectionString);
        /// <summary>
        /// Close the connection to the transportLayerLibrary
        /// </summary>
        void Close();

        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        ISessionLayer GetSessionLayer { get;}
        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        IFrameLayer GetFrameLayer();
        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        ITransportLayer GetTransportLayer { get;}

        /// <summary>
        /// Returns statistics about the communication
        /// </summary>
        /// <returns>Read/write/error statistics</returns>
        ZWStatistics GetStatistics();
        /// <summary>
        /// Event which will be fired when Application frames are received from other modules
        /// </summary>
        event EventHandler<ApplicationCommandEventArgs> ApplicationCommandEvent;
        /// <summary>
        /// Event which will be fired when Application frames for virtual slaves are received from other modules
        /// </summary>
        event EventHandler<ApplicationSlaveCommandEventArgs> ApplicationSlaveCommandEvent;
        /// <summary>
        /// If a unknown command is received from the Module this event is fired
        /// </summary>
        event EventHandler<UnknownCommandEventArgs> UnknownCommandEvent;
        /// <summary>
        /// This event is called when adding nodes
        /// </summary>
        event EventHandler<AddNodeEventArgs> AddNodeEvent;
        /// <summary>
        /// This event is fired when deleting nodes
        /// </summary>
        event EventHandler<RemoveNodeEventArgs> RemoveNodeEvent;
        /// <summary>
        /// This event is fired when requesting nodeinformation
        /// </summary>
        event EventHandler<RequestNodeInfoEventArgs> RequestNodeInfoEvent;
        /// <summary>
        /// Event which will be fired when Network Updates are received.
        /// </summary>
        event EventHandler<UpdateEventArgs> UpdateEvent;
        /// <summary>
        /// 
        /// </summary>
        event EventHandler<NodeFailedEventArgs> NodeFailedEvent;
        /// <summary>
        /// 
        /// </summary>
        event EventHandler<SlaveEventArgs> SlaveEvent;
        /// <summary>
        /// 
        /// </summary>
        event EventHandler<TestEventArgs> TestEvent;
        /// <summary>
        /// Update the capabilities and return a list of nodes as read from the ZWave module
        /// </summary>
        /// <returns>List of nodes</returns>
        Node[] EnumerateNodes();
        /// <summary>
        /// Returns a copy of the node list stored in the DLL (does not read from ZWave module)
        /// </summary>
        /// <returns>Copy of node list</returns>
        Node[] GetAllNodes();
        /// <summary>
        /// Reads the devicetype from the ZWave module
        /// </summary>
        /// <param name="nodeId">Node ID to get info for</param>
        /// <returns></returns>
        Node ZWaveGetNodeProtocolInfo(byte nodeId);
        /// <summary>
        /// Gets the node capabilities from the ZWave.dll list (does not read from ZWave module)
        /// </summary>
        /// <param name="nodeId">nodeID</param>
        /// <returns>null if unkown ZWNode if it exist locally</returns>
        Node GetNode(byte nodeId);

        /// <summary>
        /// Simply check if the node Id is in the ZWave.dll copy of the nodetable
        /// </summary>
        /// <param name="id">id to look for</param>
        /// <returns>true if it exist false if not</returns>
        bool IsNodePresent(byte id);
        /// <summary>
        /// Returns the numeber of nodes in the ZWave.dll copy of the nodetable.
        /// </summary>
        /// <returns>number of nodes</returns>
        //int GetNodeCount();
        int GetNodeCount { get; }
        /// <summary>
        /// Return the ZWave Chiptype
        /// </summary>
        /// <returns>The ChipType</returns>
        ChipType ChipType();
        /// <summary>
        /// Returns the ZWave Chip revision
        /// </summary>
        /// <returns>revision</returns>
        byte ChipRev();
        /// <summary>
        /// Returns the ZWave SerialAPI version
        /// </summary>
        /// <returns></returns>
        byte SerialApiVersion();

        /// <summary>
        /// Returns the library type and version used on the ZWaveModule
        /// </summary>
        /// <returns>Type and version</returns>
        VersionInfoType ZWaveVersion();
        /// <summary>
        /// Transmit a frame to the node ID specified. If 0xFF is specified the frame is broadcasted
        /// </summary>
        /// <param name="nodeId">Destination node</param>
        /// <param name="data">payload to send</param>
        /// <param name="txOptions">Transmit options (TRANSMIT_OPTION_xxx)</param>
        /// <param name="timeout">Response timeout in ms</param>
        /// <returns>Transmit Result</returns>
        TXStatus ZWaveSendData(byte nodeId, byte[] data, TXOption txOptions, int timeout);
        /// <summary>
        /// 
        /// </summary>
        /// <param name="nodeId"></param>
        /// <param name="data"></param>
        /// <param name="txOptions"></param>
        /// <returns></returns>
        TXStatus ZWaveSendData(byte nodeId, byte[] data, TXOption txOptions);
        /// <summary>
        /// Transmit a frame to the node ID specified. If 0xFF is specified the frame is broadcasted
        /// </summary>
        /// <param name="sourceId">Source node</param>
        /// <param name="destinationId">Destination node</param>
        /// <param name="data">payload to send</param>
        /// <param name="txOptions">Transmit options (TRANSMIT_OPTION_xxx)</param>
        /// <param name="timeout">Response timeout in ms</param>
        /// <returns>Transmit Result</returns>
        TXStatus ZWaveSendSlaveData(byte sourceId, byte destinationId, byte[] data, TXOption txOptions, int timeout);

        /// <summary>
        /// Z-wave rediscovery needed.
        /// </summary>
        /// <param name="nodeId">The node id.</param>
        /// <returns></returns>
        ZWaveRediscoveryNeededReturnValue ZWaveRediscoveryNeeded(byte nodeId);
        /// <summary>
        /// 
        /// </summary>
        /// <param name="sourceId"></param>
        /// <param name="destinationId"></param>
        /// <param name="data"></param>
        /// <param name="txOptions"></param>
        /// <returns></returns>
        TXStatus ZWaveSendSlaveData(byte sourceId, byte destinationId, byte[] data, TXOption txOptions);
        /// <summary>
        /// Transmit a frame to the node IDs specified. If 0xFF is specified the frame is broadcasted
        /// </summary>
        /// <param name="nodeIdList">list of nodes to send to</param>
        /// <param name="data">payload to send</param>
        /// <param name="txOptions">if TRANSMIT_OPTION_ACK is specified each node gets a singlecast</param>
        /// <returns>Transmit Result</returns>
        TXStatus ZWaveSendDataMulti(ArrayList nodeIdList, byte[] data, TXOption txOptions);
        /// <summary>
        /// Transmit a frame to the node ID specified. If 0xFF is specified the frame is broadcasted
        /// </summary>
        /// <param name="nodeId">Destination node</param>
        /// <param name="data">payload to send</param>
        /// <param name="txOptions">Transmit options (TRANSMIT_OPTION_xxx)</param>
        /// <param name="timeout">Response timeout in ms</param>
        /// <returns>Transmit Result</returns>
        TXStatus ZWaveSendDataMeta(byte nodeId, byte[] data, TXOption txOptions, int timeout);
        /// <summary>
        /// Transmita meta data frame to nodeID.
        /// </summary>
        /// <param name="nodeId"></param>
        /// <param name="data"></param>
        /// <param name="txOptions"></param>
        /// <returns></returns>
        TXStatus ZWaveSendDataMeta(byte nodeId, byte[] data, TXOption txOptions);
        /// <summary>
        /// Abort application initiated transmissions started by calling ZWaveSendData
        /// </summary>
        void ZWaveSendDataAbort();

        /// <summary>
        /// Enable Add node function
        /// </summary>
        /// <param name="mode">SLAVE/CONTROLLER/ANY</param>
        /// <returns></returns>
        NodeStatus ZWaveAddNodeToNetwork(Mode mode);
        /// <summary>
        /// Enable this controller to hand over its primary status
        /// </summary>
        /// <param name="mode">ControllerChangeMode START/STOP/FAILED</param>
        /// <returns>Add node state</returns>
        NodeStatus ZWaveControllerChange(ControllerChangeMode mode);
        /// <summary>
        /// Enable this controller to create a new primary. Only valid for SUC
        /// </summary>