iapplicationlayer.cs

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

        /// <param name="mode">START/STOP/FAILED</param>
        /// <returns></returns>
        NodeStatus ZWaveCreateNewPrimaryCtrl(CreateNewPrimaryControllerMode mode);
        /// <summary>
        /// Force the controller to assign SUC/SIS routes 
        /// </summary>
        /// <param name="destinationNodeId"></param>
        /// <returns></returns>
        TXStatus ZWaveAssignSucReturnRoute(byte destinationNodeId);
        /// <summary>
        /// Assigns Return routes to a routing slave
        /// </summary>
        /// <param name="sourceNodeId">Node to receive the routes</param>
        /// <param name="destinationNodeId">destination of the route</param>
        /// <returns></returns>
        TXStatus ZWaveAssignReturnRoute(byte sourceNodeId, byte destinationNodeId);
        /// <summary>
        /// Deletes the return routes assigned to a Routing Node
        /// </summary>
        /// <param name="sourceNodeId">Node to delete routes for</param>
        /// <returns></returns>
        TXStatus ZWaveDeleteReturnRoute(byte sourceNodeId);
        /// <summary>
        /// Deletes the SUC return routes on a routing slave
        /// </summary>
        /// <param name="sourceNodeId">Node to delete SUC return routes</param>
        /// <returns></returns>
        TXStatus ZWaveDeleteSucReturnRoute(byte sourceNodeId);
        /// <summary>
        /// Transmits the SUC node ID to the node specified
        /// </summary>
        /// <param name="nodeId">Destination node</param>
        /// <param name="txOptions">Option</param>
        /// <returns>Transmit status</returns>
        TXStatus ZWaveSendSucId(byte nodeId, TXOption txOptions);
        /// <summary>
        /// Enables SUC for this node
        /// </summary>
        /// <param name="enable">true/false</param>
        /// <param name="capabilities"></param>
        /// <returns>true if success false if not</returns>
        bool ZWaveEnableSuc(bool enable, byte capabilities);
        /// <summary>
        /// Check if a node ID is registered as failed
        /// </summary>
        /// <param name="nodeId"></param>
        /// <returns>true/false</returns>
        bool ZWaveIsFailedNode(byte nodeId);
        /// <summary>
        /// Get the home and node ID of this controller
        /// </summary>
        /// <param name="homeId"></param>
        /// <param name="controllerNode"></param>
        /// <returns></returns>
        TXStatus ZWaveMemoryGetId(out Int32 homeId, out byte controllerNode);
        /// <summary>
        /// Stores the specified buffer in ZWaveModule Nonvolatile memory
        /// </summary>
        /// <param name="offset">Application offset start address</param>
        /// <param name="buffer">Buffer to write</param>
        /// <param name="length">number of bytes to write</param>
        void ZWaveMemoryPutBuffer(uint offset, byte[] buffer, uint length);
        /// <summary>
        /// Store the specified byte at the offset adress specified
        /// </summary>
        /// <param name="offset">adress</param>
        /// <param name="value">value to write</param>
        /// <returns></returns>
        TXStatus ZWaveMemoryPutByte(uint offset, byte value);
        /// <summary>
        /// Reads the number of bytes from ZWaveModule nonvolatile memory
        /// </summary>
        /// <param name="offset">Start offset adress</param>
        /// <param name="len">number of bytes to read</param>
        /// <returns>array of read values</returns>
        byte[] ZWaveMemoryGetBuffer(uint offset, byte len);
        /// <summary>
        /// Reads the byte located at the ofset specified
        /// </summary>
        /// <param name="offset"></param>
        /// <returns></returns>
        byte ZWaveMemoryGetByte(uint offset);

        /// <summary>
        /// Enables controller to remove nodes from the network
        /// </summary>
        /// <param name="mode">SLAVE/CONTROLLER/ANY/STOP</param>
        /// <returns>status</returns>
        NodeStatus ZWaveRemoveNodeFromNetwork(Mode mode);
        /// <summary>
        /// Only used during replication to transfer application information. See programming guide
        /// </summary>
        /// <param name="nodeId">destination</param>
        /// <param name="data">payload</param>
        /// <param name="txOptions">transmit options</param>
        /// <returns></returns>
        TXStatus ZWaveReplicationSend(byte nodeId, byte[] data, TXOption txOptions);
        /// <summary>
        /// Request network update from the SUC/SIS 
        /// </summary>
        /// <returns></returns>
        TXStatus ZWaveRequestNetworkUpdate();
        /// <summary>
        /// Request nodeinformation frame from nodeId
        /// </summary>
        /// <param name="nodeId"></param>
        /// <returns></returns>
        TXStatus ZWaveRequestNodeInfo(byte nodeId);
        /// <summary>
        /// Request that a node updates its neighbours
        /// </summary>
        /// <param name="nodeId"></param>
        /// <returns></returns>
        RequestNeighbor ZWaveRequestNodeNeighborUpdate(byte nodeId);
        /// <summary>
        /// Send out this device Node information Frame
        /// </summary>
        /// <param name="destination">Destination node</param>
        /// <param name="txOptions"></param>
        /// <returns></returns>
        TXStatus ZWaveSendNodeInformation(byte destination, TXOption txOptions);
        /// <summary>
        /// Reset all protocol data back to factory default (incl home and nodeID)
        /// </summary>
        void ZWaveSetDefault();
        /// <summary>
        /// Enable/disabl this device to be added to or removed from a network
        /// </summary>
        /// <param name="learnMode"></param>
        /// <returns></returns>
        bool ZWaveSetLearnMode(bool learnMode);
        /// <summary>
        /// Used when a Static controller wants to become SUC itself.
        /// </summary>
        /// <param name="sucState">true become SUC, false disable SUC</param>
        /// <param name="capabilities"></param>
        /// <param name="suc">Status</param>
        /// <returns></returns>
        bool ZWaveSetSelfAsSuc(bool sucState, byte capabilities, out byte suc);
        /// <summary>
        /// Assign or remove SUC on another controller in the network
        /// </summary>
        /// <param name="nodeId">Destination node</param>
        /// <param name="sucState"></param>
        /// <param name="txOptions"></param>
        /// <param name="capabilities"></param>
        /// <returns></returns>
        bool ZWaveSetSucNodeId(byte nodeId, bool sucState, TXOption txOptions, byte capabilities);
        /// <summary>
        /// Get the controller capabilities/ current configuration
        /// </summary>
        /// <param name="slaveController"></param>
        /// <returns></returns>
        byte[] ZWaveGetControllerCapabilities(out bool slaveController);
        /// <summary>
        /// Get the Capabilities of the ZWave module serialAPI (supported functions)
        /// </summary>
        /// <returns>bitmask of supported capabilities</returns>
        byte[] ZWaveSerialApiGetCapabilities();

        /// <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>
        string ZWaveSupportedSerialCmds();

        /// <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>
        bool IsSupportedSerialCmd(byte CommandId);

        /// <summary>
        /// Set the Serial communication timeouts in 10ms
        /// </summary>
        /// <param name="acknowledgeTimeout">Timeout in 10ms waiting for ACK</param>
        /// <param name="timeout">Timeout in 10ms waiting for another byte in frame</param>
        /// <returns></returns>
        byte[] ZWaveSerialApiSetTimeout(byte acknowledgeTimeout, byte timeout);
        /// <summary>
        /// Make Z-Wave module do a software reset
        /// </summary>
        void ZWaveSerialApiSoftReset();
        /// <summary>
        /// Get the nodeId of the node that is currently assigned SUC or SIS 0 if none 
        /// </summary>
        /// <returns></returns>
        byte ZWaveGetSucNodeId();
        /// <summary>
        /// Request the ZWave module to remove a failing node from the network
        /// </summary>
        /// <param name="nodeId">nodeId to remove</param>
        /// <returns>status</returns>
        DataPacket[] ZWaveRemoveFailedNodeId(byte nodeId);
        /// <summary>
        /// Request teh ZWave module to replace a failing node in the network
        /// </summary>
        /// <param name="nodeId">node Id to try and replace</param>
        /// <returns></returns>
        bool ZWaveReplaceFailedNode(byte nodeId);
        /// <summary>
        /// Enable or disable RF on the ZWave module.
        /// </summary>
        /// <param name="mode"></param>
        void ZWaveSetRFReceiveMode(byte mode);
        /// <summary>
        /// 
        /// </summary>
        /// <param name="powerLevel"></param>
        /// <returns>The RF powerlevel set</returns>
        byte ZWaveRFPowerLevelSet(byte powerLevel);
        /// <summary>
        /// Lock a response route to the nodeId supplied
        /// </summary>
        /// <param name="nodeId"></param>
        void ZWaveLockRoutes(byte nodeId);
        /// <summary>
        /// Sends a command complete. This should be used as a response to ReplicationSend
        /// </summary>
        void ZWaveReplicationReceiveComplete();
        /// <summary>
        /// Setup this nodes Nodeinformation
        /// </summary>
        /// <param name="listening"></param>
        /// <param name="generic">Generic devicetype</param>
        /// <param name="specific">Specific devicetype</param>
        /// <param name="nodeParameter">Supported commandclasses</param>
        void ZWaveSetNodeInformation(byte listening, byte generic, byte specific, byte[] nodeParameter);
        /// <summary>
        /// Disables the learn mode
        /// </summary>
        void ZWaveStopLearnMode();
        /// <summary>
        /// Returns true if a SIS is available
        /// </summary>
        bool NodeIdServerPresent { get;}
        /// <summary>
        /// 
        /// </summary>
        bool ControllerIsRealPrimary { get;}
        /// <summary>
        /// 
        /// </summary>
        bool ControllerIsSis { get;}
        /// <summary>
        /// 
        /// </summary>
        bool ControllerOnOtherNetwork { get;}
        /// <summary>
        /// 
        /// </summary>
        bool ControllerIsSuc { get;}
        /// <summary>
        /// 
        /// </summary>
        bool IsRealTimeSystem { get;}
        /// <summary>
        /// 
        /// </summary>
        Library LibraryType { get;}
        /// <summary>
        /// 
        /// </summary>
        String LibraryVersion { get; }

        /// <summary>
        /// Gets the node list.
        /// </summary>
        /// <value>The node list.</value>
        Node[] NodeList { get; }


        #region ZWaveINSTALLER
        /// <summary>
        /// Store the HomeId on the Controller in the external EEPROM
        /// Only available on Installer ZWave modules
        /// </summary>
        /// <param name="homeId">four byte array with the homeId in</param>
        /// <param name="nodeId"></param>
        bool ZWaveStoreHomeId(Int32 homeId, byte nodeId);
        /// <summary>
        /// Stores the nodeinformation for a specific node
        /// Only available on Installer ZWave modules
        /// </summary>
        /// <param name="nodeId">nodeId</param>
        /// <param name="nodeInfo">NodeInfo</param>
        /// <returns></returns>
        TXStatus ZWaveStoreNodeInfo(byte nodeId, Node nodeInfo);

        #endregion

        #region ZWaveBRIDGE
        /// <summary>
        /// ZWaveSendSlaveNodeInformation with timeout
        /// </summary>
        /// <param name="sourceId"></param>
        /// <param name="destinationId"></param>
        /// <param name="txOptions"></param>
        /// <param name="timeout"></param>
        /// <returns></returns>
        TXStatus ZWaveSendSlaveNodeInformation(byte sourceId, byte destinationId, TXOption txOptions, int timeout);
        /// <summary>
        /// ZWaveSendSlaveNodeInformation 
        /// </summary>
        /// <param name="sourceId"></param>
        /// <param name="destinationId"></param>
        /// <param name="txOptions"></param>
        /// <returns></returns>
        TXStatus ZWaveSendSlaveNodeInformation(byte sourceId, byte destinationId, TXOption txOptions);
        /// <summary>
        /// ZWaveSetSlaveLearnMode(byte node, byte mode)
        /// </summary>
        /// <param name="node"></param>
        /// <param name="mode"></param>
        /// <returns></returns>
        bool ZWaveSetSlaveLearnMode(byte node, byte mode);
        /// <summary>
        /// ZWaveSetSlaveNodeInformation(byte nodeID, byte listening, byte generic, byte specific, byte[] nodeParm)
        /// </summary>
        /// <param name="nodeId"></param>
        /// <param name="listening"></param>
        /// <param name="generic"></param>
        /// <param name="specific"></param>
        /// <param name="nodeParameter"></param>
        void ZWaveSetSlaveNodeInformation(byte nodeId, byte listening, byte generic, byte specific, byte[] nodeParameter);
        /// <summary>
        /// ZWaveIsVirtualNode(byte nodeID)
        /// </summary>
        /// <param name="nodeId"></param>
        /// <returns></returns>
        bool ZWaveIsVirtualNode(byte nodeId);
        #endregion ZWaveBRIDGE
        #region ZWaveINSTALLER
        /// <summary>
        /// enable / disable the installe lib promiscuous mode
        /// </summary>
        /// <param name="enable"></param>
        /// <returns></returns>
        bool ZWaveSetPromiscuousMode(bool enable);
        #endregion

        #region ERTT
        /// <summary>
        /// 
        /// </summary>
        /// <param name="testCmd"></param>
        /// <param name="testDelay"></param>
        /// <param name="testPayloadLength"></param>
        /// <param name="testCount"></param>
        /// <param name="testTXOptions"></param>
        /// <param name="maxLength"></param>
        /// <param name="testNodeMask"></param>
        /// <returns></returns>
        byte ZWaveTest(byte testCmd, ushort testDelay, byte testPayloadLength, int testCount, TXOption testTXOptions, byte maxLength, byte[] testNodeMask);
        #endregion ERTT
    }
}