// Compilation export flags
#if (defined _WINDOWS || defined WIN32 || defined _MSC_VER) && !defined MINGW
# if defined OPENZWAVE_MAKEDLL // Create the dynamic library.
# define OPENZWAVE_EXPORT __declspec(dllexport)
# elif defined OPENZWAVE_USEDLL // Use the dynamic library
# define OPENZWAVE_EXPORT __declspec(dllimport)
# else // Create/Use the static library
# define OPENZWAVE_EXPORT
# endif
// Disable export warnings
# define OPENZWAVE_EXPORT_WARNINGS_OFF __pragma( warning(push) )\
__pragma( warning(disable: 4251) ) \
__pragma( warning(disable: 4275) )
# define OPENZWAVE_EXPORT_WARNINGS_ON __pragma( warning(pop) )
#else
# define OPENZWAVE_EXPORT
# define OPENZWAVE_EXPORT_WARNINGS_OFF
# define OPENZWAVE_EXPORT_WARNINGS_ON
#endif
#ifdef __GNUC__
#define DEPRECATED __attribute__((deprecated))
#elif defined(_MSC_VER)
#define DEPRECATED __declspec(deprecated)
#else
#pragma message("WARNING: You need to implement DEPRECATED for this compiler")
#define DEPRECATED
#endif
#ifdef NULL
#undef NULL
#endif
#define NULL 0
// Basic types
typedef signed char int8;
typedef unsigned char uint8;
typedef signed short int16;
typedef unsigned short uint16;
typedef signed int int32;
typedef unsigned int uint32;
#ifdef _MSC_VER
typedef signed __int64 int64;
typedef unsigned __int64 uint64;
#endif
#ifdef __GNUC__
typedef signed long long int64;
typedef unsigned long long uint64;
#endif
typedef float float32;
typedef double float64;
typedef struct ozwversion {
uint32_t _v; /* major << 16 | minor */
} ozwversion;
/**
* \brief version_major - return the major version of the given struct
* \param v: the version number to obtain the major number from
* \return the Major Version Number
*/
static inline uint16_t version_major(struct ozwversion v) {
return (v._v & 0xFFFF0000) >> 16;
}
/**
* \brief version_minor - return the minor version of the given struct
* \param v: the version number to obtain the minor number from
* \return the Minor Version Number
*/
static inline uint16_t version_minor(const struct ozwversion &v) {
return v._v & 0xFFFF;
}
/**
* \brief version - create a new version number
* \param major: major version number
* \param minor: minor version number
* \return the Version Number Struct
*/
static inline struct ozwversion version(uint16_t major, uint16_t minor)
{
struct ozwversion v;
v._v = (uint32_t)(major << 16) | (uint32_t)minor;
return v;
}
/**
* \brief version_cmp - compare two versions
* \param a: the first version number
* \param b: the second version number
* \return a number greater, equal, or less than 0 if a is greater, equal or
* less than b, respectively
*
* Example:
* struct version a = version(1, 0);
* struct version b = version(1, 3);
* if (version_cmp(a, b) < 0)
* printf("b is smaller than b\n");
*/
static inline int version_cmp(struct ozwversion a, struct ozwversion b)
{
return (a._v == b._v) ? 0 : (a._v > b._v) ? 1 : - 1;
}
#include "OZWException.h"
#define OPENZWAVE_DISABLE_EXCEPTIONS
#if defined(_MSC_VER)
# define __MYFUNCTION__ __FUNCTION__
#else
# define __MYFUNCTION__ __FILE__
#endif
// Exceptions : define OPENZWAVE_DISABLE_EXCEPTIONS in compiler flags to enable exceptions instead of exit function
#ifndef OPENZWAVE_DISABLE_EXCEPTIONS
# define OZW_FATAL_ERROR(exitCode, msg) Log::Write( LogLevel_Error,"Exception: %s:%d - %d - %s", std::string(__MYFUNCTION__).substr(std::string(__MYFUNCTION__).find_last_of("/\\") + 1).c_str(), __LINE__, exitCode, msg); \
throw OZWException(__MYFUNCTION__, __LINE__, exitCode, msg)
# define OZW_ERROR(exitCode, msg) Log::Write( LogLevel_Warning,"Exception: %s:%d - %d - %s", std::string(__MYFUNCTION__).substr(std::string(__MYFUNCTION__).find_last_of("/\\") + 1).c_str(), __LINE__, exitCode, msg); \
throw OZWException(__MYFUNCTION__, __LINE__, exitCode, msg)
#else
# define OZW_FATAL_ERROR(exitCode, msg) Log::Write( LogLevel_Error,"Exception: %s:%d - %d - %s", std::string(__MYFUNCTION__).substr(std::string(__MYFUNCTION__).find_last_of("/\\") + 1).c_str(), __LINE__, exitCode, msg); \
std::cerr << "Error: "<< std::string(__MYFUNCTION__).substr(std::string(__MYFUNCTION__).find_last_of("/\\") + 1) << ":" << __LINE__ << " - " << msg << std::endl; exit(exitCode)
# define OZW_ERROR(exitCode, msg) Log::Write( LogLevel_Warning,"Exception: %s:%d - %d - %s", std::string(__MYFUNCTION__).substr(std::string(__MYFUNCTION__).find_last_of("/\\") + 1).c_str(), __LINE__, exitCode, msg);
#endif
// Declare the OpenZWave namespace
namespace std {}
namespace OpenZWave
{
// Include the STL namespace
using namespace std;
}
// Modifications for Microsoft compilers
#ifdef _MSC_VER
// Fix for namespace-related compiler bug
namespace OpenZWave
{
}
// Rename safe versions of sprintf etc
#define snprintf sprintf_s
#define strcasecmp _stricmp
#define sscanf sscanf_s
#endif
// Modifications for MiNGW32 compiler
#ifdef MINGW
// Replace "safe" versions of sprintf
#define sprintf_s snprintf
// seems some MINGW versions don't have a errno_t
#ifndef errno_t
#define errno_t int
#endif
#define fopen_s fopen
#endif
//#define MAX_TRIES 3 // Retry sends up to 3 times
#define MAX_TRIES 1 // set this to one, as I believe now that a ACK failure is indication that the device is offline, hence additional attempts will not work.
#define MAX_MAX_TRIES 7 // Don't exceed this retry limit
#define ACK_TIMEOUT 1000 // How long to wait for an ACK
#define BYTE_TIMEOUT 150
//#define RETRY_TIMEOUT 40000 // Retry send after 40 seconds
#define RETRY_TIMEOUT 10000 // Retry send after 10 seconds (we might need to keep this below 10 for Security CC to function correctly)
#define SOF 0x01
#define ACK 0x06
#define NAK 0x15
#define CAN 0x18
#define NUM_NODE_BITFIELD_BYTES 29 // 29 bytes = 232 bits, one for each possible node in the network.
#define REQUEST 0x00
#define RESPONSE 0x01
#define ZW_CLOCK_SET 0x30
#define TRANSMIT_OPTION_ACK 0x01
#define TRANSMIT_OPTION_LOW_POWER 0x02
#define TRANSMIT_OPTION_AUTO_ROUTE 0x04
#define TRANSMIT_OPTION_NO_ROUTE 0x10
#define TRANSMIT_OPTION_EXPLORE 0x20
#define TRANSMIT_COMPLETE_OK 0x00
#define TRANSMIT_COMPLETE_NO_ACK 0x01
#define TRANSMIT_COMPLETE_FAIL 0x02
#define TRANSMIT_COMPLETE_NOT_IDLE 0x03
#define TRANSMIT_COMPLETE_NOROUTE 0x04
#define RECEIVE_STATUS_ROUTED_BUSY 0x01
#define RECEIVE_STATUS_TYPE_BROAD 0x04
#define FUNC_ID_SERIAL_API_GET_INIT_DATA 0x02
#define FUNC_ID_SERIAL_API_APPL_NODE_INFORMATION 0x03
#define FUNC_ID_APPLICATION_COMMAND_HANDLER 0x04
#define FUNC_ID_ZW_GET_CONTROLLER_CAPABILITIES 0x05
#define FUNC_ID_SERIAL_API_SET_TIMEOUTS 0x06
#define FUNC_ID_SERIAL_API_GET_CAPABILITIES 0x07
#define FUNC_ID_SERIAL_API_SOFT_RESET 0x08
#define FUNC_ID_ZW_SEND_NODE_INFORMATION 0x12
#define FUNC_ID_ZW_SEND_DATA 0x13
#define FUNC_ID_ZW_GET_VERSION 0x15
#define FUNC_ID_ZW_R_F_POWER_LEVEL_SET 0x17
#define FUNC_ID_ZW_GET_RANDOM 0x1c
#define FUNC_ID_ZW_MEMORY_GET_ID 0x20
#define FUNC_ID_MEMORY_GET_BYTE 0x21
#define FUNC_ID_ZW_READ_MEMORY 0x23
#define FUNC_ID_ZW_SET_LEARN_NODE_STATE 0x40 // Not implemented
#define FUNC_ID_ZW_GET_NODE_PROTOCOL_INFO 0x41 // Get protocol info (baud rate, listening, etc.) for a given node
#define FUNC_ID_ZW_SET_DEFAULT 0x42 // Reset controller and node info to default (original) values
#define FUNC_ID_ZW_NEW_CONTROLLER 0x43 // Not implemented
#define FUNC_ID_ZW_REPLICATION_COMMAND_COMPLETE 0x44 // Replication send data complete
#define FUNC_ID_ZW_REPLICATION_SEND_DATA 0x45 // Replication send data
#define FUNC_ID_ZW_ASSIGN_RETURN_ROUTE 0x46 // Assign a return route from the specified node to the controller
#define FUNC_ID_ZW_DELETE_RETURN_ROUTE 0x47 // Delete all return routes from the specified node
#define FUNC_ID_ZW_REQUEST_NODE_NEIGHBOR_UPDATE 0x48 // Ask the specified node to update its neighbors (then read them from the controller)
#define FUNC_ID_ZW_APPLICATION_UPDATE 0x49 // Get a list of supported (and controller) command classes
#define FUNC_ID_ZW_ADD_NODE_TO_NETWORK 0x4a // Control the addnode (or addcontroller) process...start, stop, etc.
#define FUNC_ID_ZW_REMOVE_NODE_FROM_NETWORK 0x4b // Control the removenode (or removecontroller) process...start, stop, etc.
#define FUNC_ID_ZW_CREATE_NEW_PRIMARY 0x4c // Control the createnewprimary process...start, stop, etc.
#define FUNC_ID_ZW_CONTROLLER_CHANGE 0x4d // Control the transferprimary process...start, stop, etc.
#define FUNC_ID_ZW_SET_LEARN_MODE 0x50 // Put a controller into learn mode for replication/ receipt of configuration info
#define FUNC_ID_ZW_ASSIGN_SUC_RETURN_ROUTE 0x51 // Assign a return route to the SUC
#define FUNC_ID_ZW_ENABLE_SUC 0x52 // Make a controller a Static Update Controller
#define FUNC_ID_ZW_REQUEST_NETWORK_UPDATE 0x53 // Network update for a SUC(?)
#define FUNC_ID_ZW_SET_SUC_NODE_ID 0x54 // Identify a Static Update Controller node id
#define FUNC_ID_ZW_DELETE_SUC_RETURN_ROUTE 0x55 // Remove return routes to the SUC
#define FUNC_ID_ZW_GET_SUC_NODE_ID 0x56 // Try to retrieve a Static Update Controller node id (zero if no SUC present)
#define FUNC_ID_ZW_REQUEST_NODE_NEIGHBOR_UPDATE_OPTIONS 0x5a // Allow options for request node neighbor update
#define FUNC_ID_ZW_EXPLORE_REQUEST_INCLUSION 0x5e // supports NWI
#define FUNC_ID_ZW_REQUEST_NODE_INFO 0x60 // Get info (supported command classes) for the specified node
#define FUNC_ID_ZW_REMOVE_FAILED_NODE_ID 0x61 // Mark a specified node id as failed
#define FUNC_ID_ZW_IS_FAILED_NODE_ID 0x62 // Check to see if a specified node has failed
#define FUNC_ID_ZW_REPLACE_FAILED_NODE 0x63 // Remove a failed node from the controller's list (?)
#define FUNC_ID_ZW_GET_ROUTING_INFO 0x80 // Get a specified node's neighbor information from the controller
#define FUNC_ID_SERIAL_API_SLAVE_NODE_INFO 0xA0 // Set application virtual slave node information
#define FUNC_ID_APPLICATION_SLAVE_COMMAND_HANDLER 0xA1 // Slave command handler
#define FUNC_ID_ZW_SEND_SLAVE_NODE_INFO 0xA2 // Send a slave node information frame
#define FUNC_ID_ZW_SEND_SLAVE_DATA 0xA3 // Send data from slave
#define FUNC_ID_ZW_SET_SLAVE_LEARN_MODE 0xA4 // Enter slave learn mode
#define FUNC_ID_ZW_GET_VIRTUAL_NODES 0xA5 // Return all virtual nodes
#define FUNC_ID_ZW_IS_VIRTUAL_NODE 0xA6 // Virtual node test
#define FUNC_ID_ZW_SET_PROMISCUOUS_MODE 0xD0 // Set controller into promiscuous mode to listen to all frames
#define FUNC_ID_PROMISCUOUS_APPLICATION_COMMAND_HANDLER 0xD1
#define ADD_NODE_ANY 0x01
#define ADD_NODE_CONTROLLER 0x02
#define ADD_NODE_SLAVE 0x03
#define ADD_NODE_EXISTING 0x04
#define ADD_NODE_STOP 0x05
#define ADD_NODE_STOP_FAILED 0x06
#define ADD_NODE_STATUS_LEARN_READY 0x01
#define ADD_NODE_STATUS_NODE_FOUND 0x02
#define ADD_NODE_STATUS_ADDING_SLAVE 0x03
#define ADD_NODE_STATUS_ADDING_CONTROLLER 0x04
#define ADD_NODE_STATUS_PROTOCOL_DONE 0x05
#define ADD_NODE_STATUS_DONE 0x06
#define ADD_NODE_STATUS_FAILED 0x07
#define REMOVE_NODE_ANY 0x01
#define REMOVE_NODE_CONTROLLER 0x02
#define REMOVE_NODE_SLAVE 0x03
#define REMOVE_NODE_STOP 0x05
#define REMOVE_NODE_STATUS_LEARN_READY 0x01
#define REMOVE_NODE_STATUS_NODE_FOUND 0x02
#define REMOVE_NODE_STATUS_REMOVING_SLAVE 0x03
#define REMOVE_NODE_STATUS_REMOVING_CONTROLLER 0x04
#define REMOVE_NODE_STATUS_DONE 0x06
#define REMOVE_NODE_STATUS_FAILED 0x07
#define CREATE_PRIMARY_START 0x02
#define CREATE_PRIMARY_STOP 0x05
#define CREATE_PRIMARY_STOP_FAILED 0x06
#define CONTROLLER_CHANGE_START 0x02
#define CONTROLLER_CHANGE_STOP 0x05
#define CONTROLLER_CHANGE_STOP_FAILED 0x06
#define LEARN_MODE_STARTED 0x01
#define LEARN_MODE_DONE 0x06
#define LEARN_MODE_FAILED 0x07
#define LEARN_MODE_DELETED 0x80
#define REQUEST_NEIGHBOR_UPDATE_STARTED 0x21
#define REQUEST_NEIGHBOR_UPDATE_DONE 0x22
#define REQUEST_NEIGHBOR_UPDATE_FAILED 0x23
#define FAILED_NODE_OK 0x00
#define FAILED_NODE_REMOVED 0x01
#define FAILED_NODE_NOT_REMOVED 0x02
#define FAILED_NODE_REPLACE_WAITING 0x03
#define FAILED_NODE_REPLACE_DONE 0x04
#define FAILED_NODE_REPLACE_FAILED 0x05
#define FAILED_NODE_REMOVE_STARTED 0x00
#define FAILED_NODE_NOT_PRIMARY_CONTROLLER 0x02
#define FAILED_NODE_NO_CALLBACK_FUNCTION 0x04
#define FAILED_NODE_NOT_FOUND 0x08
#define FAILED_NODE_REMOVE_PROCESS_BUSY 0x10
#define FAILED_NODE_REMOVE_FAIL 0x20
#define SUC_UPDATE_DONE 0x00
#define SUC_UPDATE_ABORT 0x01
#define SUC_UPDATE_WAIT 0x02
#define SUC_UPDATE_DISABLED 0x03
#define SUC_UPDATE_OVERFLOW 0x04
#define SUC_FUNC_BASIC_SUC 0x00
#define SUC_FUNC_NODEID_SERVER 0x01
#define UPDATE_STATE_NODE_INFO_RECEIVED 0x84
#define UPDATE_STATE_NODE_INFO_REQ_DONE 0x82
#define UPDATE_STATE_NODE_INFO_REQ_FAILED 0x81
#define UPDATE_STATE_ROUTING_PENDING 0x80
#define UPDATE_STATE_NEW_ID_ASSIGNED 0x40
#define UPDATE_STATE_DELETE_DONE 0x20
#define UPDATE_STATE_SUC_ID 0x10
#define APPLICATION_NODEINFO_LISTENING 0x01
#define APPLICATION_NODEINFO_OPTIONAL_FUNCTIONALITY 0x02
#define SLAVE_ASSIGN_COMPLETE 0x00
#define SLAVE_ASSIGN_NODEID_DONE 0x01 // Node ID has been assigned
#define SLAVE_ASSIGN_RANGE_INFO_UPDATE 0x02 // Node is doing neighbor discovery
#define SLAVE_LEARN_MODE_DISABLE 0x00 // disable add/remove virtual slave nodes
#define SLAVE_LEARN_MODE_ENABLE 0x01 // enable ability to include/exclude virtual slave nodes
#define SLAVE_LEARN_MODE_ADD 0x02 // add node directly but only if primary/inclusion controller
#define SLAVE_LEARN_MODE_REMOVE 0x03 // remove node directly but only if primary/inclusion controller
#define OPTION_HIGH_POWER 0x80
#define OPTION_NWI 0x40 // NWI Inclusion
//Device request related
#define BASIC_SET 0x01
#define BASIC_REPORT 0x03
#define COMMAND_CLASS_BASIC 0x20
#define COMMAND_CLASS_CONTROLLER_REPLICATION 0x21
#define COMMAND_CLASS_APPLICATION_STATUS 0x22
#define COMMAND_CLASS_HAIL 0x82
#endif // _Defs_H
open-zwave-1.5/cpp/src/DoxygenMain.h 0000664 0000000 0000000 00000016631 12644742024 0017432 0 ustar 00root root 0000000 0000000
/**
* \mainpage OpenZWave
* \section Introduction Introduction to OpenZWave
* OpenZWave is an open-source, cross-platform library designed to enable
* anyone to add support for Z-Wave home-automation devices to their
* applications, without requiring any in depth knowledge of the Z-Wave
* protocol.
*
* Z-Wave employs a proprietary protocol which the owners, Sigma Designs,
* have chosen not to release into the public domain. There is also no
* official free or low-cost SDK that can be used to develop applications
* (The ControlThink SDK is now tied exclusively to their own Z-Wave PC
* interface). The only way to obtain the protocol documentation and sample
* code is to purchase an expensive development kit, and sign a non-disclosure
* agreement (NDA) preventing the release of that knowledge.
*
* OpenZWave was created to fill that gap. We do not have the official
* documentation, have signed no NDA, and are free to develop the library as
* we see fit. Our knowledge comes from existing bodies of open-source code
* (principally the Z-Wave parts of LinuxMCE), and through examining the
* messages sent by Z-Wave devices.
*
* The goal of the project is to make a positive contribution to the Z-Wave
* community by creating a library that supports as much of the Z-Wave
* specification as possible, and that can be used as a "black-box"
* solution by anyone wanting to add Z-Wave to their application. It is NOT
* our aim to publish alternative documentation of the Z-Wave protocol, or
* to attempt to "punish" Sigma Designs for their decision to keep the
* protocol closed.
* \section ZWave Z-Wave Concepts
* Z-Wave is a proprietary wireless communications protocol employing mesh
* networking technology. A mesh network allows low power devices to
* communicate over long ranges, and around radio blackspots by passing
* messages from one node to another. It is important to note that not all
* Z-Wave devices are active all the time, especially those that are battery
* powered. These nodes cannot take part in the forwarding of messages
* across the mesh.
*
* Each Z-Wave device is known as "Node" in the network. A Z-Wave network
* can contain up to 232 nodes. If more devices are required, then
* multiple networks need to be set up using separate Z-Wave controller.
* OpenZWave supports multiple controllers, but on its own does not bridge
* the networks allowing a device on one to directly control a device on
* another. This functionality would have to be supplied by the application.
*
* Z-Wave nodes can be divided into two types: Controllers and Slaves. The
* controllers are usually in the form of hand-held remote controls, or PC
* interfaces. The switches, dimmers, movement sensors etc are all slaves.
* Controllers and Devices
* Replication
* Command Classes
* Values
*
* \section Library The OpenZWave Library
* \subsection Overview Overview
* \subsection Manager The Manager
* All Z-Wave functionality is accessed via the Manager class. While this
* does not make for the most efficient code structure, it does enable
* the library to handle potentially complex and hard-to-debug issues
* such as multi-threading and object lifespans behind the scenes.
* Application development is therefore simplified and less prone to bugs.
*
* \subsection Notifications Notifications
* Communication between the PC and devices on the the Z-Wave network occurs
* asynchronously. Some devices, notably movement sensors, sleep most of the
* time to save battery power, and can only receive commands when awake.
* Therefore a command to change a value in a device may not occur immediately.
* It may take several seconds or minutes, or even never arrive at all.
* For this reason, many OpenZWave methods, even those that request
* information, do not return that information directly. A request will be
* sent to the network, and the response sent to the application some time
* later via a system of notification callbacks. The notification handler
* will be at the core of any application using OpenZWave. It is here that
* all information regarding device configurations and states will be reported.
*
* A Z-Wave network is a dynamic entity. Controllers and devices can be
* added or removed at any time. Once a network has been set up, this
* probably won't happen very often, but OpenZWave, and any application
* built upon it, must cope all the same. The notification callback system
* is used to inform the application of any changes to the structure of the
* network.
* \subsection Values Working with Values
*
* \subsection Guidelines Application Development Guidelines
* The main considerations when designing an application based upon
* OpenZWave are:
*
* - Communication with Z-Wave devices is asynchronous and not guaranteed
* to be reliable. Do not rely on receiving a response to any request.
*
* - A Z-Wave network may change at any time. The application's notification
* callback handler must deal woth all notifications, and any representation
* of the state of the Z-Wave network held by the application must be
* modified to match. User interfaces should be built dynamically from the
* information reported in the notification callbacks, and must be able to cope
* with the addition and removal of devices.
*
* Some users will have more than one Z-Wave controller, to allow for remote
* locations or to work around the 232 device limit. OpenZWave is designed
* for use with multiple controllers, and all applications should be written
* to support this.
*
* - There is no need to save the state of the network and restore it on
* the next run. OpenZWave does this automatically, and is designed to cope
* with any changes that occur to the network while the application is not
* running.
*
*
* \section Structure Source Code Structure
*
*
* \section Samples Samples
* The SDK package includes skeleton code for creating xPL-enabled
* applications. Code is provided for three types of application - a Windows
* service, a Windowed application, and a console application. The Windows
* service is quite flexible - it will run as a console application if no
* command line parameters are passed to it. This makes it possible to
* ship one application that will run on all versions of Windows, whether or
* not there is support for services. It is also useful for debugging.
*
* The full source code for the W800RF32 service is also provided as a real
* life example of using the SDK to build a complete xPL application.
*
* \section Licensing Licensing
* OpenZWave is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published
* by the Free Software Foundation, either version 3 of the License,
* or (at your option) any later version.
*
* OpenZWave is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with OpenZWave. If not, see .
*
* \section Support Support
* Assistance with all OpenZWave issues can be obtained by posting a message
* to the OpenZWave Google Group (http://groups.google.com/group/openzwave)
*
*/
open-zwave-1.5/cpp/src/Driver.cpp 0000664 0000000 0000000 00000635150 12644742024 0017001 0 ustar 00root root 0000000 0000000 //-----------------------------------------------------------------------------
//
// Driver.cpp
//
// Communicates with a Z-Wave network
//
// Copyright (c) 2010 Mal Lansell
//
// SOFTWARE NOTICE AND LICENSE
//
// This file is part of OpenZWave.
//
// OpenZWave is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published
// by the Free Software Foundation, either version 3 of the License,
// or (at your option) any later version.
//
// OpenZWave is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with OpenZWave. If not, see .
//
//-----------------------------------------------------------------------------
#include "Defs.h"
#include "Driver.h"
#include "Options.h"
#include "Manager.h"
#include "Node.h"
#include "Msg.h"
#include "Notification.h"
#include "Scene.h"
#include "ZWSecurity.h"
#include "platform/Event.h"
#include "platform/Mutex.h"
#include "platform/SerialController.h"
#ifdef WINRT
#include "platform/winRT/HidControllerWinRT.h"
#else
#include "platform/HidController.h"
#endif
#include "platform/Thread.h"
#include "platform/Log.h"
#include "platform/TimeStamp.h"
#include "command_classes/CommandClasses.h"
#include "command_classes/ApplicationStatus.h"
#include "command_classes/ControllerReplication.h"
#include "command_classes/Security.h"
#include "command_classes/WakeUp.h"
#include "command_classes/SwitchAll.h"
#include "command_classes/ManufacturerSpecific.h"
#include "command_classes/NoOperation.h"
#include "value_classes/ValueID.h"
#include "value_classes/Value.h"
#include "value_classes/ValueStore.h"
#include "tinyxml.h"
#include "Utils.h"
#if defined(__unix__) || (defined(__APPLE__) && defined(__MACH__))
# include
#elif defined _WIN32
# include
#define sleep(x) Sleep(1000 * x)
#endif
#include
#include
using namespace OpenZWave;
// Version numbering for saved configurations. Any change that will invalidate
// previously saved configurations must be accompanied by an increment to the
// version number, and a comment explaining the date of, and reason for, the change.
//
// 01: 12-31-2010 - Introduced config version numbering due to ValueID format change.
// 02: 01-12-2011 - Command class m_afterMark sense corrected, and attribute named to match.
// 03: 08-04-2011 - Changed command class instance handling for non-sequential MultiChannel endpoints.
//
uint32 const c_configVersion = 3;
static char const* c_libraryTypeNames[] =
{
"Unknown", // library type 0
"Static Controller", // library type 1
"Controller", // library type 2
"Enhanced Slave", // library type 3
"Slave", // library type 4
"Installer", // library type 5
"Routing Slave", // library type 6
"Bridge Controller", // library type 7
"Device Under Test" // library type 8
};
static char const* c_controllerCommandNames[] =
{
"None",
"Add Device",
"Create New Primary",
"Receive Configuration",
"Remove Device",
"Remove Failed Node",
"Has Node Failed",
"Replace Failed Node",
"Transfer Primary Role",
"Request Network Update",
"Request Node Neighbor Update",
"Assign Return Route",
"Delete All Return Routes",
"Send Node Information",
"Replication Send",
"Create Button",
"Delete Button"
};
static char const* c_sendQueueNames[] =
{
"Command",
"Security",
"NoOp",
"Controller",
"WakeUp",
"Send",
"Query",
"Poll"
};
//-----------------------------------------------------------------------------
//
// Constructor
//-----------------------------------------------------------------------------
Driver::Driver
(
string const& _controllerPath,
ControllerInterface const& _interface
):
m_driverThread( new Thread( "driver" ) ),
m_initMutex(new Mutex()),
m_exit( false ),
m_init( false ),
m_awakeNodesQueried( false ),
m_allNodesQueried( false ),
m_notifytransactions( false ),
m_controllerInterfaceType( _interface ),
m_controllerPath( _controllerPath ),
m_controller( NULL ),
m_homeId( 0 ),
m_libraryVersion( "" ),
m_libraryTypeName( "" ),
m_libraryType( 0 ),
m_manufacturerId( 0 ),
m_productType( 0 ),
m_productId ( 0 ),
m_initVersion( 0 ),
m_initCaps( 0 ),
m_controllerCaps( 0 ),
m_Controller_nodeId ( 0 ),
m_nodeMutex( new Mutex() ),
m_controllerReplication( NULL ),
m_transmitOptions( TRANSMIT_OPTION_ACK | TRANSMIT_OPTION_AUTO_ROUTE | TRANSMIT_OPTION_EXPLORE ),
m_waitingForAck( false ),
m_expectedCallbackId( 0 ),
m_expectedReply( 0 ),
m_expectedCommandClassId( 0 ),
m_expectedNodeId( 0 ),
m_pollThread( new Thread( "poll" ) ),
m_pollMutex( new Mutex() ),
m_pollInterval( 0 ),
m_bIntervalBetweenPolls( false ), // if set to true (via SetPollInterval), the pollInterval will be interspersed between each poll (so a much smaller m_pollInterval like 100, 500, or 1,000 may be appropriate)
m_currentControllerCommand( NULL ),
m_SUCNodeId( 0 ),
m_controllerResetEvent( NULL ),
m_sendMutex( new Mutex() ),
m_currentMsg( NULL ),
m_virtualNeighborsReceived( false ),
m_notificationsEvent( new Event() ),
m_SOFCnt( 0 ),
m_ACKWaiting( 0 ),
m_readAborts( 0 ),
m_badChecksum( 0 ),
m_readCnt( 0 ),
m_writeCnt( 0 ),
m_CANCnt( 0 ),
m_NAKCnt( 0 ),
m_ACKCnt( 0 ),
m_OOFCnt( 0 ),
m_dropped( 0 ),
m_retries( 0 ),
m_callbacks( 0 ),
m_badroutes( 0 ),
m_noack( 0 ),
m_netbusy( 0 ),
m_notidle( 0 ),
m_nondelivery( 0 ),
m_routedbusy( 0 ),
m_broadcastReadCnt( 0 ),
m_broadcastWriteCnt( 0 ),
m_nonceReportSent( 0 ),
m_nonceReportSentAttempt( 0 )
{
// set a timestamp to indicate when this driver started
TimeStamp m_startTime;
// Create the message queue events
for( int32 i=0; iSetSignalThreshold( 1 );
Options::Get()->GetOptionAsBool( "NotifyTransactions", &m_notifytransactions );
Options::Get()->GetOptionAsInt( "PollInterval", &m_pollInterval );
Options::Get()->GetOptionAsBool( "IntervalBetweenPolls", &m_bIntervalBetweenPolls );
}
//-----------------------------------------------------------------------------
//
// Destructor
//-----------------------------------------------------------------------------
Driver::~Driver
(
)
{
/* Signal that we are going away... so at least Apps know... */
Notification* notification = new Notification( Notification::Type_DriverRemoved );
notification->SetHomeAndNodeIds( m_homeId, 0 );
QueueNotification( notification );
NotifyWatchers();
// append final driver stats output to the log file
LogDriverStatistics();
// Save the driver config before deleting anything else
bool save;
if( Options::Get()->GetOptionAsBool( "SaveConfiguration", &save) )
{
if( save )
{
WriteConfig();
Scene::WriteXML( "zwscene.xml" );
}
}
// The order of the statements below has been achieved by mitigating freed memory
//references using a memory allocator checker. Do not rearrange unless you are
//certain memory won't be referenced out of order. --Greg Satz, April 2010
m_initMutex->Lock();
m_exit = true;
m_initMutex->Unlock();
m_pollThread->Stop();
m_pollThread->Release();
m_driverThread->Stop();
m_driverThread->Release();
m_sendMutex->Release();
m_controller->Close();
m_controller->Release();
m_initMutex->Release();
if( m_currentMsg != NULL )
{
RemoveCurrentMsg();
}
// Clear the node data
{
LockGuard LG(m_nodeMutex);
for( int i=0; i<256; ++i )
{
if( GetNodeUnsafe( i ) )
{
delete m_nodes[i];
m_nodes[i] = NULL;
Notification* notification = new Notification( Notification::Type_NodeRemoved );
notification->SetHomeAndNodeIds( m_homeId, i );
QueueNotification( notification );
}
}
}
// Don't release until all nodes have removed their poll values
m_pollMutex->Release();
// Clear the send Queue
for( int32 i=0; iRelease();
}
/* Doing our Notification Call back here in the destructor is just asking for trouble
* as there is a good chance that the application will do some sort of GetDriver() supported
* method on the Manager Class, which by this time, most of the OZW Classes associated with the
* Driver class is 99% destructed. (mainly nodes, which cascade to CC, which cascade to ValueID
* classes etc). We might need a flag around the Manager::GetDriver() class that stops applications
* from getting a half destructed Driver Reference, but still retain a Internal GetDriver() method
* that can return half destructed Driver references for internal classes (as per Greg's note above)
*/
bool notify;
if( Options::Get()->GetOptionAsBool( "NotifyOnDriverUnload", ¬ify) )
{
if( notify )
{
NotifyWatchers();
}
}
if (m_controllerReplication)
delete m_controllerReplication;
m_notificationsEvent->Release();
m_nodeMutex->Release();
}
//-----------------------------------------------------------------------------
//
// Start the driver thread
//-----------------------------------------------------------------------------
void Driver::Start
(
)
{
// Start the thread that will handle communications with the Z-Wave network
m_driverThread->Start( Driver::DriverThreadEntryPoint, this );
}
//-----------------------------------------------------------------------------
//
// Entry point of the thread for creating and managing the worker threads
//-----------------------------------------------------------------------------
void Driver::DriverThreadEntryPoint
(
Event* _exitEvent,
void* _context
)
{
Driver* driver = (Driver*)_context;
if( driver )
{
driver->DriverThreadProc( _exitEvent );
}
}
//-----------------------------------------------------------------------------
//
// Create and manage the worker threads
//-----------------------------------------------------------------------------
void Driver::DriverThreadProc
(
Event* _exitEvent
)
{
uint32 attempts = 0;
while( true )
{
if( Init( attempts ) )
{
// Driver has been initialised
Wait* waitObjects[11];
waitObjects[0] = _exitEvent; // Thread must exit.
waitObjects[1] = m_notificationsEvent; // Notifications waiting to be sent.
waitObjects[2] = m_controller; // Controller has received data.
waitObjects[3] = m_queueEvent[MsgQueue_Command]; // A controller command is in progress.
waitObjects[4] = m_queueEvent[MsgQueue_Security]; // Security Related Commands (As they have a timeout)
waitObjects[5] = m_queueEvent[MsgQueue_NoOp]; // Send device probes and diagnostics messages
waitObjects[6] = m_queueEvent[MsgQueue_Controller]; // A multi-part controller command is in progress
waitObjects[7] = m_queueEvent[MsgQueue_WakeUp]; // A node has woken. Pending messages should be sent.
waitObjects[8] = m_queueEvent[MsgQueue_Send]; // Ordinary requests to be sent.
waitObjects[9] = m_queueEvent[MsgQueue_Query]; // Node queries are pending.
waitObjects[10] = m_queueEvent[MsgQueue_Poll]; // Poll request is waiting.
TimeStamp retryTimeStamp;
int retryTimeout = RETRY_TIMEOUT;
Options::Get()->GetOptionAsInt( "RetryTimeout", &retryTimeout );
//retryTimeout = RETRY_TIMEOUT * 10;
while( true )
{
Log::Write( LogLevel_StreamDetail, " Top of DriverThreadProc loop." );
uint32 count = 11;
int32 timeout = Wait::Timeout_Infinite;
// If we're waiting for a message to complete, we can only
// handle incoming data, notifications and exit events.
if( m_waitingForAck || m_expectedCallbackId || m_expectedReply )
{
count = 3;
timeout = m_waitingForAck ? ACK_TIMEOUT : retryTimeStamp.TimeRemaining();
if( timeout < 0 )
{
timeout = 0;
}
}
else if( m_currentControllerCommand != NULL )
{
count = 7;
}
else
{
Log::QueueClear(); // clear the log queue when starting a new message
}
// Wait for something to do
int32 res = Wait::Multiple( waitObjects, count, timeout );
switch( res )
{
case -1:
{
// Wait has timed out - time to resend
if( m_currentMsg != NULL )
{
Notification* notification = new Notification( Notification::Type_Notification );
notification->SetHomeAndNodeIds( m_homeId, m_currentMsg->GetTargetNodeId() );
notification->SetNotification( Notification::Code_Timeout );
QueueNotification( notification );
}
if( WriteMsg( "Wait Timeout" ) )
{
retryTimeStamp.SetTime( retryTimeout );
}
break;
}
case 0:
{
// Exit has been signalled
return;
}
case 1:
{
// Notifications are waiting to be sent
NotifyWatchers();
break;
}
case 2:
{
// Data has been received
ReadMsg();
break;
}
default:
{
// All the other events are sending message queue items
if( WriteNextMsg( (MsgQueue)(res-3) ) )
{
retryTimeStamp.SetTime( retryTimeout );
}
break;
}
}
}
}
++attempts;
uint32 maxAttempts = 0;
Options::Get()->GetOptionAsInt("DriverMaxAttempts", (int32 *)&maxAttempts);
if( maxAttempts && (attempts >= maxAttempts) )
{
Manager::Get()->Manager::SetDriverReady(this, false);
NotifyWatchers();
break;
}
if( attempts < 25 )
{
// Retry every 5 seconds for the first two minutes
if( Wait::Single( _exitEvent, 5000 ) == 0 )
{
// Exit signalled.
return;
}
}
else
{
// Retry every 30 seconds after that
if( Wait::Single( _exitEvent, 30000 ) == 0 )
{
// Exit signalled.
return;
}
}
}
}
//-----------------------------------------------------------------------------
//
// Initialize the controller
//-----------------------------------------------------------------------------
bool Driver::Init
(
uint32 _attempts
)
{
m_initMutex->Lock();
if (m_exit)
{
m_initMutex->Unlock();
return false;
}
m_Controller_nodeId = -1;
m_waitingForAck = false;
// Open the controller
Log::Write( LogLevel_Info, " Opening controller %s", m_controllerPath.c_str() );
if( !m_controller->Open( m_controllerPath ) )
{
Log::Write( LogLevel_Warning, "WARNING: Failed to init the controller (attempt %d)", _attempts );
m_initMutex->Unlock();
return false;
}
// Controller opened successfully, so we need to start all the worker threads
m_pollThread->Start( Driver::PollThreadEntryPoint, this );
// Send a NAK to the ZWave device
uint8 nak = NAK;
m_controller->Write( &nak, 1 );
// Get/set ZWave controller information in its preferred initialization order
m_controller->PlayInitSequence( this );
//If we ever want promiscuous mode uncomment this code.
//Msg* msg = new Msg( "FUNC_ID_ZW_SET_PROMISCUOUS_MODE", 0xff, REQUEST, FUNC_ID_ZW_SET_PROMISCUOUS_MODE, false, false );
//msg->Append( 0xff );
//SendMsg( msg );
m_initMutex->Unlock();
// Init successful
return true;
}
//-----------------------------------------------------------------------------
//
// Clean up any messages to a node
//-----------------------------------------------------------------------------
void Driver::RemoveQueues
(
uint8 const _nodeId
)
{
if( m_currentMsg != NULL && m_currentMsg->GetTargetNodeId() == _nodeId )
{
RemoveCurrentMsg();
}
// Clear the send Queue
for( int32 i=0; i::iterator it = m_msgQueue[i].begin();
while( it != m_msgQueue[i].end() )
{
bool remove = false;
MsgQueueItem const& item = *it;
if( MsgQueueCmd_SendMsg == item.m_command && _nodeId == item.m_msg->GetTargetNodeId() )
{
delete item.m_msg;
remove = true;
}
else if( MsgQueueCmd_QueryStageComplete == item.m_command && _nodeId == item.m_nodeId )
{
remove = true;
}
else if( MsgQueueCmd_Controller == item.m_command && _nodeId == item.m_cci->m_controllerCommandNode && m_currentControllerCommand != item.m_cci )
{
delete item.m_cci;
remove = true;
}
if( remove )
{
it = m_msgQueue[i].erase( it );
}
else
{
++it;
}
}
if( m_msgQueue[i].empty() )
{
m_queueEvent[i]->Reset();
}
}
}
//-----------------------------------------------------------------------------
// Configuration
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//
// Read our configuration from an XML document
//-----------------------------------------------------------------------------
bool Driver::ReadConfig
(
)
{
char str[32];
int32 intVal;
// Load the XML document that contains the driver configuration
string userPath;
Options::Get()->GetOptionAsString( "UserPath", &userPath );
snprintf( str, sizeof(str), "ozwcache_0x%08x.xml", m_homeId );
string filename = userPath + string(str);
TiXmlDocument doc;
if( !doc.LoadFile( filename.c_str(), TIXML_ENCODING_UTF8 ) )
{
return false;
}
TiXmlElement const* driverElement = doc.RootElement();
// Version
if( TIXML_SUCCESS != driverElement->QueryIntAttribute( "version", &intVal ) || (uint32)intVal != c_configVersion )
{
Log::Write( LogLevel_Warning, "WARNING: Driver::ReadConfig - %s is from an older version of OpenZWave and cannot be loaded.", filename.c_str() );
return false;
}
// Home ID
char const* homeIdStr = driverElement->Attribute( "home_id" );
if( homeIdStr )
{
char* p;
uint32 homeId = (uint32)strtoul( homeIdStr, &p, 0 );
if( homeId != m_homeId )
{
Log::Write( LogLevel_Warning, "WARNING: Driver::ReadConfig - Home ID in file %s is incorrect", filename.c_str() );
return false;
}
}
else
{
Log::Write( LogLevel_Warning, "WARNING: Driver::ReadConfig - Home ID is missing from file %s", filename.c_str() );
return false;
}
// Node ID
if( TIXML_SUCCESS == driverElement->QueryIntAttribute( "node_id", &intVal ) )
{
if( (uint8)intVal != m_Controller_nodeId )
{
Log::Write( LogLevel_Warning, "WARNING: Driver::ReadConfig - Controller Node ID in file %s is incorrect", filename.c_str() );
return false;
}
}
else
{
Log::Write( LogLevel_Warning, "WARNING: Driver::ReadConfig - Node ID is missing from file %s", filename.c_str() );
return false;
}
// Capabilities
if( TIXML_SUCCESS == driverElement->QueryIntAttribute( "api_capabilities", &intVal ) )
{
m_initCaps = (uint8)intVal;
}
if( TIXML_SUCCESS == driverElement->QueryIntAttribute( "controller_capabilities", &intVal ) )
{
m_controllerCaps = (uint8)intVal;
}
// Poll Interval
if( TIXML_SUCCESS == driverElement->QueryIntAttribute( "poll_interval", &intVal ) )
{
m_pollInterval = intVal;
}
// Poll Interval--between polls or period for polling the entire pollList?
char const* cstr = driverElement->Attribute( "poll_interval_between" );
if( cstr )
{
m_bIntervalBetweenPolls = !strcmp( str, "true" );
}
// Read the nodes
LockGuard LG(m_nodeMutex);
TiXmlElement const* nodeElement = driverElement->FirstChildElement();
while( nodeElement )
{
char const* str = nodeElement->Value();
if( str && !strcmp( str, "Node" ) )
{
// Get the node Id from the XML
if( TIXML_SUCCESS == nodeElement->QueryIntAttribute( "id", &intVal ) )
{
uint8 nodeId = (uint8)intVal;
Node* node = new Node( m_homeId, nodeId );
m_nodes[nodeId] = node;
Notification* notification = new Notification( Notification::Type_NodeAdded );
notification->SetHomeAndNodeIds( m_homeId, nodeId );
QueueNotification( notification );
// Read the rest of the node configuration from the XML
node->ReadXML( nodeElement );
}
}
nodeElement = nodeElement->NextSiblingElement();
}
LG.Unlock();
// restore the previous state (for now, polling) for the nodes/values just retrieved
for( int i=0; i<256; i++ )
{
if( m_nodes[i] != NULL )
{
ValueStore* vs = m_nodes[i]->m_values;
for( ValueStore::Iterator it = vs->Begin(); it != vs->End(); ++it )
{
Value* value = it->second;
if( value->m_pollIntensity != 0 )
EnablePoll( value->GetID(), value->m_pollIntensity );
}
}
}
return true;
}
//-----------------------------------------------------------------------------
//
// Write ourselves to an XML document
//-----------------------------------------------------------------------------
void Driver::WriteConfig
(
)
{
char str[32];
if (!m_homeId) {
Log::Write( LogLevel_Warning, "WARNING: Tried to write driver config with no home ID set");
return;
}
// Create a new XML document to contain the driver configuration
TiXmlDocument doc;
TiXmlDeclaration* decl = new TiXmlDeclaration( "1.0", "utf-8", "" );
TiXmlElement* driverElement = new TiXmlElement( "Driver" );
doc.LinkEndChild( decl );
doc.LinkEndChild( driverElement );
driverElement->SetAttribute( "xmlns", "http://code.google.com/p/open-zwave/" );
snprintf( str, sizeof(str), "%d", c_configVersion );
driverElement->SetAttribute( "version", str );
snprintf( str, sizeof(str), "0x%.8x", m_homeId );
driverElement->SetAttribute( "home_id", str );
snprintf( str, sizeof(str), "%d", m_Controller_nodeId );
driverElement->SetAttribute( "node_id", str );
snprintf( str, sizeof(str), "%d", m_initCaps );
driverElement->SetAttribute( "api_capabilities", str );
snprintf( str, sizeof(str), "%d", m_controllerCaps );
driverElement->SetAttribute( "controller_capabilities", str );
snprintf( str, sizeof(str), "%d", m_pollInterval );
driverElement->SetAttribute( "poll_interval", str );
snprintf( str, sizeof(str), "%s", m_bIntervalBetweenPolls ? "true" : "false" );
driverElement->SetAttribute( "poll_interval_between", str );
{
LockGuard LG(m_nodeMutex);
for( int i=0; i<256; ++i )
{
if( m_nodes[i] )
{
m_nodes[i]->WriteXML( driverElement );
}
}
}
string userPath;
Options::Get()->GetOptionAsString( "UserPath", &userPath );
snprintf( str, sizeof(str), "ozwcache_0x%08x.xml", m_homeId );
string filename = userPath + string(str);
doc.SaveFile( filename.c_str() );
}
//-----------------------------------------------------------------------------
// Controller
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//
// Returns a pointer to the requested node without locking.
// Only to be used by main thread code.
//-----------------------------------------------------------------------------
Node* Driver::GetNodeUnsafe
(
uint8 _nodeId
)
{
if( Node* node = m_nodes[_nodeId] )
{
return node;
}
return NULL;
}
//-----------------------------------------------------------------------------
//
// Locks the nodes and returns a pointer to the requested one
//-----------------------------------------------------------------------------
Node* Driver::GetNode
(
uint8 _nodeId
)
{
if (m_nodeMutex->IsSignalled()) {
Log::Write(LogLevel_Error, _nodeId, "Driver Thread is Not Locked during Call to GetNode");
return NULL;
}
if( Node* node = m_nodes[_nodeId] )
{
return node;
}
return NULL;
}
//-----------------------------------------------------------------------------
// Sending Z-Wave messages
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//
// Queue an item on the query queue that indicates a stage is complete
//-----------------------------------------------------------------------------
void Driver::SendQueryStageComplete
(
uint8 const _nodeId,
Node::QueryStage const _stage
)
{
MsgQueueItem item;
item.m_command = MsgQueueCmd_QueryStageComplete;
item.m_nodeId = _nodeId;
item.m_queryStage = _stage;
item.m_retry = false;
LockGuard LG(m_nodeMutex);
if( Node* node = GetNode( _nodeId ) )
{
if( !node->IsListeningDevice() )
{
if( WakeUp* wakeUp = static_cast( node->GetCommandClass( WakeUp::StaticGetCommandClassId() ) ) )
{
if( !wakeUp->IsAwake() )
{
// If the message is for a sleeping node, we queue it in the node itself.
Log::Write( LogLevel_Info, "" );
Log::Write( LogLevel_Detail, node->GetNodeId(), "Queuing (%s) Query Stage Complete (%s)", c_sendQueueNames[MsgQueue_WakeUp], node->GetQueryStageName( _stage ).c_str() );
wakeUp->QueueMsg( item );
return;
}
}
}
// Non-sleeping node
Log::Write( LogLevel_Detail, node->GetNodeId(), "Queuing (%s) Query Stage Complete (%s)", c_sendQueueNames[MsgQueue_Query], node->GetQueryStageName( _stage ).c_str() );
m_sendMutex->Lock();
m_msgQueue[MsgQueue_Query].push_back( item );
m_queueEvent[MsgQueue_Query]->Set();
m_sendMutex->Unlock();
}
}
//-----------------------------------------------------------------------------
//
// Request the current stage will be repeated
//-----------------------------------------------------------------------------
void Driver::RetryQueryStageComplete
(
uint8 const _nodeId,
Node::QueryStage const _stage
)
{
MsgQueueItem item;
item.m_command = MsgQueueCmd_QueryStageComplete;
item.m_nodeId = _nodeId;
item.m_queryStage = _stage;
m_sendMutex->Lock();
for( list::iterator it = m_msgQueue[MsgQueue_Query].begin(); it != m_msgQueue[MsgQueue_Query].end(); ++it )
{
if( *it == item )
{
(*it).m_retry = true;
break;
}
}
m_sendMutex->Unlock();
}
//-----------------------------------------------------------------------------
//
// Queue a message to be sent to the Z-Wave PC Interface
//-----------------------------------------------------------------------------
void Driver::SendMsg
(
Msg* _msg,
MsgQueue const _queue
)
{
MsgQueueItem item;
item.m_command = MsgQueueCmd_SendMsg;
item.m_msg = _msg;
/* make sure the HomeId is Set on this message */
_msg->SetHomeId(m_homeId);
_msg->Finalize();
{
LockGuard LG(m_nodeMutex);
if( Node* node = GetNode(_msg->GetTargetNodeId()) )
{
/* if the node Supports the Security Class - check if this message is meant to be encapsulated */
if ( node->GetCommandClass(Security::StaticGetCommandClassId() ) )
{
CommandClass *cc = node->GetCommandClass(_msg->GetSendingCommandClass());
if ( (cc) && (cc->IsSecured()) )
{
Log::Write( LogLevel_Detail, GetNodeNumber( _msg ), "Setting Encryption Flag on Message For Command Class %s", cc->GetCommandClassName().c_str());
item.m_msg->setEncrypted();
}
}
// If the message is for a sleeping node, we queue it in the node itself.
if( !node->IsListeningDevice() )
{
if( WakeUp* wakeUp = static_cast( node->GetCommandClass( WakeUp::StaticGetCommandClassId() ) ) )
{
if( !wakeUp->IsAwake() )
{
Log::Write( LogLevel_Detail, "" );
// Handle saving multi-step controller commands
if( m_currentControllerCommand != NULL )
{
Log::Write( LogLevel_Detail, GetNodeNumber( _msg ), "Queuing (%s) %s", c_sendQueueNames[MsgQueue_Controller], c_controllerCommandNames[m_currentControllerCommand->m_controllerCommand] );
delete _msg;
item.m_command = MsgQueueCmd_Controller;
item.m_cci = new ControllerCommandItem( *m_currentControllerCommand );
item.m_msg = NULL;
UpdateControllerState( ControllerState_Sleeping );
}
else
{
Log::Write( LogLevel_Detail, GetNodeNumber( _msg ), "Queuing (%s) %s", c_sendQueueNames[MsgQueue_WakeUp], _msg->GetAsString().c_str() );
}
wakeUp->QueueMsg( item );
return;
}
}
}
}
}
Log::Write( LogLevel_Detail, GetNodeNumber( _msg ), "Queuing (%s) %s", c_sendQueueNames[_queue], _msg->GetAsString().c_str() );
m_sendMutex->Lock();
m_msgQueue[_queue].push_back( item );
m_queueEvent[_queue]->Set();
m_sendMutex->Unlock();
}
//-----------------------------------------------------------------------------
//
// Transmit a queued message to the Z-Wave controller
//-----------------------------------------------------------------------------
bool Driver::WriteNextMsg
(
MsgQueue const _queue
)
{
// There are messages to send, so get the one at the front of the queue
m_sendMutex->Lock();
MsgQueueItem item = m_msgQueue[_queue].front();
if( MsgQueueCmd_SendMsg == item.m_command )
{
// Send a message
m_currentMsg = item.m_msg;
m_currentMsgQueueSource = _queue;
m_msgQueue[_queue].pop_front();
if( m_msgQueue[_queue].empty() )
{
m_queueEvent[_queue]->Reset();
}
m_sendMutex->Unlock();
return WriteMsg( "WriteNextMsg" );
}
if( MsgQueueCmd_QueryStageComplete == item.m_command )
{
// Move to the next query stage
m_currentMsg = NULL;
Node::QueryStage stage = item.m_queryStage;
m_msgQueue[_queue].pop_front();
if( m_msgQueue[_queue].empty() )
{
m_queueEvent[_queue]->Reset();
}
m_sendMutex->Unlock();
Node* node = GetNodeUnsafe( item.m_nodeId );
if( node != NULL )
{
Log::Write( LogLevel_Detail, node->GetNodeId(), "Query Stage Complete (%s)", node->GetQueryStageName( stage ).c_str() );
if( !item.m_retry )
{
node->QueryStageComplete( stage );
}
node->AdvanceQueries();
return true;
}
}
if( MsgQueueCmd_Controller == item.m_command )
{
// Run a multi-step controller command
m_currentControllerCommand = item.m_cci;
m_sendMutex->Unlock();
// Figure out if done with command
if ( m_currentControllerCommand->m_controllerCommandDone )
{
m_sendMutex->Lock();
m_msgQueue[_queue].pop_front();
if( m_msgQueue[_queue].empty() )
{
m_queueEvent[_queue]->Reset();
}
m_sendMutex->Unlock();
if( m_currentControllerCommand->m_controllerCallback )
{
m_currentControllerCommand->m_controllerCallback( m_currentControllerCommand->m_controllerState, m_currentControllerCommand->m_controllerReturnError, m_currentControllerCommand->m_controllerCallbackContext );
}
m_sendMutex->Lock();
delete m_currentControllerCommand;
m_currentControllerCommand = NULL;
m_sendMutex->Unlock();
}
else if( m_currentControllerCommand->m_controllerState == ControllerState_Normal )
{
DoControllerCommand();
}
else if( m_currentControllerCommand->m_controllerStateChanged )
{
if( m_currentControllerCommand->m_controllerCallback )
{
m_currentControllerCommand->m_controllerCallback( m_currentControllerCommand->m_controllerState, m_currentControllerCommand->m_controllerReturnError, m_currentControllerCommand->m_controllerCallbackContext );
m_currentControllerCommand->m_controllerStateChanged = false;
}
}
else
{
Log::Write( LogLevel_Info, "WriteNextMsg Controller nothing to do" );
m_sendMutex->Lock();
m_queueEvent[_queue]->Reset();
m_sendMutex->Unlock();
}
return true;
}
return false;
}
//-----------------------------------------------------------------------------
//
// Transmit the current message to the Z-Wave controller
//-----------------------------------------------------------------------------
bool Driver::WriteMsg
(
string const &msg
)
{
if( !m_currentMsg )
{
Log::Write( LogLevel_Detail, GetNodeNumber( m_currentMsg ), "WriteMsg %s m_currentMsg=%08x", msg.c_str(), m_currentMsg );
// We try not to hang when this happenes
m_expectedCallbackId = 0;
m_expectedCommandClassId = 0;
m_expectedNodeId = 0;
m_expectedReply = 0;
m_waitingForAck = false;
return false;
}
/* if this is called with m_nonceReportSent > 0 it means that we have
* tried to send a NONCE report and it timed out or was NAK'd
*
*/
uint8 attempts;
uint8 nodeId;
if (m_nonceReportSent > 0) {
attempts = m_nonceReportSentAttempt++;
nodeId = m_nonceReportSent;
} else {
attempts = m_currentMsg->GetSendAttempts();
nodeId = m_currentMsg->GetTargetNodeId();
}
LockGuard LG(m_nodeMutex);
Node* node = GetNode( nodeId );
if( attempts >= m_currentMsg->GetMaxSendAttempts() ||
(node != NULL && !node->IsNodeAlive() && !m_currentMsg->IsNoOperation() ) )
{
if( node != NULL && !node->IsNodeAlive() )
{
Log::Write( LogLevel_Error, nodeId, "ERROR: Dropping command because node is presumed dead" );
}
else
{
// That's it - already tried to send GetMaxSendAttempt() times.
Log::Write( LogLevel_Error, nodeId, "ERROR: Dropping command, expected response not received after %d attempt(s)", m_currentMsg->GetMaxSendAttempts() );
}
if( m_currentControllerCommand != NULL )
{
/* its a ControllerCommand that is failed */
UpdateControllerState( ControllerState_Error, ControllerError_Failed);
}
RemoveCurrentMsg();
m_dropped++;
return false;
}
if (( attempts != 0) && (m_nonceReportSent == 0))
{
// this is not the first attempt, so increment the callback id before sending
m_currentMsg->UpdateCallbackId();
}
/* XXX TODO: Minor Bug - Due to the post increament of the SendAttempts, it means our final NONCE_GET will go though
* but the subsequent MSG send will fail (as the counter is incremented only upon a successful NONCE_GET, and Not a Send
*
*/
if (m_nonceReportSent == 0) {
if (m_currentMsg->isEncrypted() && !m_currentMsg->isNonceRecieved()) {
m_currentMsg->SetSendAttempts( ++attempts );
} else if (!m_currentMsg->isEncrypted() ) {
m_currentMsg->SetSendAttempts( ++attempts );
}
m_expectedCallbackId = m_currentMsg->GetCallbackId();
m_expectedCommandClassId = m_currentMsg->GetExpectedCommandClassId();
m_expectedNodeId = m_currentMsg->GetTargetNodeId();
m_expectedReply = m_currentMsg->GetExpectedReply();
m_waitingForAck = true;
}
string attemptsstr = "";
if( attempts > 1 )
{
char buf[15];
snprintf( buf, sizeof(buf), "Attempt %d, ", attempts );
attemptsstr = buf;
m_retries++;
if( node != NULL )
{
node->m_retries++;
}
}
Log::Write( LogLevel_Detail, "" );
if (m_nonceReportSent > 0) {
/* send a new NONCE report */
SendNonceKey(m_nonceReportSent, node->GenerateNonceKey());
} else if (m_currentMsg->isEncrypted()) {
if (m_currentMsg->isNonceRecieved()) {
Log::Write( LogLevel_Info, nodeId, "Processing (%s) Encrypted message (%sCallback ID=0x%.2x, Expected Reply=0x%.2x) - %s", c_sendQueueNames[m_currentMsgQueueSource], attemptsstr.c_str(), m_expectedCallbackId, m_expectedReply, m_currentMsg->GetAsString().c_str() );
SendEncryptedMessage();
} else {
Log::Write( LogLevel_Info, nodeId, "Processing (%s) Nonce Request message (%sCallback ID=0x%.2x, Expected Reply=0x%.2x)", c_sendQueueNames[m_currentMsgQueueSource], attemptsstr.c_str(), m_expectedCallbackId, m_expectedReply);
SendNonceRequest(m_currentMsg->GetLogText());
}
} else {
Log::Write( LogLevel_Info, nodeId, "Sending (%s) message (%sCallback ID=0x%.2x, Expected Reply=0x%.2x) - %s", c_sendQueueNames[m_currentMsgQueueSource], attemptsstr.c_str(), m_expectedCallbackId, m_expectedReply, m_currentMsg->GetAsString().c_str() );
uint32 bytesWritten = m_controller->Write(m_currentMsg->GetBuffer(), m_currentMsg->GetLength());
if (bytesWritten == 0)
{
//0 will be returned when the port is closed or something bad happened
//so send notification
Notification* notification = new Notification(Notification::Type_DriverFailed);
notification->SetHomeAndNodeIds(m_homeId, m_currentMsg->GetTargetNodeId());
QueueNotification(notification);
NotifyWatchers();
m_driverThread->Stop();
return false;
}
}
m_writeCnt++;
if( nodeId == 0xff )
{
m_broadcastWriteCnt++; // not accurate since library uses 0xff for the controller too
}
else
{
if( node != NULL )
{
node->m_sentCnt++;
node->m_sentTS.SetTime();
if( m_expectedReply == FUNC_ID_APPLICATION_COMMAND_HANDLER )
{
CommandClass *cc = node->GetCommandClass(m_expectedCommandClassId);
if( cc != NULL )
{
cc->SentCntIncr();
}
}
}
}
return true;
}
//-----------------------------------------------------------------------------
//
// Delete the current message
//-----------------------------------------------------------------------------
void Driver::RemoveCurrentMsg
(
)
{
Log::Write( LogLevel_Detail, GetNodeNumber( m_currentMsg ), "Removing current message" );
if( m_currentMsg != NULL)
{
delete m_currentMsg;
m_currentMsg = NULL;
}
m_expectedCallbackId = 0;
m_expectedCommandClassId = 0;
m_expectedNodeId = 0;
m_expectedReply = 0;
m_waitingForAck = false;
m_nonceReportSent = 0;
m_nonceReportSentAttempt = 0;
}
//-----------------------------------------------------------------------------
//
// Move messages for a sleeping device to its wake-up queue
//-----------------------------------------------------------------------------
bool Driver::MoveMessagesToWakeUpQueue
(
uint8 const _targetNodeId,
bool const _move
)
{
// If the target node is one that goes to sleep, transfer
// all messages for it to its Wake-Up queue.
if( Node* node = GetNodeUnsafe(_targetNodeId) )
{
if( !node->IsListeningDevice() && !node->IsFrequentListeningDevice() && _targetNodeId != m_Controller_nodeId )
{
if( WakeUp* wakeUp = static_cast( node->GetCommandClass( WakeUp::StaticGetCommandClassId() ) ) )
{
// Mark the node as asleep
wakeUp->SetAwake( false );
// If we need to save the messages
if( _move )
{
// Move all messages for this node to the wake-up queue
m_sendMutex->Lock();
// See if we are working on a controller command
if( m_currentControllerCommand )
{
// Don't save controller message as it will be recreated
RemoveCurrentMsg();
}
// Then try the current message first
if( m_currentMsg )
{
if( _targetNodeId == m_currentMsg->GetTargetNodeId() )
{
// This message is for the unresponsive node
// We do not move any "Wake Up No More Information"
// commands or NoOperations to the pending queue.
if( !m_currentMsg->IsWakeUpNoMoreInformationCommand() && !m_currentMsg->IsNoOperation() )
{
Log::Write( LogLevel_Info, _targetNodeId, "Node not responding - moving message to Wake-Up queue: %s", m_currentMsg->GetAsString().c_str() );
/* reset the sendAttempts */
m_currentMsg->SetSendAttempts(0);
MsgQueueItem item;
item.m_command = MsgQueueCmd_SendMsg;
item.m_msg = m_currentMsg;
wakeUp->QueueMsg( item );
}
else
{
delete m_currentMsg;
}
m_currentMsg = NULL;
m_expectedCallbackId = 0;
m_expectedCommandClassId = 0;
m_expectedNodeId = 0;
m_expectedReply = 0;
m_waitingForAck = false;
}
}
// Now the message queues
for( int i=0; i::iterator it = m_msgQueue[i].begin();
while( it != m_msgQueue[i].end() )
{
bool remove = false;
MsgQueueItem const& item = *it;
if( MsgQueueCmd_SendMsg == item.m_command )
{
if( _targetNodeId == item.m_msg->GetTargetNodeId() )
{
// This message is for the unresponsive node
// We do not move any "Wake Up No More Information"
// commands or NoOperations to the pending queue.
if( !item.m_msg->IsWakeUpNoMoreInformationCommand() && !item.m_msg->IsNoOperation() )
{
Log::Write( LogLevel_Info, item.m_msg->GetTargetNodeId(), "Node not responding - moving message to Wake-Up queue: %s", item.m_msg->GetAsString().c_str() );
/* reset any SendAttempts */
item.m_msg->SetSendAttempts(0);
wakeUp->QueueMsg( item );
}
else
{
delete item.m_msg;
}
remove = true;
}
}
if( MsgQueueCmd_QueryStageComplete == item.m_command )
{
if( _targetNodeId == item.m_nodeId )
{
Log::Write( LogLevel_Info, _targetNodeId, "Node not responding - moving QueryStageComplete command to Wake-Up queue" );
wakeUp->QueueMsg( item );
remove = true;
}
}
if( MsgQueueCmd_Controller == item.m_command )
{
if( _targetNodeId == item.m_cci->m_controllerCommandNode )
{
Log::Write( LogLevel_Info, _targetNodeId, "Node not responding - moving controller command to Wake-Up queue: %s", c_controllerCommandNames[item.m_cci->m_controllerCommand] );
wakeUp->QueueMsg( item );
remove = true;
}
}
if( remove )
{
it = m_msgQueue[i].erase( it );
}
else
{
++it;
}
}
// If the queue is now empty, we need to clear its event
if( m_msgQueue[i].empty() )
{
m_queueEvent[i]->Reset();
}
}
if( m_currentControllerCommand )
{
// Put command back on queue so it will be cleaned up
UpdateControllerState( ControllerState_Sleeping );
MsgQueueItem item;
item.m_command = MsgQueueCmd_Controller;
item.m_cci = new ControllerCommandItem( *m_currentControllerCommand );
m_currentControllerCommand = item.m_cci;
m_msgQueue[MsgQueue_Controller].push_back( item );
m_queueEvent[MsgQueue_Controller]->Set();
}
m_sendMutex->Unlock();
// Move completed successfully
return true;
}
}
}
}
// Failed to move messages
return false;
}
//-----------------------------------------------------------------------------
//
// For messages that return a ZW_SEND_DATA response, process the results here
// If it is a non-listeing (sleeping) node return true.
//-----------------------------------------------------------------------------
bool Driver::HandleErrorResponse
(
uint8 const _error,
uint8 const _nodeId,
char const* _funcStr,
bool _sleepCheck // = 0
)
{
// Only called with a ZW_SEND_DATA error response. We count and output the message here.
if( _error == TRANSMIT_COMPLETE_NOROUTE )
{
m_badroutes++;
Log::Write( LogLevel_Info, _nodeId, "ERROR: %s failed. No route available.", _funcStr );
}
else if( _error == TRANSMIT_COMPLETE_NO_ACK )
{
m_noack++;
Log::Write( LogLevel_Info, _nodeId, "WARNING: %s failed. No ACK received - device may be asleep.", _funcStr );
if( m_currentMsg )
{
// In case the failure is due to the target being a sleeping node, we
// first try to move its pending messages to its wake-up queue.
if( MoveMessagesToWakeUpQueue( m_currentMsg->GetTargetNodeId(), _sleepCheck ) )
{
return true;
}
Log::Write( LogLevel_Warning, _nodeId, "WARNING: Device is not a sleeping node." );
}
}
else if( _error == TRANSMIT_COMPLETE_FAIL )
{
m_netbusy++;
Log::Write( LogLevel_Info, _nodeId, "ERROR: %s failed. Network is busy.", _funcStr );
}
else if( _error == TRANSMIT_COMPLETE_NOT_IDLE )
{
m_notidle++;
Log::Write( LogLevel_Info, _nodeId, "ERROR: %s failed. Network is busy.", _funcStr );
}
if( Node* node = GetNodeUnsafe( _nodeId ) )
{
if( ++node->m_errors >= 3 )
{
node->SetNodeAlive( false );
}
}
return false;
}
//-----------------------------------------------------------------------------
//
// Identify controller (as opposed to node) commands...especially blocking ones
//-----------------------------------------------------------------------------
void Driver::CheckCompletedNodeQueries
(
)
{
Log::Write( LogLevel_Warning, "CheckCompletedNodeQueries m_allNodesQueried=%d m_awakeNodesQueried=%d", m_allNodesQueried, m_awakeNodesQueried );
if( !m_allNodesQueried )
{
bool all = true;
bool sleepingOnly = true;
bool deadFound = false;
LockGuard LG(m_nodeMutex);
for( int i=0; i<256; ++i )
{
if( m_nodes[i] )
{
if( m_nodes[i]->GetCurrentQueryStage() != Node::QueryStage_Complete )
{
if ( !m_nodes[i]->IsNodeAlive() )
{
deadFound = true;
continue;
}
all = false;
if( m_nodes[i]->IsListeningDevice() )
{
sleepingOnly = false;
}
}
}
}
LG.Unlock();
Log::Write( LogLevel_Warning, "CheckCompletedNodeQueries all=%d, deadFound=%d sleepingOnly=%d", all, deadFound, sleepingOnly );
if( all )
{
if( deadFound )
{
// only dead nodes left to query
Log::Write( LogLevel_Info, " Node query processing complete except for dead nodes." );
Notification* notification = new Notification( Notification::Type_AllNodesQueriedSomeDead );
notification->SetHomeAndNodeIds( m_homeId, 0xff );
QueueNotification( notification );
}
else
{
// no sleeping nodes, no dead nodes and no more nodes in the queue, so...All done
Log::Write( LogLevel_Info, " Node query processing complete." );
Notification* notification = new Notification( Notification::Type_AllNodesQueried );
notification->SetHomeAndNodeIds( m_homeId, 0xff );
QueueNotification( notification );
}
m_awakeNodesQueried = true;
m_allNodesQueried = true;
}
else if( sleepingOnly )
{
if (!m_awakeNodesQueried )
{
// only sleeping nodes remain, so signal awake nodes queried complete
Log::Write( LogLevel_Info, " Node query processing complete except for sleeping nodes." );
Notification* notification = new Notification( Notification::Type_AwakeNodesQueried );
notification->SetHomeAndNodeIds( m_homeId, 0xff );
QueueNotification( notification );
m_awakeNodesQueried = true;
}
}
}
}
//-----------------------------------------------------------------------------
//
// Determine if the reply is from the node we are expecting.
//-----------------------------------------------------------------------------
bool Driver::IsExpectedReply
(
const uint8 _nodeId
)
{
// Accept all controller commands or where the protocol doesn't identify the actual node
if( m_expectedNodeId == 255 || _nodeId == 0 )
{
return true;
}
// Accept all messages that do not convey source node identification.
if( m_expectedReply == FUNC_ID_ZW_GET_NODE_PROTOCOL_INFO ||
m_expectedReply == FUNC_ID_ZW_REQUEST_NODE_INFO ||
m_expectedReply == FUNC_ID_ZW_GET_ROUTING_INFO ||
m_expectedReply == FUNC_ID_ZW_ASSIGN_RETURN_ROUTE ||
m_expectedReply == FUNC_ID_ZW_DELETE_RETURN_ROUTE ||
m_expectedReply == FUNC_ID_ZW_SEND_DATA ||
m_expectedReply == FUNC_ID_ZW_SEND_NODE_INFORMATION ||
m_expectedReply == FUNC_ID_ZW_REQUEST_NODE_NEIGHBOR_UPDATE ||
m_expectedReply == FUNC_ID_ZW_ENABLE_SUC ||
m_expectedReply == FUNC_ID_ZW_SET_SUC_NODE_ID ||
m_expectedReply == FUNC_ID_ZW_REQUEST_NODE_NEIGHBOR_UPDATE_OPTIONS )
{
return true;
}
// Accept if source message contains node info and it is from the one we are expecting
if( m_expectedNodeId == _nodeId )
{
return true;
}
Log::Write( LogLevel_Detail, "IsExpectedReply: m_expectedNodeId = %d m_expectedReply = %02x", m_expectedNodeId, m_expectedReply );
return false;
}
//-----------------------------------------------------------------------------
// Receiving Z-Wave messages
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//
// Read data from the serial port
//-----------------------------------------------------------------------------
bool Driver::ReadMsg
(
)
{
uint8 buffer[1024] = {0};
if( !m_controller->Read( buffer, 1 ) )
{
// Nothing to read
return false;
}
switch( buffer[0] )
{
case SOF:
{
m_SOFCnt++;
if( m_waitingForAck )
{
// This can happen on any normal network when a transmission overlaps an unexpected
// reception and the data in the buffer doesn't contain the ACK. The controller will
// notice and send us a CAN to retransmit.
Log::Write( LogLevel_Detail, "Unsolicited message received while waiting for ACK." );
m_ACKWaiting++;
}
// Read the length byte. Keep trying until we get it.
m_controller->SetSignalThreshold( 1 );
int32 response = Wait::Single( m_controller, 50 );
if( response < 0 )
{
Log::Write( LogLevel_Warning, "WARNING: 50ms passed without finding the length byte...aborting frame read");
m_readAborts++;
break;
}
m_controller->Read( &buffer[1], 1 );
m_controller->SetSignalThreshold( buffer[1] );
if( Wait::Single( m_controller, 500 ) < 0 )
{
Log::Write( LogLevel_Warning, "WARNING: 500ms passed without reading the rest of the frame...aborting frame read" );
m_readAborts++;
m_controller->SetSignalThreshold( 1 );
break;
}
m_controller->Read( &buffer[2], buffer[1] );
m_controller->SetSignalThreshold( 1 );
uint32 length = buffer[1] + 2;
// Log the data
string str = "";
for( uint32 i=0; iWrite( &ack, 1 );
m_readCnt++;
// Process the received message
ProcessMsg( &buffer[2] );
}
else
{
Log::Write( LogLevel_Warning, nodeId, "WARNING: Checksum incorrect - sending NAK" );
m_badChecksum++;
uint8 nak = NAK;
m_controller->Write( &nak, 1 );
m_controller->Purge();
}
break;
}
case CAN:
{
// This is the other side of an unsolicited ACK. As mentioned there if we receive a message
// just after we transmitted one, the controller will notice and tell us to retransmit here.
// Don't increment the transmission counter as it is possible the message will never get out
// on very busy networks with lots of unsolicited messages being received. Increase the amount
// of retries but only up to a limit so we don't stay here forever.
Log::Write( LogLevel_Detail, GetNodeNumber( m_currentMsg ), "CAN received...triggering resend" );
m_CANCnt++;
if( m_currentMsg != NULL )
{
m_currentMsg->SetMaxSendAttempts( m_currentMsg->GetMaxSendAttempts() + 1 );
}
else
{
Log::Write( LogLevel_Warning, "m_currentMsg was NULL when trying to set MaxSendAttempts" );
Log::QueueDump();
}
WriteMsg( "CAN" );
break;
}
case NAK:
{
Log::Write( LogLevel_Warning, GetNodeNumber( m_currentMsg ), "WARNING: NAK received...triggering resend" );
m_NAKCnt++;
WriteMsg( "NAK" );
break;
}
case ACK:
{
m_ACKCnt++;
m_waitingForAck = false;
if( m_currentMsg == NULL )
{
Log::Write( LogLevel_StreamDetail, 255, " ACK received" );
}
else
{
Log::Write( LogLevel_StreamDetail, GetNodeNumber( m_currentMsg ), " ACK received CallbackId 0x%.2x Reply 0x%.2x", m_expectedCallbackId, m_expectedReply );
if( ( 0 == m_expectedCallbackId ) && ( 0 == m_expectedReply ) )
{
// Remove the message from the queue, now that it has been acknowledged.
RemoveCurrentMsg();
}
}
break;
}
default:
{
Log::Write( LogLevel_Warning, "WARNING: Out of frame flow! (0x%.2x). Sending NAK.", buffer[0] );
m_OOFCnt++;
uint8 nak = NAK;
m_controller->Write( &nak, 1 );
m_controller->Purge();
break;
}
}
return true;
}
//-----------------------------------------------------------------------------
//
// Process data received from the Z-Wave PC interface
//-----------------------------------------------------------------------------
void Driver::ProcessMsg
(
uint8* _data
)
{
bool handleCallback = true;
bool wasencrypted = false;
//uint8 nodeId = GetNodeNumber( m_currentMsg );
if ((REQUEST == _data[0]) &&
(Security::StaticGetCommandClassId() == _data[5])) {
/* if this message is a NONCE Report - Then just Trigger the Encrypted Send */
if (SecurityCmd_NonceReport == _data[6]) {
Log::Write(LogLevel_Info, _data[3], "Received SecurityCmd_NonceReport from node %d", _data[3] );
// No Need to triger a WriteMsg here - It should be handled automatically
m_currentMsg->setNonce(&_data[7]);
this->SendEncryptedMessage();
return;
/* if this is a NONCE Get - Then call to the CC directly, process it, and then bail out. */
} else if (SecurityCmd_NonceGet == _data[6]) {
Log::Write(LogLevel_Info, _data[3], "Received SecurityCmd_NonceGet from node %d", _data[3] );
{
uint8 *nonce = NULL;
LockGuard LG(m_nodeMutex);
Node* node = GetNode( _data[3] );
if( node ) {
nonce = node->GenerateNonceKey();
} else {
Log::Write(LogLevel_Warning, _data[3], "Couldn't Generate Nonce Key for Node %d", _data[3]);
return;
}
SendNonceKey(_data[3], nonce);
}
/* don't continue processing */
return;
/* if this message is encrypted, decrypt it first */
} else if ((SecurityCmd_MessageEncap == _data[6]) || (SecurityCmd_MessageEncapNonceGet == _data[6])) {
uint8 _newdata[256];
uint8 *_nonce;
/* clear out NONCE Report tracking */
m_nonceReportSent = 0;
m_nonceReportSentAttempt = 0;
/* make sure the Node Exists, and it has the Security CC */
{
LockGuard LG(m_nodeMutex);
Node* node = GetNode( _data[3] );
if( node ) {
_nonce = node->GetNonceKey(_data[_data[4]-4]);
if (!_nonce) {
Log::Write(LogLevel_Warning, _data[3], "Could Not Retrieve Nonce for Node %d", _data[3]);
return;
}
} else {
Log::Write(LogLevel_Warning, _data[3], "Can't Find Node %d for Encrypted Message", _data[3]);
return;
}
}
if (DecryptBuffer(&_data[5], _data[4]+1, this, _data[3], this->GetControllerNodeId(), _nonce, &_newdata[0])) {
/* Ok - _newdata now contains the decrypted packet */
/* copy it back to the _data packet for processing */
/* New Length - See Decrypt Packet for why these numbers*/
_data[4] = _data[4] - 8 - 8 - 2 - 2;
/* now copy the decrypted packet */
memcpy(&_data[5], &_newdata[1], _data[4]);
//PrintHex("Decrypted Packet", _data, _data[4]+5);
/* if the Node has something else to send, it will encrypt a message and send it as a MessageEncapNonceGet */
if (SecurityCmd_MessageEncapNonceGet == _data[6])
{
Log::Write(LogLevel_Info, _data[3], "Received SecurityCmd_MessageEncapNonceGet from node %d - Sending New Nonce", _data[3] );
LockGuard LG(m_nodeMutex);
Node* node = GetNode( _data[3] );
if( node ) {
_nonce = node->GenerateNonceKey();
} else {
Log::Write(LogLevel_Warning, _data[3], "Couldn't Generate Nonce Key for Node %d", _data[3]);
return;
}
SendNonceKey(_data[3], _nonce);
}
wasencrypted = true;
} else {
/* it failed for some reason, lets just move on */
m_expectedReply = 0;
m_expectedNodeId = 0;
RemoveCurrentMsg();
return;
}
}
}
if( RESPONSE == _data[0] )
{
switch( _data[1] )
{
case FUNC_ID_SERIAL_API_GET_INIT_DATA:
{
Log::Write( LogLevel_Detail, "" );
HandleSerialAPIGetInitDataResponse( _data );
break;
}
case FUNC_ID_ZW_GET_CONTROLLER_CAPABILITIES:
{
Log::Write( LogLevel_Detail, "" );
HandleGetControllerCapabilitiesResponse( _data );
break;
}
case FUNC_ID_SERIAL_API_GET_CAPABILITIES:
{
Log::Write( LogLevel_Detail, "" );
HandleGetSerialAPICapabilitiesResponse( _data );
break;
}
case FUNC_ID_SERIAL_API_SOFT_RESET:
{
Log::Write( LogLevel_Detail, "" );
HandleSerialAPISoftResetResponse( _data );
break;
}
case FUNC_ID_ZW_SEND_DATA:
{
HandleSendDataResponse( _data, false );
handleCallback = false; // Skip the callback handling - a subsequent FUNC_ID_ZW_SEND_DATA request will deal with that
break;
}
case FUNC_ID_ZW_GET_VERSION:
{
Log::Write( LogLevel_Detail, "" );
HandleGetVersionResponse( _data );
break;
}
case FUNC_ID_ZW_GET_RANDOM:
{
Log::Write( LogLevel_Detail, "" );
HandleGetRandomResponse( _data );
break;
}
case FUNC_ID_ZW_MEMORY_GET_ID:
{
Log::Write( LogLevel_Detail, "" );
HandleMemoryGetIdResponse( _data );
break;
}
case FUNC_ID_ZW_GET_NODE_PROTOCOL_INFO:
{
Log::Write( LogLevel_Detail, "" );
HandleGetNodeProtocolInfoResponse( _data );
break;
}
case FUNC_ID_ZW_REPLICATION_SEND_DATA:
{
HandleSendDataResponse( _data, true );
handleCallback = false; // Skip the callback handling - a subsequent FUNC_ID_ZW_REPLICATION_SEND_DATA request will deal with that
break;
}
case FUNC_ID_ZW_ASSIGN_RETURN_ROUTE:
{
Log::Write( LogLevel_Detail, "" );
if( !HandleAssignReturnRouteResponse( _data ) )
{
m_expectedCallbackId = _data[2]; // The callback message won't be coming, so we force the transaction to complete
m_expectedReply = 0;
m_expectedCommandClassId = 0;
m_expectedNodeId = 0;
}
break;
}
case FUNC_ID_ZW_DELETE_RETURN_ROUTE:
{
Log::Write( LogLevel_Detail, "" );
if( !HandleDeleteReturnRouteResponse( _data ) )
{
m_expectedCallbackId = _data[2]; // The callback message won't be coming, so we force the transaction to complete
m_expectedReply = 0;
m_expectedCommandClassId = 0;
m_expectedNodeId = 0;
}
break;
}
case FUNC_ID_ZW_ENABLE_SUC:
{
Log::Write( LogLevel_Detail, "" );
HandleEnableSUCResponse( _data );
break;
}
case FUNC_ID_ZW_REQUEST_NETWORK_UPDATE:
{
Log::Write( LogLevel_Detail, "" );
if( !HandleNetworkUpdateResponse( _data ) )
{
m_expectedCallbackId = _data[2]; // The callback message won't be coming, so we force the transaction to complete
m_expectedReply = 0;
m_expectedCommandClassId = 0;
m_expectedNodeId = 0;
}
break;
}
case FUNC_ID_ZW_SET_SUC_NODE_ID:
{
Log::Write( LogLevel_Detail, "" );
HandleSetSUCNodeIdResponse( _data );
break;
}
case FUNC_ID_ZW_GET_SUC_NODE_ID:
{
Log::Write( LogLevel_Detail, "" );
HandleGetSUCNodeIdResponse( _data );
break;
}
case FUNC_ID_ZW_REQUEST_NODE_INFO:
{
Log::Write( LogLevel_Detail, "" );
if( _data[2] )
{
Log::Write( LogLevel_Info, _data[3], "FUNC_ID_ZW_REQUEST_NODE_INFO Request successful." );
}
else
{
Log::Write( LogLevel_Info, _data[3], "FUNC_ID_ZW_REQUEST_NODE_INFO Request failed." );
}
break;
}
case FUNC_ID_ZW_REMOVE_FAILED_NODE_ID:
{
Log::Write( LogLevel_Detail, "" );
if( !HandleRemoveFailedNodeResponse( _data ) )
{
m_expectedCallbackId = _data[2]; // The callback message won't be coming, so we force the transaction to complete
m_expectedReply = 0;
m_expectedCommandClassId = 0;
m_expectedNodeId = 0;
}
break;
}
case FUNC_ID_ZW_IS_FAILED_NODE_ID:
{
Log::Write( LogLevel_Detail, "" );
HandleIsFailedNodeResponse( _data );
break;
}
case FUNC_ID_ZW_REPLACE_FAILED_NODE:
{
Log::Write( LogLevel_Detail, "" );
if( !HandleReplaceFailedNodeResponse( _data ) )
{
m_expectedCallbackId = _data[2]; // The callback message won't be coming, so we force the transaction to complete
m_expectedReply = 0;
m_expectedCommandClassId = 0;
m_expectedNodeId = 0;
}
break;
}
case FUNC_ID_ZW_GET_ROUTING_INFO:
{
Log::Write( LogLevel_Detail, "" );
HandleGetRoutingInfoResponse( _data );
break;
}
case FUNC_ID_ZW_R_F_POWER_LEVEL_SET:
{
Log::Write( LogLevel_Detail, "" );
HandleRfPowerLevelSetResponse( _data );
break;
}
case FUNC_ID_ZW_READ_MEMORY:
{
Log::Write( LogLevel_Detail, "" );
HandleReadMemoryResponse( _data );
break;
}
case FUNC_ID_SERIAL_API_SET_TIMEOUTS:
{
Log::Write( LogLevel_Detail, "" );
HandleSerialApiSetTimeoutsResponse( _data );
break;
}
case FUNC_ID_MEMORY_GET_BYTE:
{
Log::Write( LogLevel_Detail, "" );
HandleMemoryGetByteResponse( _data );
break;
}
case FUNC_ID_ZW_GET_VIRTUAL_NODES:
{
Log::Write( LogLevel_Detail, "" );
HandleGetVirtualNodesResponse( _data );
break;
}
case FUNC_ID_ZW_SET_SLAVE_LEARN_MODE:
{
Log::Write( LogLevel_Detail, "" );
if( !HandleSetSlaveLearnModeResponse( _data ) )
{
m_expectedCallbackId = _data[2]; // The callback message won't be coming, so we force the transaction to complete
m_expectedReply = 0;
m_expectedCommandClassId = 0;
m_expectedNodeId = 0;
}
break;
}
case FUNC_ID_ZW_SEND_SLAVE_NODE_INFO:
{
Log::Write( LogLevel_Detail, "" );
if( !HandleSendSlaveNodeInfoResponse( _data ) )
{
m_expectedCallbackId = _data[2]; // The callback message won't be coming, so we force the transaction to complete
m_expectedReply = 0;
m_expectedCommandClassId = 0;
m_expectedNodeId = 0;
}
break;
}
default:
{
Log::Write( LogLevel_Detail, "" );
Log::Write( LogLevel_Info, "**TODO: handle response for 0x%.2x** Please report this message.", _data[1] );
break;
}
}
}
else if( REQUEST == _data[0] )
{
switch( _data[1] )
{
case FUNC_ID_APPLICATION_COMMAND_HANDLER:
{
Log::Write( LogLevel_Detail, "" );
HandleApplicationCommandHandlerRequest( _data, wasencrypted );
break;
}
case FUNC_ID_ZW_SEND_DATA:
{
HandleSendDataRequest( _data, false );
break;
}
case FUNC_ID_ZW_REPLICATION_COMMAND_COMPLETE:
{
if( m_controllerReplication )
{
Log::Write( LogLevel_Detail, "" );
m_controllerReplication->SendNextData();
}
break;
}
case FUNC_ID_ZW_REPLICATION_SEND_DATA:
{
HandleSendDataRequest( _data, true );
break;
}
case FUNC_ID_ZW_ASSIGN_RETURN_ROUTE:
{
Log::Write( LogLevel_Detail, "" );
HandleAssignReturnRouteRequest( _data );
break;
}
case FUNC_ID_ZW_DELETE_RETURN_ROUTE:
{
Log::Write( LogLevel_Detail, "" );
HandleDeleteReturnRouteRequest( _data );
break;
}
case FUNC_ID_ZW_SEND_NODE_INFORMATION:
{
Log::Write( LogLevel_Detail, "" );
HandleSendNodeInformationRequest( _data );
break;
}
case FUNC_ID_ZW_REQUEST_NODE_NEIGHBOR_UPDATE:
case FUNC_ID_ZW_REQUEST_NODE_NEIGHBOR_UPDATE_OPTIONS:
{
Log::Write( LogLevel_Detail, "" );
HandleNodeNeighborUpdateRequest( _data );
break;
}
case FUNC_ID_ZW_APPLICATION_UPDATE:
{
Log::Write( LogLevel_Detail, "" );
handleCallback = !HandleApplicationUpdateRequest( _data );
break;
}
case FUNC_ID_ZW_ADD_NODE_TO_NETWORK:
{
Log::Write( LogLevel_Detail, "" );
HandleAddNodeToNetworkRequest( _data );
break;
}
case FUNC_ID_ZW_REMOVE_NODE_FROM_NETWORK:
{
Log::Write( LogLevel_Detail, "" );
HandleRemoveNodeFromNetworkRequest( _data );
break;
}
case FUNC_ID_ZW_CREATE_NEW_PRIMARY:
{
Log::Write( LogLevel_Detail, "" );
HandleCreateNewPrimaryRequest( _data );
break;
}
case FUNC_ID_ZW_CONTROLLER_CHANGE:
{
Log::Write( LogLevel_Detail, "" );
HandleControllerChangeRequest( _data );
break;
}
case FUNC_ID_ZW_SET_LEARN_MODE:
{
Log::Write( LogLevel_Detail, "" );
HandleSetLearnModeRequest( _data );
break;
}
case FUNC_ID_ZW_REQUEST_NETWORK_UPDATE:
{
Log::Write( LogLevel_Detail, "" );
HandleNetworkUpdateRequest( _data );
break;
}
case FUNC_ID_ZW_REMOVE_FAILED_NODE_ID:
{
Log::Write( LogLevel_Detail, "" );
HandleRemoveFailedNodeRequest( _data );
break;
}
case FUNC_ID_ZW_REPLACE_FAILED_NODE:
{
Log::Write( LogLevel_Detail, "" );
HandleReplaceFailedNodeRequest( _data );
break;
}
case FUNC_ID_ZW_SET_SLAVE_LEARN_MODE:
{
Log::Write( LogLevel_Detail, "" );
HandleSetSlaveLearnModeRequest( _data );
break;
}
case FUNC_ID_ZW_SEND_SLAVE_NODE_INFO:
{
Log::Write( LogLevel_Detail, "" );
HandleSendSlaveNodeInfoRequest( _data );
break;
}
case FUNC_ID_APPLICATION_SLAVE_COMMAND_HANDLER:
{
Log::Write( LogLevel_Detail, "" );
HandleApplicationSlaveCommandRequest( _data );
break;
}
case FUNC_ID_PROMISCUOUS_APPLICATION_COMMAND_HANDLER:
{
Log::Write( LogLevel_Detail, "" );
HandlePromiscuousApplicationCommandHandlerRequest( _data );
break;
}
case FUNC_ID_ZW_SET_DEFAULT:
{
Log::Write( LogLevel_Detail, "" );
HandleSerialAPIResetRequest( _data );
break;
}
default:
{
Log::Write( LogLevel_Detail, "" );
Log::Write( LogLevel_Info, "**TODO: handle request for 0x%.2x** Please report this message.", _data[1] );
break;
}
}
}
// Generic callback handling
if( handleCallback )
{
if( ( m_expectedCallbackId || m_expectedReply ) )
{
if( m_expectedCallbackId )
{
if( m_expectedCallbackId == _data[2] )
{
Log::Write( LogLevel_Detail, _data[3], " Expected callbackId was received" );
m_expectedCallbackId = 0;
} else if (_data[2] == 0x02 || _data[2] == 0x01) {
/* it was a NONCE request/reply. Drop it */
return;
}
}
if( m_expectedReply )
{
if( m_expectedReply == _data[1] )
{
if( m_expectedCommandClassId && ( m_expectedReply == FUNC_ID_APPLICATION_COMMAND_HANDLER ) )
{
if( m_expectedCallbackId == 0 && m_expectedCommandClassId == _data[5] && m_expectedNodeId == _data[3] )
{
Log::Write( LogLevel_Detail, _data[3], " Expected reply and command class was received" );
m_waitingForAck = false;
m_expectedReply = 0;
m_expectedCommandClassId = 0;
m_expectedNodeId = 0;
}
}
else
{
if( IsExpectedReply( _data[3] ) )
{
Log::Write( LogLevel_Detail, _data[3], " Expected reply was received" );
m_expectedReply = 0;
m_expectedNodeId = 0;
}
}
}
}
if( !( m_expectedCallbackId || m_expectedReply ) )
{
Log::Write( LogLevel_Detail, _data[3], " Message transaction complete" );
Log::Write( LogLevel_Detail, "" );
if( m_notifytransactions )
{
Notification* notification = new Notification( Notification::Type_Notification );
notification->SetHomeAndNodeIds( m_homeId, _data[3] );
notification->SetNotification( Notification::Code_MsgComplete );
QueueNotification( notification );
}
RemoveCurrentMsg();
}
}
}
}
//-----------------------------------------------------------------------------
//
// Process a response from the Z-Wave PC interface
//-----------------------------------------------------------------------------
void Driver::HandleGetVersionResponse
(
uint8* _data
)
{
m_libraryVersion = (char*)&_data[2];
m_libraryType = _data[m_libraryVersion.size()+3];
if( m_libraryType < 9 )
{
m_libraryTypeName = c_libraryTypeNames[m_libraryType];
}
Log::Write( LogLevel_Info, GetNodeNumber( m_currentMsg ), "Received reply to FUNC_ID_ZW_GET_VERSION:" );
Log::Write( LogLevel_Info, GetNodeNumber( m_currentMsg ), " %s library, version %s", m_libraryTypeName.c_str(), m_libraryVersion.c_str() );
}
//-----------------------------------------------------------------------------
//
// Process a response from the Z-Wave PC interface
//-----------------------------------------------------------------------------
void Driver::HandleGetRandomResponse
(
uint8* _data
)
{
Log::Write( LogLevel_Info, GetNodeNumber( m_currentMsg ), "Received reply to FUNC_ID_ZW_GET_RANDOM: %s", _data[2] ? "true" : "false" );
}
//-----------------------------------------------------------------------------
//
// Process a response from the Z-Wave PC interface
//-----------------------------------------------------------------------------
void Driver::HandleGetControllerCapabilitiesResponse
(
uint8* _data
)
{
m_controllerCaps = _data[2];
Log::Write( LogLevel_Info, GetNodeNumber( m_currentMsg ), "Received reply to FUNC_ID_ZW_GET_CONTROLLER_CAPABILITIES:" );
char str[256];
if( m_controllerCaps & ControllerCaps_SIS )
{
Log::Write( LogLevel_Info, GetNodeNumber( m_currentMsg ), " There is a SUC ID Server (SIS) in this network." );
snprintf( str, sizeof(str), " The PC controller is an inclusion %s%s%s",
( m_controllerCaps & ControllerCaps_SUC ) ? "static update controller (SUC)" : "controller",
( m_controllerCaps & ControllerCaps_OnOtherNetwork ) ? " which is using a Home ID from another network" : "",
( m_controllerCaps & ControllerCaps_RealPrimary ) ? " and was the original primary before the SIS was added." : "." );
Log::Write( LogLevel_Info, GetNodeNumber( m_currentMsg ), str );
}
else
{
Log::Write( LogLevel_Info, GetNodeNumber( m_currentMsg ), " There is no SUC ID Server (SIS) in this network." );
snprintf( str, sizeof(str), " The PC controller is a %s%s%s",
( m_controllerCaps & ControllerCaps_Secondary ) ? "secondary" : "primary",
( m_controllerCaps & ControllerCaps_SUC ) ? " static update controller (SUC)" : " controller",
( m_controllerCaps & ControllerCaps_OnOtherNetwork ) ? " which is using a Home ID from another network." : "." );
Log::Write( LogLevel_Info, GetNodeNumber( m_currentMsg ), str );
}
}
//-----------------------------------------------------------------------------
//
// Process a response from the Z-Wave PC interface
//-----------------------------------------------------------------------------
void Driver::HandleGetSerialAPICapabilitiesResponse
(
uint8* _data
)
{
Log::Write( LogLevel_Info, GetNodeNumber( m_currentMsg ), " Received reply to FUNC_ID_SERIAL_API_GET_CAPABILITIES" );
Log::Write( LogLevel_Info, GetNodeNumber( m_currentMsg ), " Serial API Version: %d.%d", _data[2], _data[3] );
Log::Write( LogLevel_Info, GetNodeNumber( m_currentMsg ), " Manufacturer ID: 0x%.2x%.2x", _data[4], _data[5] );
Log::Write( LogLevel_Info, GetNodeNumber( m_currentMsg ), " Product Type: 0x%.2x%.2x", _data[6], _data[7] );
Log::Write( LogLevel_Info, GetNodeNumber( m_currentMsg ), " Product ID: 0x%.2x%.2x", _data[8], _data[9] );
// _data[10] to _data[41] are a 256-bit bitmask with one bit set for
// each FUNC_ID_ method supported by the controller.
// Bit 0 is FUNC_ID_ 1. So FUNC_ID_SERIAL_API_GET_CAPABILITIES (0x07) will be bit 6 of the first byte.
m_serialAPIVersion[0] = _data[2];
m_serialAPIVersion[1] = _data[3];
m_manufacturerId = ( ( (uint16)_data[4] )<<8) | (uint16)_data[5];
m_productType = ( ( (uint16)_data[6] )<<8 ) | (uint16)_data[7];
m_productId = ( ( (uint16)_data[8] )<<8 ) | (uint16)_data[9];
memcpy( m_apiMask, &_data[10], sizeof( m_apiMask ) );
if( IsBridgeController() )
{
SendMsg( new Msg( "FUNC_ID_ZW_GET_VIRTUAL_NODES", 0xff, REQUEST, FUNC_ID_ZW_GET_VIRTUAL_NODES, false ), MsgQueue_Command);
}
else if( IsAPICallSupported( FUNC_ID_ZW_GET_RANDOM ) )
{
Msg *msg = new Msg( "FUNC_ID_ZW_GET_RANDOM", 0xff, REQUEST, FUNC_ID_ZW_GET_RANDOM, false );
msg->Append( 32 ); // 32 bytes
SendMsg( msg, MsgQueue_Command );
}
SendMsg( new Msg( "FUNC_ID_SERIAL_API_GET_INIT_DATA", 0xff, REQUEST, FUNC_ID_SERIAL_API_GET_INIT_DATA, false ), MsgQueue_Command);
if( !IsBridgeController() )
{
Msg* msg = new Msg( "FUNC_ID_SERIAL_API_SET_TIMEOUTS", 0xff, REQUEST, FUNC_ID_SERIAL_API_SET_TIMEOUTS, false );
msg->Append( ACK_TIMEOUT / 10 );
msg->Append( BYTE_TIMEOUT / 10 );
SendMsg( msg, MsgQueue_Command );
}
Msg* msg = new Msg( "FUNC_ID_SERIAL_API_APPL_NODE_INFORMATION", 0xff, REQUEST, FUNC_ID_SERIAL_API_APPL_NODE_INFORMATION, false, false );
msg->Append( APPLICATION_NODEINFO_LISTENING );
msg->Append( 0x02 ); // Generic Static Controller
msg->Append( 0x01 ); // Specific Static PC Controller
msg->Append( 0x00 ); // Length
SendMsg( msg, MsgQueue_Command );
}
//-----------------------------------------------------------------------------
//
// Process a response from the Z-Wave PC interface
//-----------------------------------------------------------------------------
void Driver::HandleSerialAPISoftResetResponse
(
uint8* _data
)
{
Log::Write( LogLevel_Info, GetNodeNumber( m_currentMsg ), "Received reply to Soft Reset." );
}
//-----------------------------------------------------------------------------
//
// Process a response from the Z-Wave PC interface
//-----------------------------------------------------------------------------
void Driver::HandleSerialAPIResetRequest
(
uint8* _data
)
{
Log::Write( LogLevel_Info, GetNodeNumber( m_currentMsg ), "Received reply to complete Controller Reset." );
if( m_controllerResetEvent != NULL )
{
m_controllerResetEvent->Set();
m_controllerResetEvent = NULL;
}
}
//-----------------------------------------------------------------------------
//
// Process a response from the Z-Wave PC interface
//-----------------------------------------------------------------------------
void Driver::HandleEnableSUCResponse
(
uint8* _data
)
{
Log::Write( LogLevel_Info, GetNodeNumber( m_currentMsg ), "Received reply to Enable SUC." );
}
//-----------------------------------------------------------------------------
//
// Process a response from the Z-Wave PC interface
//-----------------------------------------------------------------------------
bool Driver::HandleNetworkUpdateResponse
(
uint8* _data
)
{
bool res = true;
ControllerState state = ControllerState_InProgress;
if( _data[2] )
{
Log::Write( LogLevel_Info, GetNodeNumber( m_currentMsg ), "Received reply to FUNC_ID_ZW_REQUEST_NETWORK_UPDATE - command in progress" );
}
else
{
// Failed
Log::Write( LogLevel_Warning, GetNodeNumber( m_currentMsg ), "WARNING: Received reply to FUNC_ID_ZW_REQUEST_NETWORK_UPDATE - command failed" );
state = ControllerState_Failed;
res = false;
}
UpdateControllerState( state );
return res;
}
//-----------------------------------------------------------------------------
//
// Process a response from the Z-Wave PC interface
//-----------------------------------------------------------------------------
void Driver::HandleSetSUCNodeIdResponse
(
uint8* _data
)
{
Log::Write( LogLevel_Info, GetNodeNumber( m_currentMsg ), "Received reply to SET_SUC_NODE_ID." );
}
//-----------------------------------------------------------------------------
//
// Process a response from the Z-Wave PC interface
//-----------------------------------------------------------------------------
void Driver::HandleGetSUCNodeIdResponse
(
uint8* _data
)
{
Log::Write( LogLevel_Info, GetNodeNumber( m_currentMsg ), "Received reply to GET_SUC_NODE_ID. Node ID = %d", _data[2] );
m_SUCNodeId = _data[2];
if( _data[2] == 0)
{
bool enableSIS = true;
Options::Get()->GetOptionAsBool("EnableSIS", &enableSIS);
if (enableSIS) {
if (IsAPICallSupported(FUNC_ID_ZW_ENABLE_SUC) && IsAPICallSupported(FUNC_ID_ZW_SET_SUC_NODE_ID)) {
Log::Write( LogLevel_Info, " No SUC, so we become SIS" );
Msg* msg;
msg = new Msg( "Enable SUC", m_Controller_nodeId, REQUEST, FUNC_ID_ZW_ENABLE_SUC, false );
msg->Append( 1 );
msg->Append( SUC_FUNC_NODEID_SERVER ); // SIS; SUC would be ZW_SUC_FUNC_BASIC_SUC
SendMsg( msg, MsgQueue_Send );
msg = new Msg( "Set SUC node ID", m_Controller_nodeId, REQUEST, FUNC_ID_ZW_SET_SUC_NODE_ID, false );
msg->Append( m_Controller_nodeId );
msg->Append( 1 ); // TRUE, we want to be SUC/SIS
msg->Append( 0 ); // no low power
msg->Append( SUC_FUNC_NODEID_SERVER );
SendMsg( msg, MsgQueue_Send );
} else {
Log::Write (LogLevel_Info, "Controller Does not Support SUC - Cannot Setup Controller as SUC Node");
}
} else {
Log::Write( LogLevel_Info, " No SUC, not becoming SUC as option is disabled" );
}
}
}
//-----------------------------------------------------------------------------
//
// Process a response from the Z-Wave PC interface
//-----------------------------------------------------------------------------
void Driver::HandleMemoryGetIdResponse
(
uint8* _data
)
{
Log::Write( LogLevel_Info, GetNodeNumber( m_currentMsg ), "Received reply to FUNC_ID_ZW_MEMORY_GET_ID. Home ID = 0x%02x%02x%02x%02x. Our node ID = %d", _data[2], _data[3], _data[4], _data[5], _data[6] );
m_homeId = ( ( (uint32)_data[2] )<<24 ) | ( ( (uint32)_data[3] )<<16 ) | ( ( (uint32)_data[4] )<<8 ) | ( (uint32)_data[5] );
m_Controller_nodeId = _data[6];
m_controllerReplication = static_cast(ControllerReplication::Create( m_homeId, m_Controller_nodeId ));
}
//-----------------------------------------------------------------------------
//
// Process a response from the Z-Wave PC interface
//-----------------------------------------------------------------------------
void Driver::HandleSerialAPIGetInitDataResponse
(
uint8* _data
)
{
int32 i;
if( !m_init )
{
// Mark the driver as ready (we have to do this first or
// all the code handling notifications will go awry).
Manager::Get()->SetDriverReady( this, true );
// Read the config file first, to get the last known state
ReadConfig();
}
else
{
// Notify the user that all node and value information has been deleted
// We need to wait to do this here so we have new information to report.
Notification* notification = new Notification( Notification::Type_DriverReset );
notification->SetHomeAndNodeIds( m_homeId, 0 );
QueueNotification( notification );
}
Log::Write( LogLevel_Info, GetNodeNumber( m_currentMsg ), "Received reply to FUNC_ID_SERIAL_API_GET_INIT_DATA:" );
m_initVersion = _data[2];
m_initCaps = _data[3];
if( _data[4] == NUM_NODE_BITFIELD_BYTES )
{
for( i=0; iSetQueryStage( Node::QueryStage_CacheLoad );
}
}
else
{
// This node is new
Log::Write( LogLevel_Info, GetNodeNumber( m_currentMsg ), " Node %.3d - New", nodeId );
Notification* notification = new Notification( Notification::Type_NodeNew );
notification->SetHomeAndNodeIds( m_homeId, nodeId );
QueueNotification( notification );
// Create the node and request its info
InitNode( nodeId );
}
}
}
else
{
LockGuard LG(m_nodeMutex);
if( GetNode(nodeId) )
{
// This node no longer exists in the Z-Wave network
Log::Write( LogLevel_Info, GetNodeNumber( m_currentMsg ), " Node %.3d - Removed", nodeId );
delete m_nodes[nodeId];
m_nodes[nodeId] = NULL;
Notification* notification = new Notification( Notification::Type_NodeRemoved );
notification->SetHomeAndNodeIds( m_homeId, nodeId );
QueueNotification( notification );
}
}
}
}
}
m_init = true;
}
//-----------------------------------------------------------------------------
//
// Process a response from the Z-Wave PC interface
//-----------------------------------------------------------------------------
void Driver::HandleGetNodeProtocolInfoResponse
(
uint8* _data
)
{
// The node that the protocol info response is for is not included in the message.
// We have to assume that the node is the same one as in the most recent request.
if( !m_currentMsg )
{
Log::Write( LogLevel_Warning, "WARNING: Received unexpected FUNC_ID_ZW_GET_NODE_PROTOCOL_INFO message - ignoring.");
return;
}
uint8 nodeId = m_currentMsg->GetTargetNodeId();
Log::Write( LogLevel_Info, nodeId, "Received reply to FUNC_ID_ZW_GET_NODE_PROTOCOL_INFO" );
// Update the node with the protocol info
if( Node* node = GetNodeUnsafe( nodeId ) )
{
node->UpdateProtocolInfo( &_data[2] );
}
}
//-----------------------------------------------------------------------------
//
// Process a response from the Z-Wave PC interface
//-----------------------------------------------------------------------------
bool Driver::HandleAssignReturnRouteResponse
(
uint8* _data
)
{
bool res = true;
ControllerState state = ControllerState_InProgress;
if( _data[2] )
{
Log::Write( LogLevel_Info, GetNodeNumber( m_currentMsg ), "Received reply to FUNC_ID_ZW_ASSIGN_RETURN_ROUTE - command in progress" );
}
else
{
// Failed
Log::Write( LogLevel_Warning, GetNodeNumber( m_currentMsg ), "WARNING: Received reply to FUNC_ID_ZW_ASSIGN_RETURN_ROUTE - command failed" );
state = ControllerState_Failed;
res = false;
}
UpdateControllerState( state );
return res;
}
//-----------------------------------------------------------------------------
//
// Process a response from the Z-Wave PC interface
//-----------------------------------------------------------------------------
bool Driver::HandleDeleteReturnRouteResponse
(
uint8* _data
)
{
bool res = true;
ControllerState state = ControllerState_InProgress;
if( _data[2] )
{
Log::Write( LogLevel_Info, GetNodeNumber( m_currentMsg ), "Received reply to FUNC_ID_ZW_DELETE_RETURN_ROUTE - command in progress" );
}
else
{
// Failed
Log::Write( LogLevel_Warning, GetNodeNumber( m_currentMsg ), "WARNING: Received reply to FUNC_ID_ZW_DELETE_RETURN_ROUTE - command failed" );
state = ControllerState_Failed;
res = false;
}
UpdateControllerState( state );
return res;
}
//-----------------------------------------------------------------------------
//
// Process a response from the Z-Wave PC interface
//-----------------------------------------------------------------------------
bool Driver::HandleRemoveFailedNodeResponse
(
uint8* _data
)
{
bool res = true;
ControllerState state = ControllerState_InProgress;
ControllerError error = ControllerError_None;
if( _data[2] )
{
string reason;
switch( _data[2] )
{
case FAILED_NODE_NOT_FOUND:
{
reason = "Node not found";
error = ControllerError_NotFound;
break;
}
case FAILED_NODE_REMOVE_PROCESS_BUSY:
{
reason = "Remove process busy";
error = ControllerError_Busy;
break;
}
case FAILED_NODE_REMOVE_FAIL:
{
reason = "Remove failed";
error = ControllerError_Failed;
break;
}
case FAILED_NODE_NOT_PRIMARY_CONTROLLER:
{
reason = "Not Primary Controller";
error = ControllerError_NotPrimary;
break;
}
default:
{
reason = "Command failed";
break;
}
}
Log::Write( LogLevel_Warning, GetNodeNumber( m_currentMsg ), "WARNING: Received reply to FUNC_ID_ZW_REMOVE_FAILED_NODE_ID - %s", reason.c_str() );
state = ControllerState_Failed;
res = false;
}
else
{
Log::Write( LogLevel_Info, GetNodeNumber( m_currentMsg ), "Received reply to FUNC_ID_ZW_REMOVE_FAILED_NODE_ID - Command in progress" );
}
UpdateControllerState( state, error );
return res;
}
//-----------------------------------------------------------------------------
//
// Process a response from the Z-Wave PC interface
//-----------------------------------------------------------------------------
void Driver::HandleIsFailedNodeResponse
(
uint8* _data
)
{
ControllerState state;
uint8 nodeId = m_currentControllerCommand ? m_currentControllerCommand->m_controllerCommandNode : GetNodeNumber( m_currentMsg );
if( _data[2] )
{
Log::Write( LogLevel_Warning, nodeId, "WARNING: Received reply to FUNC_ID_ZW_IS_FAILED_NODE_ID - node %d failed", nodeId );
state = ControllerState_NodeFailed;
if( Node* node = GetNodeUnsafe( nodeId ) )
{
if (node->IsNodeReset()) {
/* a DeviceReset has Occured. Remove the Node */
if (!BeginControllerCommand(Driver::ControllerCommand_RemoveFailedNode, NULL, NULL, true, nodeId, 0))
Log::Write(LogLevel_Warning, nodeId, "RemoveFailedNode for DeviceResetLocally Command Failed");
Notification* notification = new Notification( Notification::Type_NodeReset );
notification->SetHomeAndNodeIds( m_homeId, nodeId );
QueueNotification( notification );
state = ControllerState_Completed;
} else {
node->SetNodeAlive( false );
}
}
}
else
{
Log::Write( LogLevel_Warning, nodeId, "Received reply to FUNC_ID_ZW_IS_FAILED_NODE_ID - node %d has not failed", nodeId );
if( Node* node = GetNodeUnsafe( nodeId ) )
{
node->SetNodeAlive( true );
}
state = ControllerState_NodeOK;
}
UpdateControllerState( state );
}
//-----------------------------------------------------------------------------
//
// Process a response from the Z-Wave PC interface
//-----------------------------------------------------------------------------
bool Driver::HandleReplaceFailedNodeResponse
(
uint8* _data
)
{
bool res = true;
ControllerState state = ControllerState_InProgress;
if( _data[2] )
{
// Command failed
Log::Write( LogLevel_Warning, GetNodeNumber( m_currentMsg ), "WARNING: Received reply to FUNC_ID_ZW_REPLACE_FAILED_NODE - command failed" );
state = ControllerState_Failed;
res = false;
}
else
{
Log::Write( LogLevel_Info, GetNodeNumber( m_currentMsg ), "Received reply to FUNC_ID_ZW_REPLACE_FAILED_NODE - command in progress" );
}
UpdateControllerState( state );
return res;
}
//-----------------------------------------------------------------------------
//
// Process a response from the Z-Wave PC interface
//-----------------------------------------------------------------------------
void Driver::HandleSendDataResponse
(
uint8* _data,
bool _replication
)
{
if( _data[2] )
{
Log::Write( LogLevel_Detail, GetNodeNumber( m_currentMsg ), " %s delivered to Z-Wave stack", _replication ? "ZW_REPLICATION_SEND_DATA" : "ZW_SEND_DATA" );
}
else
{
Log::Write( LogLevel_Error, GetNodeNumber( m_currentMsg ), "ERROR: %s could not be delivered to Z-Wave stack", _replication ? "ZW_REPLICATION_SEND_DATA" : "ZW_SEND_DATA" );
m_nondelivery++;
if( Node* node = GetNodeUnsafe( GetNodeNumber( m_currentMsg ) ) )
{
node->m_sentFailed++;
}
}
}
//-----------------------------------------------------------------------------
//
// Process a response from the Z-Wave PC interface
//-----------------------------------------------------------------------------
void Driver::HandleGetRoutingInfoResponse
(
uint8* _data
)
{
Log::Write( LogLevel_Info, GetNodeNumber( m_currentMsg ), "Received reply to FUNC_ID_ZW_GET_ROUTING_INFO" );
LockGuard LG(m_nodeMutex);
if( Node* node = GetNode( GetNodeNumber( m_currentMsg ) ) )
{
// copy the 29-byte bitmap received (29*8=232 possible nodes) into this node's neighbors member variable
memcpy( node->m_neighbors, &_data[2], 29 );
Log::Write( LogLevel_Info, GetNodeNumber( m_currentMsg ), " Neighbors of this node are:" );
bool bNeighbors = false;
for( int by=0; by<29; by++ )
{
for( int bi=0; bi<8; bi++ )
{
if( (_data[2+by] & (0x01<
// Process a request from the Z-Wave PC interface
//-----------------------------------------------------------------------------
void Driver::HandleSendDataRequest
(
uint8* _data,
bool _replication
)
{
uint8 nodeId = GetNodeNumber( m_currentMsg );
Log::Write( LogLevel_Detail, nodeId, " %s Request with callback ID 0x%.2x received (expected 0x%.2x)", _replication ? "ZW_REPLICATION_SEND_DATA" : "ZW_SEND_DATA", _data[2], _data[2] < 10 ? _data[2] : m_expectedCallbackId );
/* Callback ID's below 10 are reserved for NONCE messages */
if ((_data[2] > 10 ) && ( _data[2] != m_expectedCallbackId )) {
// Wrong callback ID
m_callbacks++;
Log::Write( LogLevel_Warning, nodeId, "WARNING: Unexpected Callback ID received" );
} else {
Node* node = GetNodeUnsafe( nodeId );
if( node != NULL )
{
if( _data[3] != 0 )
{
node->m_sentFailed++;
}
else
{
node->m_lastRequestRTT = -node->m_sentTS.TimeRemaining();
if( node->m_averageRequestRTT )
{
// if the average has been established, update by averaging the average and the last RTT
node->m_averageRequestRTT = ( node->m_averageRequestRTT + node->m_lastRequestRTT ) >> 1;
}
else
{
// if this is the first observed RTT, set the average to this value
node->m_averageRequestRTT = node->m_lastRequestRTT;
}
Log::Write(LogLevel_Info, nodeId, "Request RTT %d Average Request RTT %d", node->m_lastRequestRTT, node->m_averageRequestRTT );
}
}
// We do this here since HandleErrorResponse/MoveMessagesToWakeUpQueue can delete m_currentMsg
if( m_currentMsg && m_currentMsg->IsNoOperation() )
{
Notification* notification = new Notification( Notification::Type_Notification );
notification->SetHomeAndNodeIds( m_homeId, GetNodeNumber( m_currentMsg) );
notification->SetNotification( Notification::Code_NoOperation );
QueueNotification( notification );
}
// Callback ID matches our expectation
if( _data[3] != 0 )
{
if( !HandleErrorResponse( _data[3], nodeId, _replication ? "ZW_REPLICATION_END_DATA" : "ZW_SEND_DATA", !_replication ) )
{
if( m_currentMsg && m_currentMsg->IsNoOperation() && node != NULL &&
( node->GetCurrentQueryStage() == Node::QueryStage_Probe ||
node->GetCurrentQueryStage() == Node::QueryStage_CacheLoad ) )
{
node->QueryStageRetry( node->GetCurrentQueryStage(), 3 );
}
}
}
else if( node != NULL )
{
// If WakeUpNoMoreInformation request succeeds, update our status
if( m_currentMsg && m_currentMsg->IsWakeUpNoMoreInformationCommand() )
{
if( WakeUp* wakeUp = static_cast( node->GetCommandClass( WakeUp::StaticGetCommandClassId() ) ) )
{
// Mark the node as asleep
wakeUp->SetAwake( false );
}
}
// If node is not alive, mark it alive now
if( !node->IsNodeAlive() )
{
node->SetNodeAlive( true );
}
}
// Command reception acknowledged by node, error or not, but ignore any NONCE messages
//
// m_expectedCallbackId = 0;
}
}
//-----------------------------------------------------------------------------
//
// Process a response from the Z-Wave PC interface
//-----------------------------------------------------------------------------
void Driver::HandleNetworkUpdateRequest
(
uint8* _data
)
{
ControllerState state = ControllerState_Failed;
ControllerError error = ControllerError_None;
uint8 nodeId = GetNodeNumber( m_currentMsg );
switch( _data[3] )
{
case SUC_UPDATE_DONE:
{
Log::Write( LogLevel_Info, nodeId, "Received reply to FUNC_ID_ZW_REQUEST_NETWORK_UPDATE: Success" );
state = ControllerState_Completed;
break;
}
case SUC_UPDATE_ABORT:
{
Log::Write( LogLevel_Warning, nodeId, "WARNING: Received reply to FUNC_ID_ZW_REQUEST_NETWORK_UPDATE: Failed - Error. Process aborted." );
error = ControllerError_Failed;
break;
}
case SUC_UPDATE_WAIT:
{
Log::Write( LogLevel_Warning, nodeId, "WARNING: Received reply to FUNC_ID_ZW_REQUEST_NETWORK_UPDATE: Failed - SUC is busy." );
error = ControllerError_Busy;
break;
}
case SUC_UPDATE_DISABLED:
{
Log::Write( LogLevel_Warning, nodeId, "WARNING: Received reply to FUNC_ID_ZW_REQUEST_NETWORK_UPDATE: Failed - SUC is disabled." );
error = ControllerError_Disabled;
break;
}
case SUC_UPDATE_OVERFLOW:
{
Log::Write( LogLevel_Warning, nodeId, "WARNING: Received reply to FUNC_ID_ZW_REQUEST_NETWORK_UPDATE: Failed - Overflow. Full replication required." );
error = ControllerError_Overflow;
break;
}
default:
{
}
}
UpdateControllerState( state, error );
}
//-----------------------------------------------------------------------------
//
// Process a request from the Z-Wave PC interface
//-----------------------------------------------------------------------------
void Driver::HandleAddNodeToNetworkRequest
(
uint8* _data
)
{
Log::Write( LogLevel_Info, GetNodeNumber( m_currentMsg ), "FUNC_ID_ZW_ADD_NODE_TO_NETWORK:" );
CommonAddNodeStatusRequestHandler( FUNC_ID_ZW_ADD_NODE_TO_NETWORK, _data );
}
//-----------------------------------------------------------------------------
//
// Process a request from the Z-Wave PC interface
//-----------------------------------------------------------------------------
void Driver::HandleRemoveNodeFromNetworkRequest
(
uint8* _data
)
{
//uint8 nodeId = GetNodeNumber( m_currentMsg );
if( m_currentControllerCommand == NULL )
{
return;
}
ControllerState state = m_currentControllerCommand->m_controllerState;
Log::Write( LogLevel_Info, "FUNC_ID_ZW_REMOVE_NODE_FROM_NETWORK:" );
switch( _data[3] )
{
case REMOVE_NODE_STATUS_LEARN_READY:
{
Log::Write( LogLevel_Info, "REMOVE_NODE_STATUS_LEARN_READY" );
state = ControllerState_Waiting;
m_currentControllerCommand->m_controllerCommandNode = 0;
break;
}
case REMOVE_NODE_STATUS_NODE_FOUND:
{
Log::Write( LogLevel_Info, "REMOVE_NODE_STATUS_NODE_FOUND" );
state = ControllerState_InProgress;
break;
}
case REMOVE_NODE_STATUS_REMOVING_SLAVE:
{
Log::Write( LogLevel_Info, "REMOVE_NODE_STATUS_REMOVING_SLAVE" );
if (_data[4] != 0)
{
Log::Write( LogLevel_Info, "Removing node ID %d", _data[4] );
m_currentControllerCommand->m_controllerCommandNode = _data[4];
}
else
{
Log::Write( LogLevel_Warning, "Remove Node Failed - NodeID 0 Returned");
state = ControllerState_Failed;
}
break;
}
case REMOVE_NODE_STATUS_REMOVING_CONTROLLER:
{
Log::Write( LogLevel_Info, "REMOVE_NODE_STATUS_REMOVING_CONTROLLER" );
m_currentControllerCommand->m_controllerCommandNode = _data[4];
if( m_currentControllerCommand->m_controllerCommandNode == 0 ) // Some controllers don't return node number
{
if( _data[5] >= 3 )
{
LockGuard LG(m_nodeMutex);
for( int i=0; i<256; i++ )
{
if( m_nodes[i] == NULL )
{
continue;
}
// Ignore primary controller
if( m_nodes[i]->m_nodeId == m_Controller_nodeId )
{
continue;
}
// See if we can match another way
if( m_nodes[i]->m_basic == _data[6] &&
m_nodes[i]->m_generic == _data[7] &&
m_nodes[i]->m_specific == _data[8] )
{
if( m_currentControllerCommand->m_controllerCommandNode != 0 )
{
Log::Write( LogLevel_Info, "Alternative controller lookup found more then one match. Using the first one found." );
}
else
{
m_currentControllerCommand->m_controllerCommandNode = m_nodes[i]->m_nodeId;
}
}
}
LG.Unlock();
}
else
{
Log::Write( LogLevel_Warning, "WARNING: Node is 0 but not enough data to perform alternative match." );
}
}
else
{
m_currentControllerCommand->m_controllerCommandNode = _data[4];
}
Log::Write( LogLevel_Info, "Removing controller ID %d", m_currentControllerCommand->m_controllerCommandNode );
break;
}
case REMOVE_NODE_STATUS_DONE:
{
Log::Write( LogLevel_Info, "REMOVE_NODE_STATUS_DONE" );
if( !m_currentControllerCommand->m_controllerCommandDone )
{
// Remove Node Stop calls back through here so make sure
// we do't do it again.
UpdateControllerState( ControllerState_Completed );
//AddNodeStop( FUNC_ID_ZW_REMOVE_NODE_FROM_NETWORK );
if ( m_currentControllerCommand->m_controllerCommandNode == 0 ) // never received "removing" update
{
if ( _data[4] != 0 ) // but message has the clue
{
m_currentControllerCommand->m_controllerCommandNode = _data[4];
}
}
if ( m_currentControllerCommand->m_controllerCommandNode != 0 && m_currentControllerCommand->m_controllerCommandNode != 0xff )
{
LockGuard LG(m_nodeMutex);
delete m_nodes[m_currentControllerCommand->m_controllerCommandNode];
m_nodes[m_currentControllerCommand->m_controllerCommandNode] = NULL;
LG.Unlock();
Notification* notification = new Notification( Notification::Type_NodeRemoved );
notification->SetHomeAndNodeIds( m_homeId, m_currentControllerCommand->m_controllerCommandNode );
QueueNotification( notification );
}
}
return;
}
case REMOVE_NODE_STATUS_FAILED:
{
//AddNodeStop( FUNC_ID_ZW_REMOVE_NODE_FROM_NETWORK );
Log::Write( LogLevel_Warning, "WARNING: REMOVE_NODE_STATUS_FAILED" );
state = ControllerState_Failed;
break;
}
default:
{
break;
}
}
UpdateControllerState( state );
}
//-----------------------------------------------------------------------------
//
// Process a request from the Z-Wave PC interface
//-----------------------------------------------------------------------------
void Driver::HandleControllerChangeRequest
(
uint8* _data
)
{
Log::Write( LogLevel_Info, GetNodeNumber( m_currentMsg ), "FUNC_ID_ZW_CONTROLLER_CHANGE:" );
CommonAddNodeStatusRequestHandler( FUNC_ID_ZW_CONTROLLER_CHANGE, _data );
}
//-----------------------------------------------------------------------------
//
// Process a request from the Z-Wave PC interface
//-----------------------------------------------------------------------------
void Driver::HandleCreateNewPrimaryRequest
(
uint8* _data
)
{
Log::Write( LogLevel_Info, GetNodeNumber( m_currentMsg ), "FUNC_ID_ZW_CREATE_NEW_PRIMARY:" );
CommonAddNodeStatusRequestHandler( FUNC_ID_ZW_CREATE_NEW_PRIMARY, _data );
}
//-----------------------------------------------------------------------------
//
// Process a request from the Z-Wave PC interface
//-----------------------------------------------------------------------------
void Driver::HandleSetLearnModeRequest
(
uint8* _data
)
{
uint8 nodeId = GetNodeNumber( m_currentMsg );
if( m_currentControllerCommand == NULL )
{
return;
}
ControllerState state = m_currentControllerCommand->m_controllerState;
Log::Write( LogLevel_Info, nodeId, "FUNC_ID_ZW_SET_LEARN_MODE:" );
switch( _data[3] )
{
case LEARN_MODE_STARTED:
{
Log::Write( LogLevel_Info, nodeId, "LEARN_MODE_STARTED" );
state = ControllerState_Waiting;
break;
}
case LEARN_MODE_DONE:
{
Log::Write( LogLevel_Info, nodeId, "LEARN_MODE_DONE" );
state = ControllerState_Completed;
// Stop learn mode
Msg* msg = new Msg( "End Learn Mode", 0xff, REQUEST, FUNC_ID_ZW_SET_LEARN_MODE, false, false );
msg->Append( 0 );
SendMsg( msg, MsgQueue_Command );
// Rebuild all the node info. Group and scene data that we stored
// during replication will be applied as we discover each node.
InitAllNodes();
break;
}
case LEARN_MODE_FAILED:
{
Log::Write( LogLevel_Warning, nodeId, "WARNING: LEARN_MODE_FAILED" );
state = ControllerState_Failed;
// Stop learn mode
Msg* msg = new Msg( "End Learn Mode", 0xff, REQUEST, FUNC_ID_ZW_SET_LEARN_MODE, false, false );
msg->Append( 0 );
SendMsg( msg, MsgQueue_Command );
// Rebuild all the node info, since it may have been partially
// updated by the failed command. Group and scene data that we
// stored during replication will be applied as we discover each node.
InitAllNodes();
break;
}
case LEARN_MODE_DELETED:
{
Log::Write( LogLevel_Info, nodeId, "LEARN_MODE_DELETED" );
state = ControllerState_Failed;
// Stop learn mode
Msg* msg = new Msg( "End Learn Mode", 0xff, REQUEST, FUNC_ID_ZW_SET_LEARN_MODE, false, false );
msg->Append( 0 );
SendMsg( msg, MsgQueue_Command );
break;
}
}
UpdateControllerState( state );
}
//-----------------------------------------------------------------------------
//
// Process a request from the Z-Wave PC interface
//-----------------------------------------------------------------------------
void Driver::HandleRemoveFailedNodeRequest
(
uint8* _data
)
{
ControllerState state = ControllerState_Completed;
uint8 nodeId = GetNodeNumber( m_currentMsg );
switch( _data[3] )
{
case FAILED_NODE_OK:
{
Log::Write( LogLevel_Warning, nodeId, "WARNING: Received reply to FUNC_ID_ZW_REMOVE_FAILED_NODE_ID - Node %d is OK, so command failed", m_currentControllerCommand->m_controllerCommandNode );
state = ControllerState_NodeOK;
break;
}
case FAILED_NODE_REMOVED:
{
Log::Write( LogLevel_Info, nodeId, "Received reply to FUNC_ID_ZW_REMOVE_FAILED_NODE_ID - node %d successfully moved to failed nodes list", m_currentControllerCommand->m_controllerCommandNode );
state = ControllerState_Completed;
LockGuard LG(m_nodeMutex);
delete m_nodes[m_currentControllerCommand->m_controllerCommandNode];
m_nodes[m_currentControllerCommand->m_controllerCommandNode] = NULL;
LG.Unlock();
Notification* notification = new Notification( Notification::Type_NodeRemoved );
notification->SetHomeAndNodeIds( m_homeId, m_currentControllerCommand->m_controllerCommandNode );
QueueNotification( notification );
break;
}
case FAILED_NODE_NOT_REMOVED:
{
Log::Write( LogLevel_Warning, nodeId, "WARNING: Received reply to FUNC_ID_ZW_REMOVE_FAILED_NODE_ID - unable to move node %d to failed nodes list", m_currentControllerCommand->m_controllerCommandNode );
state = ControllerState_Failed;
break;
}
}
UpdateControllerState( state );
}
//-----------------------------------------------------------------------------
//
// Process a request from the Z-Wave PC interface
//-----------------------------------------------------------------------------
void Driver::HandleReplaceFailedNodeRequest
(
uint8* _data
)
{
ControllerState state = ControllerState_Completed;
uint8 nodeId = GetNodeNumber( m_currentMsg );
switch( _data[3] )
{
case FAILED_NODE_OK:
{
Log::Write( LogLevel_Info, nodeId, "Received reply to FUNC_ID_ZW_REPLACE_FAILED_NODE - Node is OK, so command failed" );
state = ControllerState_NodeOK;
break;
}
case FAILED_NODE_REPLACE_WAITING:
{
Log::Write( LogLevel_Info, nodeId, "Received reply to FUNC_ID_ZW_REPLACE_FAILED_NODE - Waiting for new node" );
state = ControllerState_Waiting;
break;
}
case FAILED_NODE_REPLACE_DONE:
{
Log::Write( LogLevel_Info, nodeId, "Received reply to FUNC_ID_ZW_REPLACE_FAILED_NODE - Node successfully replaced" );
state = ControllerState_Completed;
// Request new node info for this device
if( m_currentControllerCommand != NULL )
{
InitNode( m_currentControllerCommand->m_controllerCommandNode, true );
}
break;
}
case FAILED_NODE_REPLACE_FAILED:
{
Log::Write( LogLevel_Info, nodeId, "Received reply to FUNC_ID_ZW_REPLACE_FAILED_NODE - Node replacement failed" );
state = ControllerState_Failed;
break;
}
}
UpdateControllerState( state );
}
//-----------------------------------------------------------------------------
//
// Process a request from the Z-Wave PC interface
//-----------------------------------------------------------------------------
void Driver::HandleApplicationCommandHandlerRequest
(
uint8* _data,
bool encrypted
)
{
uint8 status = _data[2];
uint8 nodeId = _data[3];
uint8 classId = _data[5];
Node* node = GetNodeUnsafe( nodeId );
if( ( status & RECEIVE_STATUS_ROUTED_BUSY ) != 0 )
{
m_routedbusy++;
}
if( ( status & RECEIVE_STATUS_TYPE_BROAD ) != 0 )
{
m_broadcastReadCnt++;
}
if( node != NULL )
{
node->m_receivedCnt++;
node->m_errors = 0;
int cmp = memcmp( _data, node->m_lastReceivedMessage, sizeof(node->m_lastReceivedMessage));
if( cmp == 0 && node->m_receivedTS.TimeRemaining() > -500 )
{
// if the exact same sequence of bytes are received within 500ms
node->m_receivedDups++;
}
else
{
memcpy( node->m_lastReceivedMessage, _data, sizeof(node->m_lastReceivedMessage) );
}
node->m_receivedTS.SetTime();
if( m_expectedReply == FUNC_ID_APPLICATION_COMMAND_HANDLER && m_expectedNodeId == nodeId )
{
// Need to confirm this is the correct response to the last sent request.
// At least ignore any received messages prior to the send data request.
node->m_lastResponseRTT = -node->m_sentTS.TimeRemaining();
if( node->m_averageResponseRTT )
{
// if the average has been established, update by averaging the average and the last RTT
node->m_averageResponseRTT = ( node->m_averageResponseRTT + node->m_lastResponseRTT ) >> 1;
}
else
{
// if this is the first observed RTT, set the average to this value
node->m_averageResponseRTT = node->m_lastResponseRTT;
}
Log::Write(LogLevel_Info, nodeId, "Response RTT %d Average Response RTT %d", node->m_lastResponseRTT, node->m_averageResponseRTT );
}
else
{
node->m_receivedUnsolicited++;
}
if ( !node->IsNodeAlive() )
{
node->SetNodeAlive( true );
}
}
if( ApplicationStatus::StaticGetCommandClassId() == classId )
{
//TODO: Test this class function or implement
}
else if( ControllerReplication::StaticGetCommandClassId() == classId )
{
if( m_controllerReplication && m_currentControllerCommand && ( ControllerCommand_ReceiveConfiguration == m_currentControllerCommand->m_controllerCommand ) )
{
m_controllerReplication->HandleMsg( &_data[6], _data[4] );
UpdateControllerState( ControllerState_InProgress );
}
}
else
{
// Allow the node to handle the message itself
if( node != NULL )
{
node->ApplicationCommandHandler( _data, encrypted );
}
}
}
//-----------------------------------------------------------------------------
//
// Process a request from the Z-Wave PC interface when in promiscuous mode.
//-----------------------------------------------------------------------------
void Driver::HandlePromiscuousApplicationCommandHandlerRequest
(
uint8* _data
)
{
//uint8 nodeId = _data[3];
//uint8 len = _data[4];
//uint8 classId = _data[5];
//uint8 destNodeId = _data[5+len];
}
//-----------------------------------------------------------------------------
//
// Process a request from the Z-Wave PC interface
//-----------------------------------------------------------------------------
void Driver::HandleAssignReturnRouteRequest
(
uint8* _data
)
{
ControllerState state;
uint8 nodeId = GetNodeNumber( m_currentMsg );
if( m_currentControllerCommand == NULL )
{
return;
}
if( _data[3] )
{
// Failed
HandleErrorResponse( _data[3], m_currentControllerCommand->m_controllerCommandNode, "ZW_ASSIGN_RETURN_ROUTE", true );
state = ControllerState_Failed;
}
else
{
// Success
Log::Write( LogLevel_Info, nodeId, "Received reply to FUNC_ID_ZW_ASSIGN_RETURN_ROUTE for node %d - SUCCESS", m_currentControllerCommand->m_controllerCommandNode );
state = ControllerState_Completed;
}
UpdateControllerState( state );
}
//-----------------------------------------------------------------------------
//
// Process a request from the Z-Wave PC interface
//-----------------------------------------------------------------------------
void Driver::HandleDeleteReturnRouteRequest
(
uint8* _data
)
{
ControllerState state;
uint8 nodeId = GetNodeNumber( m_currentMsg );
if( m_currentControllerCommand == NULL )
{
return;
}
if( _data[3] )
{
// Failed
HandleErrorResponse( _data[3], m_currentControllerCommand->m_controllerCommandNode, "ZW_DELETE_RETURN_ROUTE", true );
state = ControllerState_Failed;
}
else
{
// Success
Log::Write( LogLevel_Info, nodeId, "Received reply to FUNC_ID_ZW_DELETE_RETURN_ROUTE for node %d - SUCCESS", m_currentControllerCommand->m_controllerCommandNode );
state = ControllerState_Completed;
}
UpdateControllerState( state );
}
//-----------------------------------------------------------------------------
//
// Process a request from the Z-Wave PC interface
//-----------------------------------------------------------------------------
void Driver::HandleSendNodeInformationRequest
(
uint8* _data
)
{
ControllerState state;
uint8 nodeId = GetNodeNumber( m_currentMsg );
if( m_currentControllerCommand == NULL )
{
return;
}
if( _data[3] )
{
// Failed
HandleErrorResponse( _data[3], m_currentControllerCommand->m_controllerCommandNode, "ZW_SEND_NODE_INFORMATION" );
state = ControllerState_Failed;
}
else
{
// Success
Log::Write( LogLevel_Info, nodeId, "Received reply to FUNC_ID_ZW_SEND_NODE_INFORMATION - SUCCESS" );
state = ControllerState_Completed;
}
UpdateControllerState( state );
}
//-----------------------------------------------------------------------------
//
// Process a request from the Z-Wave PC interface
//-----------------------------------------------------------------------------
void Driver::HandleNodeNeighborUpdateRequest
(
uint8* _data
)
{
uint8 nodeId = GetNodeNumber( m_currentMsg );
ControllerState state = ControllerState_Normal;
switch( _data[3] )
{
case REQUEST_NEIGHBOR_UPDATE_STARTED:
{
Log::Write( LogLevel_Info, nodeId, "REQUEST_NEIGHBOR_UPDATE_STARTED" );
state = ControllerState_InProgress;
break;
}
case REQUEST_NEIGHBOR_UPDATE_DONE:
{
Log::Write( LogLevel_Info, nodeId, "REQUEST_NEIGHBOR_UPDATE_DONE" );
state = ControllerState_Completed;
// We now request the neighbour information from the
// controller and store it in our node object.
if( m_currentControllerCommand != NULL )
{
RequestNodeNeighbors( m_currentControllerCommand->m_controllerCommandNode, 0 );
}
break;
}
case REQUEST_NEIGHBOR_UPDATE_FAILED:
{
Log::Write( LogLevel_Warning, nodeId, "WARNING: REQUEST_NEIGHBOR_UPDATE_FAILED" );
state = ControllerState_Failed;
break;
}
default:
{
break;
}
}
UpdateControllerState( state );
}
//-----------------------------------------------------------------------------
//
// Process a request from the Z-Wave PC interface
//-----------------------------------------------------------------------------
bool Driver::HandleApplicationUpdateRequest
(
uint8* _data
)
{
bool messageRemoved = false;
uint8 nodeId = _data[3];
Node* node = GetNodeUnsafe( nodeId );
// If node is not alive, mark it alive now
if( node != NULL && !node->IsNodeAlive() )
{
node->SetNodeAlive( true );
}
switch( _data[2] )
{
case UPDATE_STATE_SUC_ID:
{
Log::Write( LogLevel_Info, nodeId, "UPDATE_STATE_SUC_ID from node %d", nodeId );
m_SUCNodeId = nodeId; // need to confirm real data here
break;
}
case UPDATE_STATE_DELETE_DONE:
{
Log::Write( LogLevel_Info, nodeId, "** Network change **: Z-Wave node %d was removed", nodeId );
LockGuard LG(m_nodeMutex);
delete m_nodes[nodeId];
m_nodes[nodeId] = NULL;
LG.Unlock();
Notification* notification = new Notification( Notification::Type_NodeRemoved );
notification->SetHomeAndNodeIds( m_homeId, nodeId );
QueueNotification( notification );
break;
}
case UPDATE_STATE_NEW_ID_ASSIGNED:
{
Log::Write( LogLevel_Info, nodeId, "** Network change **: ID %d was assigned to a new Z-Wave node", nodeId );
// Request the node protocol info (also removes any existing node and creates a new one)
InitNode( nodeId );
break;
}
case UPDATE_STATE_ROUTING_PENDING:
{
Log::Write( LogLevel_Info, nodeId, "UPDATE_STATE_ROUTING_PENDING from node %d", nodeId );
break;
}
case UPDATE_STATE_NODE_INFO_REQ_FAILED:
{
Log::Write( LogLevel_Warning, nodeId, "WARNING: FUNC_ID_ZW_APPLICATION_UPDATE: UPDATE_STATE_NODE_INFO_REQ_FAILED received" );
// Note: Unhelpfully, the nodeId is always zero in this message. We have to
// assume the message came from the last node to which we sent a request.
if( m_currentMsg )
{
Node* tnode = GetNodeUnsafe( m_currentMsg->GetTargetNodeId() );
if( tnode )
{
// Retry the query twice
tnode->QueryStageRetry( Node::QueryStage_NodeInfo, 2 );
// Just in case the failure was due to the node being asleep, we try
// to move its pending messages to its wakeup queue. If it is not
// a sleeping device, this will have no effect.
if( MoveMessagesToWakeUpQueue( tnode->GetNodeId(), true ) )
{
messageRemoved = true;
}
}
}
break;
}
case UPDATE_STATE_NODE_INFO_REQ_DONE:
{
Log::Write( LogLevel_Info, nodeId, "UPDATE_STATE_NODE_INFO_REQ_DONE from node %d", nodeId );
break;
}
case UPDATE_STATE_NODE_INFO_RECEIVED:
{
Log::Write( LogLevel_Info, nodeId, "UPDATE_STATE_NODE_INFO_RECEIVED from node %d", nodeId );
if( node )
{
node->UpdateNodeInfo( &_data[8], _data[4] - 3 );
}
break;
}
}
if( messageRemoved )
{
m_waitingForAck = false;
m_expectedCallbackId = 0;
m_expectedReply = 0;
m_expectedCommandClassId = 0;
m_expectedNodeId = 0;
}
return messageRemoved;
}
//-----------------------------------------------------------------------------
//
// Handle common AddNode processing for many similar commands
//-----------------------------------------------------------------------------
void Driver::CommonAddNodeStatusRequestHandler
(
uint8 _funcId,
uint8* _data
)
{
uint8 nodeId = GetNodeNumber( m_currentMsg );
ControllerState state = ControllerState_Normal;
if( m_currentControllerCommand != NULL )
{
state = m_currentControllerCommand->m_controllerState;
}
switch( _data[3] )
{
case ADD_NODE_STATUS_LEARN_READY:
{
Log::Write( LogLevel_Info, nodeId, "ADD_NODE_STATUS_LEARN_READY" );
m_currentControllerCommand->m_controllerAdded = false;
state = ControllerState_Waiting;
break;
}
case ADD_NODE_STATUS_NODE_FOUND:
{
Log::Write( LogLevel_Info, nodeId, "ADD_NODE_STATUS_NODE_FOUND" );
state = ControllerState_InProgress;
break;
}
case ADD_NODE_STATUS_ADDING_SLAVE:
{
Log::Write( LogLevel_Info, nodeId, "ADD_NODE_STATUS_ADDING_SLAVE" );
Log::Write( LogLevel_Info, nodeId, "Adding node ID %d - %s", _data[4], m_currentControllerCommand->m_controllerCommandArg ? "Secure" : "Non-Secure");
/* Discovered all the CC's are sent in this packet as well:
* position description
* 4 - Node ID
* 5 - Length
* 6 - Basic Device Class
* 7 - Generic Device Class
* 8 - Specific Device Class
* 9 to Length - Command Classes
* Last pck - CRC
*/
if( m_currentControllerCommand != NULL )
{
m_currentControllerCommand->m_controllerAdded = false;
m_currentControllerCommand->m_controllerCommandNode = _data[4];
/* make sure we dont overrun our buffer. Its ok to truncate */
uint8 length = _data[5];
if (length > 254) length = 254;
memcpy(&m_currentControllerCommand->m_controllerDeviceProtocolInfo, &_data[6], length);
m_currentControllerCommand->m_controllerDeviceProtocolInfoLength = length;
}
// AddNodeStop( _funcId );
// sleep(1);
break;
}
case ADD_NODE_STATUS_ADDING_CONTROLLER:
{
Log::Write( LogLevel_Info, nodeId, "ADD_NODE_STATUS_ADDING_CONTROLLER");
Log::Write( LogLevel_Info, nodeId, "Adding controller ID %d", _data[4] );
/* Discovered all the CC's are sent in this packet as well:
* position description
* 4 - Node ID
* 5 - Length
* 6 - Basic Device Class
* 7 - Generic Device Class
* 8 - Specific Device Class
* 9 to Length - Command Classes
* Last pck - CRC
*/
if( m_currentControllerCommand != NULL )
{
m_currentControllerCommand->m_controllerAdded = true;
m_currentControllerCommand->m_controllerCommandNode = _data[4];
}
// AddNodeStop( _funcId );
break;
}
case ADD_NODE_STATUS_PROTOCOL_DONE:
{
Log::Write( LogLevel_Info, nodeId, "ADD_NODE_STATUS_PROTOCOL_DONE" );
// We added a device.
// Get the controller out of add mode to avoid accidentally adding other devices.
// We used to call replication here.
AddNodeStop( _funcId );
break;
}
case ADD_NODE_STATUS_DONE:
{
if (state == ControllerState_Failed) {
/* if it was a failed add, we just move on */
state = ControllerState_Completed;
break;
}
Log::Write( LogLevel_Info, nodeId, "ADD_NODE_STATUS_DONE" );
state = ControllerState_Completed;
if( m_currentControllerCommand != NULL && m_currentControllerCommand->m_controllerCommandNode != 0xff )
{
InitNode( m_currentControllerCommand->m_controllerCommandNode, true, m_currentControllerCommand->m_controllerCommandArg != 0, m_currentControllerCommand->m_controllerDeviceProtocolInfo, m_currentControllerCommand->m_controllerDeviceProtocolInfoLength );
}
// Not sure about the new controller function here.
if( _funcId != FUNC_ID_ZW_ADD_NODE_TO_NETWORK && m_currentControllerCommand != NULL && m_currentControllerCommand->m_controllerAdded )
{
// Rebuild all the node info. Group and scene data that we stored
// during replication will be applied as we discover each node.
InitAllNodes();
}
break;
}
case ADD_NODE_STATUS_FAILED:
{
Log::Write( LogLevel_Info, nodeId, "ADD_NODE_STATUS_FAILED" );
state = ControllerState_Failed;
// Remove the AddNode command from the queue
RemoveCurrentMsg();
// Get the controller out of add mode to avoid accidentally adding other devices.
AddNodeStop( _funcId );
break;
}
default:
{
break;
}
}
UpdateControllerState( state );
}
//-----------------------------------------------------------------------------
// Polling Z-Wave devices
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//
// Enable polling of a value
//-----------------------------------------------------------------------------
bool Driver::EnablePoll
(
ValueID const &_valueId,
uint8 const _intensity
)
{
// make sure the polling thread doesn't lock the node while we're in this function
m_pollMutex->Lock();
// confirm that this node exists
uint8 nodeId = _valueId.GetNodeId();
LockGuard LG(m_nodeMutex);
Node* node = GetNode( nodeId );
if( node != NULL )
{
// confirm that this value is in the node's value store
if( Value* value = node->GetValue( _valueId ) )
{
// update the value's pollIntensity
value->SetPollIntensity( _intensity );
// Add the valueid to the polling list
// See if the node is already in the poll list.
for( list::iterator it = m_pollList.begin(); it != m_pollList.end(); ++it )
{
if( (*it).m_id == _valueId )
{
// It is already in the poll list, so we have nothing to do.
Log::Write( LogLevel_Detail, "EnablePoll not required to do anything (value is already in the poll list)" );
value->Release();
m_pollMutex->Unlock();
return true;
}
}
// Not in the list, so we add it
PollEntry pe;
pe.m_id = _valueId;
pe.m_pollCounter = value->GetPollIntensity();
m_pollList.push_back( pe );
value->Release();
m_pollMutex->Unlock();
// send notification to indicate polling is enabled
Notification* notification = new Notification( Notification::Type_PollingEnabled );
notification->SetHomeAndNodeIds( m_homeId, _valueId.GetNodeId() );
QueueNotification( notification );
Log::Write( LogLevel_Info, nodeId, "EnablePoll for HomeID 0x%.8x, value(cc=0x%02x,in=0x%02x,id=0x%02x)--poll list has %d items",
_valueId.GetHomeId(), _valueId.GetCommandClassId(), _valueId.GetIndex(), _valueId.GetInstance(), m_pollList.size() );
return true;
}
// allow the poll thread to continue
m_pollMutex->Unlock();
Log::Write( LogLevel_Info, nodeId, "EnablePoll failed - value not found for node %d", nodeId );
return false;
}
// allow the poll thread to continue
m_pollMutex->Unlock();
Log::Write( LogLevel_Info, "EnablePoll failed - node %d not found", nodeId );
return false;
}
//-----------------------------------------------------------------------------
//
// Disable polling of a node
//-----------------------------------------------------------------------------
bool Driver::DisablePoll
(
ValueID const &_valueId
)
{
// make sure the polling thread doesn't lock the node while we're in this function
m_pollMutex->Lock();
// confirm that this node exists
uint8 nodeId = _valueId.GetNodeId();
LockGuard LG(m_nodeMutex);
Node* node = GetNode( nodeId );
if( node != NULL)
{
// See if the value is already in the poll list.
for( list::iterator it = m_pollList.begin(); it != m_pollList.end(); ++it )
{
if( (*it).m_id == _valueId )
{
// Found it
// remove it from the poll list
m_pollList.erase( it );
// get the value object and reset pollIntensity to zero (indicating no polling)
Value* value = GetValue( _valueId );
if (!value)
continue;
value->SetPollIntensity( 0 );
value->Release();
m_pollMutex->Unlock();
// send notification to indicate polling is disabled
Notification* notification = new Notification( Notification::Type_PollingDisabled );
notification->SetHomeAndNodeIds( m_homeId, _valueId.GetNodeId() );
QueueNotification( notification );
Log::Write( LogLevel_Info, nodeId, "DisablePoll for HomeID 0x%.8x, value(cc=0x%02x,in=0x%02x,id=0x%02x)--poll list has %d items",
_valueId.GetHomeId(), _valueId.GetCommandClassId(), _valueId.GetIndex(), _valueId.GetInstance(), m_pollList.size() );
return true;
}
}
// Not in the list
m_pollMutex->Unlock();
Log::Write( LogLevel_Info, nodeId, "DisablePoll failed - value not on list");
return false;
}
// allow the poll thread to continue
m_pollMutex->Unlock();
Log::Write( LogLevel_Info, "DisablePoll failed - node %d not found", nodeId );
return false;
}
//-----------------------------------------------------------------------------
//
// Check polling status of a value
//-----------------------------------------------------------------------------
bool Driver::isPolled
(
ValueID const &_valueId
)
{
bool bPolled;
// make sure the polling thread doesn't lock the node while we're in this function
m_pollMutex->Lock();
Value* value = GetValue( _valueId );
if( value && value->GetPollIntensity() != 0 )
{
bPolled = true;
}
else
{
bPolled = false;
}
if (value) value->Release();
/*
* This code is retained for the moment as a belt-and-suspenders test to confirm that
* the pollIntensity member of each value and the pollList contents do not get out
* of sync.
*/
// confirm that this node exists
uint8 nodeId = _valueId.GetNodeId();
LockGuard LG(m_nodeMutex);
Node* node = GetNode( nodeId );
if( node != NULL)
{
// See if the value is already in the poll list.
for( list::iterator it = m_pollList.begin(); it != m_pollList.end(); ++it )
{
if( (*it).m_id == _valueId )
{
// Found it
if( bPolled )
{
m_pollMutex->Unlock();
return true;
}
else
{
Log::Write( LogLevel_Error, nodeId, "IsPolled setting for valueId 0x%016x is not consistent with the poll list", _valueId.GetId() );
}
}
}
// Not in the list
if( !bPolled )
{
m_pollMutex->Unlock();
return false;
}
else
{
Log::Write( LogLevel_Error, nodeId, "IsPolled setting for valueId 0x%016x is not consistent with the poll list", _valueId.GetId() );
}
}
// allow the poll thread to continue
m_pollMutex->Unlock();
Log::Write( LogLevel_Info, "isPolled failed - node %d not found (the value reported that it is%s polled)", nodeId, bPolled?"":" not" );
return false;
}
//-----------------------------------------------------------------------------
//
// Set the intensity with which this value is polled
//-----------------------------------------------------------------------------
void Driver::SetPollIntensity
(
ValueID const &_valueId,
uint8 const _intensity
)
{
// make sure the polling thread doesn't lock the value while we're in this function
m_pollMutex->Lock();
Value* value = GetValue( _valueId );
if (!value)
return;
value->SetPollIntensity( _intensity );
value->Release();
m_pollMutex->Unlock();
}
//-----------------------------------------------------------------------------
//
// Entry point of the thread for poll Z-Wave devices
//-----------------------------------------------------------------------------
void Driver::PollThreadEntryPoint
(
Event* _exitEvent,
void* _context
)
{
Driver* driver = (Driver*)_context;
if( driver )
{
driver->PollThreadProc( _exitEvent );
}
}
//-----------------------------------------------------------------------------
//
// Thread for poll Z-Wave devices
//-----------------------------------------------------------------------------
void Driver::PollThreadProc
(
Event* _exitEvent
)
{
while( 1 )
{
int32 pollInterval = m_pollInterval;
if( m_awakeNodesQueried && !m_pollList.empty() )
{
// We only bother getting the lock if the pollList is not empty
m_pollMutex->Lock();
// Get the next value to be polled
PollEntry pe = m_pollList.front();
m_pollList.pop_front();
ValueID valueId = pe.m_id;
// only execute this poll if pe.m_pollCounter == 1; otherwise decrement the counter and process the next polled value
if( pe.m_pollCounter != 1)
{
pe.m_pollCounter--;
m_pollList.push_back( pe );
m_pollMutex->Unlock();
continue;
}
// reset the poll counter to the full pollIntensity value and push it at the end of the list
// release the value object referenced; call GetNode to ensure the node objects are locked during this period
{
LockGuard LG(m_nodeMutex);
(void)GetNode( valueId.GetNodeId() );
Value* value = GetValue( valueId );
if (!value)
continue;
pe.m_pollCounter = value->GetPollIntensity();
m_pollList.push_back( pe );
value->Release();
}
// If the polling interval is for the whole poll list, calculate the time before the next poll,
// so that all polls can take place within the user-specified interval.
if( !m_bIntervalBetweenPolls )
{
if( pollInterval < 100 )
{
Log::Write( LogLevel_Info, "The pollInterval setting is only %d, which appears to be a legacy setting. Multiplying by 1000 to convert to ms.", pollInterval );
pollInterval *= 1000;
}
pollInterval /= (int32) m_pollList.size();
}
{
LockGuard LG(m_nodeMutex);
// Request the state of the value from the node to which it belongs
if( Node* node = GetNode( valueId.GetNodeId() ) )
{
bool requestState = true;
if( !node->IsListeningDevice() )
{
// The device is not awake all the time. If it is not awake, we mark it
// as requiring a poll. The poll will be done next time the node wakes up.
if( WakeUp* wakeUp = static_cast( node->GetCommandClass( WakeUp::StaticGetCommandClassId() ) ) )
{
if( !wakeUp->IsAwake() )
{
wakeUp->SetPollRequired();
requestState = false;
}
}
}
if( requestState )
{
// Request an update of the value
CommandClass* cc = node->GetCommandClass( valueId.GetCommandClassId() );
if (cc) {
uint8 index = valueId.GetIndex();
uint8 instance = valueId.GetInstance();
Log::Write( LogLevel_Detail, node->m_nodeId, "Polling: %s index = %d instance = %d (poll queue has %d messages)", cc->GetCommandClassName().c_str(), index, instance, m_msgQueue[MsgQueue_Poll].size() );
cc->RequestValue( 0, index, instance, MsgQueue_Poll );
}
}
}
}
m_pollMutex->Unlock();
// Polling messages are only sent when there are no other messages waiting to be sent
// While this makes the polls much more variable and uncertain if some other activity dominates
// a send queue, that may be appropriate
// TODO we can have a debate about whether to test all four queues or just the Poll queue
// Wait until the library isn't actively sending messages (or in the midst of a transaction)
int i32;
int loopCount = 0;
while( !m_msgQueue[MsgQueue_Poll].empty()
|| !m_msgQueue[MsgQueue_Send].empty()
|| !m_msgQueue[MsgQueue_Command].empty()
|| !m_msgQueue[MsgQueue_Query].empty()
|| m_currentMsg != NULL )
{
i32 = Wait::Single( _exitEvent, 10); // test conditions every 10ms
if( i32 == 0 )
{
// Exit has been called
return;
}
loopCount++;
if( loopCount == 3000*10 ) // 300 seconds worth of delay? Something unusual is going on
{
Log::Write( LogLevel_Warning, "Poll queue hasn't been able to execute for 300 secs or more" );
Log::QueueDump();
// assert( 0 );
}
}
// ready for next poll...insert the pollInterval delay
i32 = Wait::Single( _exitEvent, pollInterval );
if( i32 == 0 )
{
// Exit has been called
return;
}
}
else // poll list is empty or awake nodes haven't been fully queried yet
{
// don't poll just yet, wait for the pollInterval or exit before re-checking to see if the pollList has elements
int32 i32 = Wait::Single( _exitEvent, 500 );
if( i32 == 0 )
{
// Exit has been called
return;
}
}
}
}
//-----------------------------------------------------------------------------
// Retrieving Node information
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//
// Delete all nodes and fetch new node data from the Z-Wave network
//-----------------------------------------------------------------------------
void Driver::InitAllNodes
(
)
{
// Delete all the node data
LockGuard LG(m_nodeMutex);
for( int i=0; i<256; ++i )
{
if( m_nodes[i] )
{
delete m_nodes[i];
m_nodes[i] = NULL;
}
}
LG.Unlock();
// Fetch new node data from the Z-Wave network
m_controller->PlayInitSequence( this );
}
//-----------------------------------------------------------------------------
//
// Queue a node to be interrogated for its setup details
//-----------------------------------------------------------------------------
void Driver::InitNode
(
uint8 const _nodeId,
bool newNode,
bool secure,
uint8 const *_protocolInfo,
uint8 const _length
)
{
// Delete any existing node and replace it with a new one
{
LockGuard LG(m_nodeMutex);
if( m_nodes[_nodeId] )
{
// Remove the original node
delete m_nodes[_nodeId];
Notification* notification = new Notification( Notification::Type_NodeRemoved );
notification->SetHomeAndNodeIds( m_homeId, _nodeId );
QueueNotification( notification );
}
// Add the new node
m_nodes[_nodeId] = new Node( m_homeId, _nodeId );
if (newNode == true) static_cast(m_nodes[_nodeId])->SetAddingNode();
}
Notification* notification = new Notification( Notification::Type_NodeAdded );
notification->SetHomeAndNodeIds( m_homeId, _nodeId );
QueueNotification( notification );
if (_length == 0) {
// Request the node info
m_nodes[_nodeId]->SetQueryStage( Node::QueryStage_ProtocolInfo );
} else {
if (isNetworkKeySet())
m_nodes[_nodeId]->SetSecured(secure);
else
Log::Write(LogLevel_Info, _nodeId, "Network Key Not Set - Secure Option is %s", secure ? "required" : "not required");
m_nodes[_nodeId]->SetProtocolInfo(_protocolInfo, _length);
}
Log::Write(LogLevel_Info, _nodeId, "Initilizing Node. New Node: %s (%s)", static_cast(m_nodes[_nodeId])->IsAddingNode() ? "true" : "false", newNode ? "true" : "false");
}
//-----------------------------------------------------------------------------
//
// Get whether the node is a listening device that does not go to sleep
//-----------------------------------------------------------------------------
bool Driver::IsNodeListeningDevice
(
uint8 const _nodeId
)
{
bool res = false;
LockGuard LG(m_nodeMutex);
if( Node* node = GetNode( _nodeId ) )
{
res = node->IsListeningDevice();
}
return res;
}
//-----------------------------------------------------------------------------
//
// Get whether the node is a listening device that does not go to sleep
//-----------------------------------------------------------------------------
bool Driver::IsNodeFrequentListeningDevice
(
uint8 const _nodeId
)
{
bool res = false;
LockGuard LG(m_nodeMutex);
if( Node* node = GetNode( _nodeId ) )
{
res = node->IsFrequentListeningDevice();
}
return res;
}
//-----------------------------------------------------------------------------
//
// Get whether the node is a beam capable device.
//-----------------------------------------------------------------------------
bool Driver::IsNodeBeamingDevice
(
uint8 const _nodeId
)
{
bool res = false;
LockGuard LG(m_nodeMutex);
if( Node* node = GetNode( _nodeId ) )
{
res = node->IsBeamingDevice();
}
return res;
}
//-----------------------------------------------------------------------------
//
// Get whether the node is a routing device that passes messages to other nodes
//-----------------------------------------------------------------------------
bool Driver::IsNodeRoutingDevice
(
uint8 const _nodeId
)
{
bool res = false;
LockGuard LG(m_nodeMutex);
if( Node* node = GetNode( _nodeId ) )
{
res = node->IsRoutingDevice();
}
return res;
}
//-----------------------------------------------------------------------------
//
// Get the security attribute for a node
//-----------------------------------------------------------------------------
bool Driver::IsNodeSecurityDevice
(
uint8 const _nodeId
)
{
bool security = false;
LockGuard LG(m_nodeMutex);
if( Node* node = GetNode( _nodeId ) )
{
security = node->IsSecurityDevice();
}
return security;
}
//-----------------------------------------------------------------------------
//
// Get the maximum baud rate of a node's communications
//-----------------------------------------------------------------------------
uint32 Driver::GetNodeMaxBaudRate
(
uint8 const _nodeId
)
{
uint32 baud = 0;
LockGuard LG(m_nodeMutex);
if( Node* node = GetNode( _nodeId ) )
{
baud = node->GetMaxBaudRate();
}
return baud;
}
//-----------------------------------------------------------------------------
//
// Get the version number of a node
//-----------------------------------------------------------------------------
uint8 Driver::GetNodeVersion
(
uint8 const _nodeId
)
{
uint8 version = 0;
LockGuard LG(m_nodeMutex);
if( Node* node = GetNode( _nodeId ) )
{
version = node->GetVersion();
}
return version;
}
//-----------------------------------------------------------------------------
//
// Get the security byte of a node
//-----------------------------------------------------------------------------
uint8 Driver::GetNodeSecurity
(
uint8 const _nodeId
)
{
uint8 security = 0;
LockGuard LG(m_nodeMutex);
if( Node* node = GetNode( _nodeId ) )
{
security = node->GetSecurity();
}
return security;
}
//-----------------------------------------------------------------------------
//
// Get the basic type of a node
//-----------------------------------------------------------------------------
uint8 Driver::GetNodeBasic
(
uint8 const _nodeId
)
{
uint8 basic = 0;
LockGuard LG(m_nodeMutex);
if( Node* node = GetNode( _nodeId ) )
{
basic = node->GetBasic();
}
return basic;
}
//-----------------------------------------------------------------------------
//
// Get the generic type of a node
//-----------------------------------------------------------------------------
uint8 Driver::GetNodeGeneric
(
uint8 const _nodeId
)
{
uint8 genericType = 0;
LockGuard LG(m_nodeMutex);
if( Node* node = GetNode( _nodeId ) )
{
genericType = node->GetGeneric();
}
return genericType;
}
//-----------------------------------------------------------------------------
//
// Get the specific type of a node
//-----------------------------------------------------------------------------
uint8 Driver::GetNodeSpecific
(
uint8 const _nodeId
)
{
uint8 specific = 0;
LockGuard LG(m_nodeMutex);
if( Node* node = GetNode( _nodeId ) )
{
specific = node->GetSpecific();
}
return specific;
}
//-----------------------------------------------------------------------------
//
// Get the basic/generic/specific type of the specified node
// Returns a copy of the string rather than a const ref for thread safety
//-----------------------------------------------------------------------------
string Driver::GetNodeType
(
uint8 const _nodeId
)
{
LockGuard LG(m_nodeMutex);
if( Node* node = GetNode( _nodeId ) )
{
return node->GetType();
}
return "Unknown";
}
bool Driver::IsNodeZWavePlus
(
uint8 const _nodeId
)
{
LockGuard LG(m_nodeMutex);
if( Node* node = GetNode( _nodeId ) )
{
return node->IsNodeZWavePlus();
}
return false;
}
//-----------------------------------------------------------------------------
//
// Gets the neighbors for a node
//-----------------------------------------------------------------------------
uint32 Driver::GetNodeNeighbors
(
uint8 const _nodeId,
uint8** o_neighbors
)
{
uint32 numNeighbors = 0;
LockGuard LG(m_nodeMutex);
if( Node* node = GetNode( _nodeId ) )
{
numNeighbors = node->GetNeighbors( o_neighbors );
}
return numNeighbors;
}
//-----------------------------------------------------------------------------
//
// Get the manufacturer name for the node with the specified ID
// Returns a copy of the string rather than a const ref for thread safety
//-----------------------------------------------------------------------------
string Driver::GetNodeManufacturerName
(
uint8 const _nodeId
)
{
LockGuard LG(m_nodeMutex);
if( Node* node = GetNode( _nodeId ) )
{
return node->GetManufacturerName();
}
return "";
}
//-----------------------------------------------------------------------------
//
// Get the product name for the node with the specified ID
// Returns a copy of the string rather than a const ref for thread safety
//-----------------------------------------------------------------------------
string Driver::GetNodeProductName
(
uint8 const _nodeId
)
{
LockGuard LG(m_nodeMutex);
if( Node* node = GetNode( _nodeId ) )
{
return node->GetProductName();
}
return "";
}
//-----------------------------------------------------------------------------
//
// Get the user-editable name for the node with the specified ID
// Returns a copy of the string rather than a const ref for thread safety
//-----------------------------------------------------------------------------
string Driver::GetNodeName
(
uint8 const _nodeId
)
{
LockGuard LG(m_nodeMutex);
if( Node* node = GetNode( _nodeId ) )
{
return node->GetNodeName();
}
return "";
}
//-----------------------------------------------------------------------------
//
// Get the user-editable string for location of the specified node
// Returns a copy of the string rather than a const ref for thread safety
//-----------------------------------------------------------------------------
string Driver::GetNodeLocation
(
uint8 const _nodeId
)
{
LockGuard LG(m_nodeMutex);
if( Node* node = GetNode( _nodeId ) )
{
return node->GetLocation();
}
return "";
}
//-----------------------------------------------------------------------------
//
// Get the manufacturer Id string value with the specified ID
// Returns a copy of the string rather than a const ref for thread safety
//-----------------------------------------------------------------------------
uint16 Driver::GetNodeManufacturerId
(
uint8 const _nodeId
)
{
LockGuard LG(m_nodeMutex);
if( Node* node = GetNode( _nodeId ) )
{
return node->GetManufacturerId();
}
return 0;
}
//-----------------------------------------------------------------------------
//
// Get the product type string value with the specified ID
// Returns a copy of the string rather than a const ref for thread safety
//-----------------------------------------------------------------------------
uint16 Driver::GetNodeProductType
(
uint8 const _nodeId
)
{
LockGuard LG(m_nodeMutex);
if( Node* node = GetNode( _nodeId ) )
{
return node->GetProductType();
}
return 0;
}
//-----------------------------------------------------------------------------
//
// Get the product Id string value with the specified ID
// Returns a copy of the string rather than a const ref for thread safety
//-----------------------------------------------------------------------------
uint16 Driver::GetNodeProductId
(
uint8 const _nodeId
)
{
LockGuard LG(m_nodeMutex);
if( Node* node = GetNode( _nodeId ) )
{
return node->GetProductId();
}
return 0;
}
//-----------------------------------------------------------------------------
//
// Get the node device type as reported in the Z-Wave+ Info report.
//-----------------------------------------------------------------------------
uint16 Driver::GetNodeDeviceType
(
uint8 const _nodeId
)
{
LockGuard LG(m_nodeMutex);
if( Node* node = GetNode( _nodeId ) )
{
return node->GetDeviceType();
}
return 0x00; // unknown
}
//-----------------------------------------------------------------------------
//
// Get the node DeviceType as a string as reported in the Z-Wave+ Info report.
//-----------------------------------------------------------------------------
string Driver::GetNodeDeviceTypeString
(
uint8 const _nodeId
)
{
LockGuard LG(m_nodeMutex);
if( Node* node = GetNode( _nodeId ) )
{
return node->GetDeviceTypeString();
}
return ""; // unknown
}
//-----------------------------------------------------------------------------
//
// Get the node role as reported in the Z-Wave+ Info report.
//-----------------------------------------------------------------------------
uint8 Driver::GetNodeRole
(
uint8 const _nodeId
)
{
LockGuard LG(m_nodeMutex);
if( Node* node = GetNode( _nodeId ) )
{
return node->GetRoleType();
}
return 0x00; // unknown
}
//-----------------------------------------------------------------------------
//
// Get the node role as a string as reported in the Z-Wave+ Info report.
//-----------------------------------------------------------------------------
string Driver::GetNodeRoleString
(
uint8 const _nodeId
)
{
LockGuard LG(m_nodeMutex);
if( Node* node = GetNode( _nodeId ) )
{
return node->GetRoleTypeString();
}
return ""; // unknown
}
//-----------------------------------------------------------------------------
//
// Get the node role as a string as reported in the Z-Wave+ Info report.
//-----------------------------------------------------------------------------
uint8 Driver::GetNodePlusType
(
uint8 const _nodeId
)
{
LockGuard LG(m_nodeMutex);
if( Node* node = GetNode( _nodeId ) )
{
return node->GetNodeType();
}
return 0x00; // unknown
}
//-----------------------------------------------------------------------------
//
// Get the node role as a string as reported in the Z-Wave+ Info report.
//-----------------------------------------------------------------------------
string Driver::GetNodePlusTypeString
(
uint8 const _nodeId
)
{
LockGuard LG(m_nodeMutex);
if( Node* node = GetNode( _nodeId ) )
{
return node->GetNodeTypeString();
}
return ""; // unknown
}
//-----------------------------------------------------------------------------
//
// Set the manufacturer name for the node with the specified ID
//-----------------------------------------------------------------------------
void Driver::SetNodeManufacturerName
(
uint8 const _nodeId,
string const& _manufacturerName
)
{
LockGuard LG(m_nodeMutex);
if( Node* node = GetNode( _nodeId ) )
{
node->SetManufacturerName( _manufacturerName );
}
}
//-----------------------------------------------------------------------------
//
// Set the product name string value with the specified ID
//-----------------------------------------------------------------------------
void Driver::SetNodeProductName
(
uint8 const _nodeId,
string const& _productName
)
{
LockGuard LG(m_nodeMutex);
if( Node* node = GetNode( _nodeId ) )
{
node->SetProductName( _productName );
}
}
//-----------------------------------------------------------------------------
//
// Set the node name string value with the specified ID
//-----------------------------------------------------------------------------
void Driver::SetNodeName
(
uint8 const _nodeId,
string const& _nodeName
)
{
LockGuard LG(m_nodeMutex);
if( Node* node = GetNode( _nodeId ) )
{
node->SetNodeName( _nodeName );
}
}
//-----------------------------------------------------------------------------
//
// Set the location string value with the specified ID
//-----------------------------------------------------------------------------
void Driver::SetNodeLocation
(
uint8 const _nodeId,
string const& _location
)
{
LockGuard LG(m_nodeMutex);
if( Node* node = GetNode( _nodeId ) )
{
node->SetLocation( _location );
}
}
//-----------------------------------------------------------------------------
//
// Helper to set the node level through the basic command class
//-----------------------------------------------------------------------------
void Driver::SetNodeLevel
(
uint8 const _nodeId,
uint8 const _level
)
{
LockGuard LG(m_nodeMutex);
if( Node* node = GetNode( _nodeId ) )
{
node->SetLevel( _level );
}
}
//-----------------------------------------------------------------------------
//
// Helper to set the node on through the basic command class
//-----------------------------------------------------------------------------
void Driver::SetNodeOn
(
uint8 const _nodeId
)
{
LockGuard LG(m_nodeMutex);
if( Node* node = GetNode( _nodeId ) )
{
node->SetNodeOn();
}
}
//-----------------------------------------------------------------------------
//
// Helper to set the node off through the basic command class
//-----------------------------------------------------------------------------
void Driver::SetNodeOff
(
uint8 const _nodeId
)
{
LockGuard LG(m_nodeMutex);
if( Node* node = GetNode( _nodeId ) )
{
node->SetNodeOff();
}
}
//-----------------------------------------------------------------------------
//
// Get a pointer to a Value object for the specified ValueID
//-----------------------------------------------------------------------------
Value* Driver::GetValue
(
ValueID const& _id
)
{
// This method is only called by code that has already locked the node
if( Node* node = m_nodes[_id.GetNodeId()] )
{
return node->GetValue( _id );
}
return NULL;
}
//-----------------------------------------------------------------------------
// Controller commands
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//
// Reset controller and erase all node information
//-----------------------------------------------------------------------------
void Driver::ResetController
(
Event* _evt
)
{
m_controllerResetEvent = _evt;
Log::Write( LogLevel_Info, "Reset controller and erase all node information");
Msg* msg = new Msg( "Reset controller and erase all node information", 0xff, REQUEST, FUNC_ID_ZW_SET_DEFAULT, true );
SendMsg( msg, MsgQueue_Command );
}
//-----------------------------------------------------------------------------
//
// Soft-reset the Z-Wave controller chip
//-----------------------------------------------------------------------------
void Driver::SoftReset
(
)
{
Log::Write( LogLevel_Info, "Soft-resetting the Z-Wave controller chip");
Msg* msg = new Msg( "Soft-resetting the Z-Wave controller chip", 0xff, REQUEST, FUNC_ID_SERIAL_API_SOFT_RESET, false, false );
SendMsg( msg, MsgQueue_Command );
}
//-----------------------------------------------------------------------------
//
// Get the neighbour information for a node from the controller
//-----------------------------------------------------------------------------
void Driver::RequestNodeNeighbors
(
uint8 const _nodeId,
uint32 const _requestFlags
)
{
if( IsAPICallSupported( FUNC_ID_ZW_GET_ROUTING_INFO ) )
{
// Note: This is not the same as RequestNodeNeighbourUpdate. This method
// merely requests the controller's current neighbour information and
// the reply will be copied into the relevant Node object for later use.
Log::Write( LogLevel_Detail, GetNodeNumber( m_currentMsg ), "Requesting routing info (neighbor list) for Node %d", _nodeId );
Msg* msg = new Msg( "Get Routing Info", _nodeId, REQUEST, FUNC_ID_ZW_GET_ROUTING_INFO, false );
msg->Append( _nodeId );
msg->Append( 0 ); // don't remove bad links
msg->Append( 0 ); // don't remove non-repeaters
msg->Append( 3 ); // funcid
SendMsg( msg, MsgQueue_Command );
}
}
//-----------------------------------------------------------------------------
//
// Start the controller performing one of its network management functions
// Create a ControllerCommand request.
//-----------------------------------------------------------------------------
bool Driver::BeginControllerCommand
(
ControllerCommand _command,
pfnControllerCallback_t _callback,
void* _context,
bool _highPower,
uint8 _nodeId,
uint8 _arg
)
{
ControllerCommandItem* cci;
MsgQueueItem item;
if( _command == ControllerCommand_None )
{
return false;
}
Log::Write( LogLevel_Detail, _nodeId, "Queuing (%s) %s", c_sendQueueNames[MsgQueue_Controller], c_controllerCommandNames[_command] );
cci = new ControllerCommandItem();
cci->m_controllerCommand = _command;
cci->m_controllerCallback = _callback;
cci->m_controllerCallbackContext = _context;
cci->m_highPower = _highPower;
cci->m_controllerCommandNode = _nodeId;
cci->m_controllerCommandArg = _arg;
cci->m_controllerState = ControllerState_Normal;
cci->m_controllerStateChanged = false;
cci->m_controllerCommandDone = false;
item.m_command = MsgQueueCmd_Controller;
item.m_cci = cci;
m_sendMutex->Lock();
m_msgQueue[MsgQueue_Controller].push_back( item );
m_queueEvent[MsgQueue_Controller]->Set();
m_sendMutex->Unlock();
return true;
}
//-----------------------------------------------------------------------------
//
// Start the controller performing one of its network management functions
//-----------------------------------------------------------------------------
void Driver::DoControllerCommand
(
)
{
UpdateControllerState( ControllerState_Starting );
switch( m_currentControllerCommand->m_controllerCommand )
{
case ControllerCommand_AddDevice:
{
if( !IsPrimaryController() )
{
UpdateControllerState( ControllerState_Error, ControllerError_NotPrimary );
}
else
{
Log::Write( LogLevel_Info, 0, "Add Device" );
Msg* msg = new Msg( "ControllerCommand_AddDevice", 0xff, REQUEST, FUNC_ID_ZW_ADD_NODE_TO_NETWORK, true );
uint8 options = ADD_NODE_ANY;
if (m_currentControllerCommand->m_highPower) options |= OPTION_HIGH_POWER;
if (IsAPICallSupported(FUNC_ID_ZW_EXPLORE_REQUEST_INCLUSION)) options |= OPTION_NWI;
msg->Append( options);
SendMsg( msg, MsgQueue_Command );
}
break;
}
case ControllerCommand_CreateNewPrimary:
{
if( IsPrimaryController() )
{
UpdateControllerState( ControllerState_Error, ControllerError_NotSecondary );
}
else if( !IsStaticUpdateController() )
{
UpdateControllerState( ControllerState_Error, ControllerError_NotSUC );
}
else
{
Log::Write( LogLevel_Info, 0, "Create New Primary" );
Msg* msg = new Msg( "ControllerCommand_CreateNewPrimary", 0xff, REQUEST, FUNC_ID_ZW_CREATE_NEW_PRIMARY, true );
msg->Append( CREATE_PRIMARY_START );
SendMsg( msg, MsgQueue_Command );
}
break;
}
case ControllerCommand_ReceiveConfiguration:
{
Log::Write( LogLevel_Info, 0, "Receive Configuration" );
Msg* msg = new Msg( "ControllerCommand_ReceiveConfiguration", 0xff, REQUEST, FUNC_ID_ZW_SET_LEARN_MODE, true );
msg->Append( 0xff );
SendMsg( msg, MsgQueue_Command );
break;
}
case ControllerCommand_RemoveDevice:
{
if( !IsPrimaryController() )
{
UpdateControllerState( ControllerState_Error, ControllerError_NotPrimary );
}
else
{
Log::Write( LogLevel_Info, 0, "Remove Device" );
Msg* msg = new Msg( "ControllerCommand_RemoveDevice", 0xff, REQUEST, FUNC_ID_ZW_REMOVE_NODE_FROM_NETWORK, true );
msg->Append( m_currentControllerCommand->m_highPower ? REMOVE_NODE_ANY | OPTION_HIGH_POWER : REMOVE_NODE_ANY );
SendMsg( msg, MsgQueue_Command );
}
break;
}
case ControllerCommand_HasNodeFailed:
{
Log::Write( LogLevel_Info, 0, "Requesting whether node %d has failed", m_currentControllerCommand->m_controllerCommandNode );
Msg* msg = new Msg( "ControllerCommand_HasNodeFailed", 0xff, REQUEST, FUNC_ID_ZW_IS_FAILED_NODE_ID, false );
msg->Append( m_currentControllerCommand->m_controllerCommandNode );
SendMsg( msg, MsgQueue_Command );
break;
}
case ControllerCommand_RemoveFailedNode:
{
Log::Write( LogLevel_Info, 0, "ControllerCommand_RemoveFailedNode", m_currentControllerCommand->m_controllerCommandNode );
Msg* msg = new Msg( "ControllerCommand_RemoveFailedNode", 0xff, REQUEST, FUNC_ID_ZW_REMOVE_FAILED_NODE_ID, true );
msg->Append( m_currentControllerCommand->m_controllerCommandNode );
SendMsg( msg, MsgQueue_Command );
break;
}
case ControllerCommand_ReplaceFailedNode:
{
Log::Write( LogLevel_Info, 0, "Replace Failed Node %d", m_currentControllerCommand->m_controllerCommandNode );
Msg* msg = new Msg( "ControllerCommand_ReplaceFailedNode", 0xff, REQUEST, FUNC_ID_ZW_REPLACE_FAILED_NODE, true );
msg->Append( m_currentControllerCommand->m_controllerCommandNode );
SendMsg( msg, MsgQueue_Command );
break;
}
case ControllerCommand_TransferPrimaryRole:
{
if( !IsPrimaryController() )
{
UpdateControllerState( ControllerState_Error, ControllerError_NotPrimary );
}
else
{
Log::Write( LogLevel_Info, 0, "Transfer Primary Role" );
Msg* msg = new Msg( "ControllerCommand_TransferPrimaryRole", 0xff, REQUEST, FUNC_ID_ZW_CONTROLLER_CHANGE, true );
msg->Append( m_currentControllerCommand->m_highPower ? CONTROLLER_CHANGE_START | OPTION_HIGH_POWER : CONTROLLER_CHANGE_START );
SendMsg( msg, MsgQueue_Command );
}
break;
}
case ControllerCommand_RequestNetworkUpdate:
{
if( !IsStaticUpdateController() )
{
UpdateControllerState( ControllerState_Error, ControllerError_NotSUC );
}
else
{
Log::Write( LogLevel_Info, 0, "Request Network Update" );
Msg* msg = new Msg( "ControllerCommand_RequestNetworkUpdate", 0xff, REQUEST, FUNC_ID_ZW_REQUEST_NETWORK_UPDATE, true );
SendMsg( msg, MsgQueue_Command );
}
break;
}
case ControllerCommand_RequestNodeNeighborUpdate:
{
if( !IsPrimaryController() )
{
UpdateControllerState( ControllerState_Error, ControllerError_NotPrimary );
}
else
{
Log::Write( LogLevel_Info, 0, "Requesting Neighbor Update for node %d", m_currentControllerCommand->m_controllerCommandNode );
bool opts = IsAPICallSupported( FUNC_ID_ZW_REQUEST_NODE_NEIGHBOR_UPDATE_OPTIONS );
Msg* msg;
if( opts )
{
msg = new Msg( "ControllerCommand_RequestNodeNeighborUpdate", m_currentControllerCommand->m_controllerCommandNode, REQUEST, FUNC_ID_ZW_REQUEST_NODE_NEIGHBOR_UPDATE_OPTIONS, true );
}
else
{
msg = new Msg( "ControllerCommand_RequestNodeNeighborUpdate", m_currentControllerCommand->m_controllerCommandNode, REQUEST, FUNC_ID_ZW_REQUEST_NODE_NEIGHBOR_UPDATE, true );
}
msg->Append( m_currentControllerCommand->m_controllerCommandNode );
if( opts )
{
msg->Append( GetTransmitOptions() );
}
SendMsg( msg, MsgQueue_Command );
}
break;
}
case ControllerCommand_AssignReturnRoute:
{
Log::Write( LogLevel_Info, 0, "Assigning return route from node %d to node %d", m_currentControllerCommand->m_controllerCommandNode, m_currentControllerCommand->m_controllerCommandArg );
Msg* msg = new Msg( "ControllerCommand_AssignReturnRoute", m_currentControllerCommand->m_controllerCommandNode, REQUEST, FUNC_ID_ZW_ASSIGN_RETURN_ROUTE, true );
msg->Append( m_currentControllerCommand->m_controllerCommandNode ); // from the node
msg->Append( m_currentControllerCommand->m_controllerCommandArg ); // to the specific destination
SendMsg( msg, MsgQueue_Command );
break;
}
case ControllerCommand_DeleteAllReturnRoutes:
{
Log::Write( LogLevel_Info, 0, "Deleting all return routes from node %d", m_currentControllerCommand->m_controllerCommandNode );
Msg* msg = new Msg( "ControllerCommand_DeleteAllReturnRoutess", m_currentControllerCommand->m_controllerCommandNode, REQUEST, FUNC_ID_ZW_DELETE_RETURN_ROUTE, true );
msg->Append( m_currentControllerCommand->m_controllerCommandNode ); // from the node
SendMsg( msg, MsgQueue_Command );
break;
}
case ControllerCommand_SendNodeInformation:
{
Log::Write( LogLevel_Info, 0, "Sending a node information frame" );
Msg* msg = new Msg( "ControllerCommand_SendNodeInformation", m_currentControllerCommand->m_controllerCommandNode, REQUEST, FUNC_ID_ZW_SEND_NODE_INFORMATION, true );
msg->Append( m_currentControllerCommand->m_controllerCommandNode ); // to the node
msg->Append( GetTransmitOptions() );
SendMsg( msg, MsgQueue_Command );
break;
}
case ControllerCommand_ReplicationSend:
{
if( !IsPrimaryController() )
{
UpdateControllerState( ControllerState_Error, ControllerError_NotPrimary );
}
else
{
Log::Write( LogLevel_Info, 0, "Replication Send" );
Msg* msg = new Msg( "ControllerCommand_ReplicationSend", 0xff, REQUEST, FUNC_ID_ZW_ADD_NODE_TO_NETWORK, true );
msg->Append( m_currentControllerCommand->m_highPower ? ADD_NODE_CONTROLLER | OPTION_HIGH_POWER : ADD_NODE_CONTROLLER );
SendMsg( msg, MsgQueue_Command );
}
break;
}
case ControllerCommand_CreateButton:
{
if( IsBridgeController() )
{
Node* node = GetNodeUnsafe( m_currentControllerCommand->m_controllerCommandNode );
if( node != NULL )
{
if( node->m_buttonMap.find( m_currentControllerCommand->m_controllerCommandArg ) == node->m_buttonMap.end() && m_virtualNeighborsReceived )
{
bool found = false;
for( uint8 n = 1; n <= 232 && !found; n++ )
{
if( !IsVirtualNode( n ))
continue;
map::iterator it = node->m_buttonMap.begin();
for( ; it != node->m_buttonMap.end(); ++it )
{
// is virtual node already in map?
if( it->second == n )
break;
}
if( it == node->m_buttonMap.end() ) // found unused virtual node
{
node->m_buttonMap[m_currentControllerCommand->m_controllerCommandArg] = n;
SendVirtualNodeInfo( n, m_currentControllerCommand->m_controllerCommandNode );
found = true;
}
}
if( !found ) // create a new virtual node
{
Log::Write( LogLevel_Info, 0, "AddVirtualNode" );
Msg* msg = new Msg( "FUNC_ID_SERIAL_API_SLAVE_NODE_INFO", 0xff, REQUEST, FUNC_ID_SERIAL_API_SLAVE_NODE_INFO, false, false );
msg->Append( 0 ); // node 0
msg->Append( 1 ); // listening
msg->Append( 0x09 ); // genericType window covering
msg->Append( 0x00 ); // specificType undefined
msg->Append( 0 ); // length
SendMsg( msg, MsgQueue_Command );
msg = new Msg( "FUNC_ID_ZW_SET_SLAVE_LEARN_MODE", 0xff, REQUEST, FUNC_ID_ZW_SET_SLAVE_LEARN_MODE, true );
msg->Append( 0 ); // node 0 to add
if( IsPrimaryController() || IsInclusionController() )
{
msg->Append( SLAVE_LEARN_MODE_ADD );
}
else
{
msg->Append( SLAVE_LEARN_MODE_ENABLE );
}
SendMsg( msg, MsgQueue_Command );
}
}
else
{
UpdateControllerState( ControllerState_Error, ControllerError_ButtonNotFound );
}
}
else
{
UpdateControllerState( ControllerState_Error, ControllerError_NodeNotFound );
}
} else
{
UpdateControllerState( ControllerState_Error, ControllerError_NotBridge );
}
break;
}
case ControllerCommand_DeleteButton:
{
if( IsBridgeController() )
{
Node* node = GetNodeUnsafe( m_currentControllerCommand->m_controllerCommandNode );
if( node != NULL )
{
// Make sure button is allocated to a virtual node.
if( node->m_buttonMap.find( m_currentControllerCommand->m_controllerCommandArg ) != node->m_buttonMap.end() )
{
#ifdef notdef
// We would need a reference count to decide when to free virtual nodes
// We could do this by making the bitmap of virtual nodes into a map that also holds a reference count.
Log::Write( LogLevel_Info, 0, "RemoveVirtualNode %d", m_currentControllerCommand->m_controllerCommandNode );
Msg* msg = new Msg( "Remove Virtual Node", 0xff, REQUEST, FUNC_ID_ZW_SET_SLAVE_LEARN_MODE, true );
msg->Append( m_currentControllerCommand->m_controllerCommandNode ); // from the node
if( IsPrimaryController() || IsInclusionController() )
msg->Append( SLAVE_LEARN_MODE_REMOVE );
else
msg->Append( SLAVE_LEARN_MODE_ENABLE );
SendMsg( msg );
#endif
node->m_buttonMap.erase( m_currentControllerCommand->m_controllerCommandArg );
SaveButtons();
Notification* notification = new Notification( Notification::Type_DeleteButton );
notification->SetHomeAndNodeIds( m_homeId, m_currentControllerCommand->m_controllerCommandNode );
notification->SetButtonId( m_currentControllerCommand->m_controllerCommandArg );
QueueNotification( notification );
}
else
{
UpdateControllerState( ControllerState_Error, ControllerError_ButtonNotFound );
}
}
else
{
UpdateControllerState( ControllerState_Error, ControllerError_NodeNotFound );
}
}
else
{
UpdateControllerState( ControllerState_Error, ControllerError_NotBridge );
}
break;
}
case ControllerCommand_None:
{
// To keep gcc quiet
break;
}
}
}
//-----------------------------------------------------------------------------
//
// Stop the current controller function
//-----------------------------------------------------------------------------
void Driver::UpdateControllerState( ControllerState const _state, ControllerError const _error )
{
if( m_currentControllerCommand != NULL )
{
if( _state != m_currentControllerCommand->m_controllerState )
{
m_currentControllerCommand->m_controllerStateChanged = true;
m_currentControllerCommand->m_controllerState = _state;
switch( _state )
{
case ControllerState_Error:
case ControllerState_Cancel:
case ControllerState_Failed:
case ControllerState_Sleeping:
case ControllerState_NodeFailed:
case ControllerState_NodeOK:
case ControllerState_Completed:
{
m_currentControllerCommand->m_controllerCommandDone = true;
m_sendMutex->Lock();
m_queueEvent[MsgQueue_Controller]->Set();
m_sendMutex->Unlock();
break;
}
default:
{
break;
}
}
}
Notification* notification = new Notification( Notification::Type_ControllerCommand );
notification->SetHomeAndNodeIds(m_homeId, 0);
notification->SetEvent(_state);
if( _error != ControllerError_None )
{
m_currentControllerCommand->m_controllerReturnError = _error;
/* Create a new Notification Callback */
notification->SetNotification(_error);
}
QueueNotification( notification );
}
}
//-----------------------------------------------------------------------------
//
// Stop the current controller function
//-----------------------------------------------------------------------------
bool Driver::CancelControllerCommand
(
)
{
if( m_currentControllerCommand == NULL )
{
// Controller is not doing anything
return false;
}
switch( m_currentControllerCommand->m_controllerCommand )
{
case ControllerCommand_AddDevice:
{
Log::Write( LogLevel_Info, 0, "Cancel Add Node" );
m_currentControllerCommand->m_controllerCommandNode = 0xff; // identify the fact that there is no new node to initialize
AddNodeStop( FUNC_ID_ZW_ADD_NODE_TO_NETWORK );
break;
}
case ControllerCommand_CreateNewPrimary:
{
Log::Write( LogLevel_Info, 0, "Cancel Create New Primary" );
Msg* msg = new Msg( "CreateNewPrimary Stop", 0xff, REQUEST, FUNC_ID_ZW_CREATE_NEW_PRIMARY, true );
msg->Append( CREATE_PRIMARY_STOP );
SendMsg( msg, MsgQueue_Command );
break;
}
case ControllerCommand_ReceiveConfiguration:
{
Log::Write( LogLevel_Info, 0, "Cancel Receive Configuration" );
Msg* msg = new Msg( "ReceiveConfiguration Stop", 0xff, REQUEST, FUNC_ID_ZW_SET_LEARN_MODE, false, false );
msg->Append( 0 );
SendMsg( msg, MsgQueue_Command );
break;
}
case ControllerCommand_RemoveDevice:
{
Log::Write( LogLevel_Info, 0, "Cancel Remove Device" );
m_currentControllerCommand->m_controllerCommandNode = 0xff; // identify the fact that there is no node to remove
AddNodeStop( FUNC_ID_ZW_REMOVE_NODE_FROM_NETWORK );
break;
}
case ControllerCommand_TransferPrimaryRole:
{
Log::Write( LogLevel_Info, 0, "Cancel Transfer Primary Role" );
Msg* msg = new Msg( "Transfer Primary Role Stop", 0xff, REQUEST, FUNC_ID_ZW_CONTROLLER_CHANGE, true );
msg->Append( CONTROLLER_CHANGE_STOP );
SendMsg( msg, MsgQueue_Command );
break;
}
case ControllerCommand_ReplicationSend:
{
Log::Write( LogLevel_Info, 0, "Cancel Replication Send" );
m_currentControllerCommand->m_controllerCommandNode = 0xff; // identify the fact that there is no new node to initialize
AddNodeStop( FUNC_ID_ZW_ADD_NODE_TO_NETWORK );
break;
}
case ControllerCommand_CreateButton:
case ControllerCommand_DeleteButton:
{
if( m_currentControllerCommand->m_controllerCommandNode != 0 )
{
SendSlaveLearnModeOff();
}
break;
}
case ControllerCommand_None:
case ControllerCommand_RequestNetworkUpdate:
case ControllerCommand_RequestNodeNeighborUpdate:
case ControllerCommand_AssignReturnRoute:
case ControllerCommand_DeleteAllReturnRoutes:
case ControllerCommand_RemoveFailedNode:
case ControllerCommand_HasNodeFailed:
case ControllerCommand_ReplaceFailedNode:
case ControllerCommand_SendNodeInformation:
{
// Cannot cancel
return false;
}
}
UpdateControllerState( ControllerState_Cancel );
return true;
}
//-----------------------------------------------------------------------------
//
// Stop the Add Node mode based on API of controller
//-----------------------------------------------------------------------------
void Driver::AddNodeStop
(
uint8 const _funcId
)
{
if( m_currentControllerCommand == NULL )
{
// Controller is not doing anything
return;
}
if( m_serialAPIVersion[0] == 2 && m_serialAPIVersion[1] == 76 )
{
Msg* msg = new Msg( "Add Node Stop", 0xff, REQUEST, _funcId, false, false );
msg->Append( ADD_NODE_STOP );
SendMsg( msg, Driver::MsgQueue_Command );
}
else
{
Msg* msg = new Msg( "Add Node Stop", 0xff, REQUEST, _funcId, false, true );
msg->Append( ADD_NODE_STOP );
SendMsg( msg, Driver::MsgQueue_Command );
}
}
//-----------------------------------------------------------------------------
//
// Run a series of messages to a single node or every node on the network.
//-----------------------------------------------------------------------------
void Driver::TestNetwork
(
uint8 const _nodeId,
uint32 const _count
)
{
LockGuard LG(m_nodeMutex);
if( _nodeId == 0 ) // send _count messages to every node
{
for( int i=0; i<256; ++i )
{
if( i == m_Controller_nodeId ) // ignore sending to ourself
{
continue;
}
if( m_nodes[i] != NULL )
{
NoOperation *noop = static_cast( m_nodes[i]->GetCommandClass( NoOperation::StaticGetCommandClassId() ) );
for( int j=0; j < (int)_count; j++ )
{
noop->Set( true );
}
}
}
}
else if( _nodeId != m_Controller_nodeId && m_nodes[_nodeId] != NULL )
{
NoOperation *noop = static_cast( m_nodes[_nodeId]->GetCommandClass( NoOperation::StaticGetCommandClassId() ) );
for( int i=0; i < (int)_count; i++ )
{
noop->Set( true );
}
}
}
//-----------------------------------------------------------------------------
// SwitchAll
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//
// All devices that support the SwitchAll command class will be turned on
//-----------------------------------------------------------------------------
void Driver::SwitchAllOn
(
)
{
SwitchAll::On( this, 0xff );
LockGuard LG(m_nodeMutex);
for( int i=0; i<256; ++i )
{
if( GetNodeUnsafe( i ) )
{
if( m_nodes[i]->GetCommandClass( SwitchAll::StaticGetCommandClassId() ) )
{
SwitchAll::On( this, (uint8)i );
}
}
}
}
//-----------------------------------------------------------------------------
//
// All devices that support the SwitchAll command class will be turned off
//-----------------------------------------------------------------------------
void Driver::SwitchAllOff
(
)
{
SwitchAll::Off( this, 0xff );
LockGuard LG(m_nodeMutex);
for( int i=0; i<256; ++i )
{
if( GetNodeUnsafe( i ) )
{
if( m_nodes[i]->GetCommandClass( SwitchAll::StaticGetCommandClassId() ) )
{
SwitchAll::Off( this, (uint8)i );
}
}
}
}
//-----------------------------------------------------------------------------
//
// Set the value of one of the configuration parameters of a device
//-----------------------------------------------------------------------------
bool Driver::SetConfigParam
(
uint8 const _nodeId,
uint8 const _param,
int32 _value,
uint8 _size
)
{
LockGuard LG(m_nodeMutex);
if( Node* node = GetNode( _nodeId ) )
{
return node->SetConfigParam( _param, _value, _size );
}
return false;
}
//-----------------------------------------------------------------------------
//
// Request the value of one of the configuration parameters of a device
//-----------------------------------------------------------------------------
void Driver::RequestConfigParam
(
uint8 const _nodeId,
uint8 const _param
)
{
LockGuard LG(m_nodeMutex);
if( Node* node = GetNode( _nodeId ) )
{
node->RequestConfigParam( _param );
}
}
//-----------------------------------------------------------------------------
//
// Gets the number of association groups reported by this node
//-----------------------------------------------------------------------------
uint8 Driver::GetNumGroups
(
uint8 const _nodeId
)
{
uint8 numGroups = 0;
LockGuard LG(m_nodeMutex);
if( Node* node = GetNode( _nodeId ) )
{
numGroups = node->GetNumGroups();
}
return numGroups;
}
//-----------------------------------------------------------------------------
//
// Gets the associations for a group
//-----------------------------------------------------------------------------
uint32 Driver::GetAssociations
(
uint8 const _nodeId,
uint8 const _groupIdx,
uint8** o_associations
)
{
uint32 numAssociations = 0;
LockGuard LG(m_nodeMutex);
if( Node* node = GetNode( _nodeId ) )
{
numAssociations = node->GetAssociations( _groupIdx, o_associations );
}
return numAssociations;
}
//-----------------------------------------------------------------------------
//
// Gets the associations for a group
//-----------------------------------------------------------------------------
uint32 Driver::GetAssociations
(
uint8 const _nodeId,
uint8 const _groupIdx,
InstanceAssociation** o_associations
)
{
uint32 numAssociations = 0;
LockGuard LG(m_nodeMutex);
if( Node* node = GetNode( _nodeId ) )
{
numAssociations = node->GetAssociations( _groupIdx, o_associations );
}
return numAssociations;
}
//-----------------------------------------------------------------------------
//
// Gets the maximum number of associations for a group
//-----------------------------------------------------------------------------
uint8 Driver::GetMaxAssociations
(
uint8 const _nodeId,
uint8 const _groupIdx
)
{
uint8 maxAssociations = 0;
LockGuard LG(m_nodeMutex);
if( Node* node = GetNode( _nodeId ) )
{
maxAssociations = node->GetMaxAssociations( _groupIdx );
}
return maxAssociations;
}
//-----------------------------------------------------------------------------
//
// Gets the label for a particular group
//-----------------------------------------------------------------------------
string Driver::GetGroupLabel
(
uint8 const _nodeId,
uint8 const _groupIdx
)
{
string label = "";
LockGuard LG(m_nodeMutex);
if( Node* node = GetNode( _nodeId ) )
{
label = node->GetGroupLabel( _groupIdx );
}
return label;
}
//-----------------------------------------------------------------------------
//
// Adds a node to an association group
//-----------------------------------------------------------------------------
void Driver::AddAssociation
(
uint8 const _nodeId,
uint8 const _groupIdx,
uint8 const _targetNodeId,
uint8 const _instance
)
{
LockGuard LG(m_nodeMutex);
if( Node* node = GetNode( _nodeId ) )
{
node->AddAssociation( _groupIdx, _targetNodeId, _instance );
}
}
//-----------------------------------------------------------------------------
//
// Removes a node from an association group
//-----------------------------------------------------------------------------
void Driver::RemoveAssociation
(
uint8 const _nodeId,
uint8 const _groupIdx,
uint8 const _targetNodeId,
uint8 const _instance
)
{
LockGuard LG(m_nodeMutex);
if( Node* node = GetNode( _nodeId ) )
{
node->RemoveAssociation( _groupIdx, _targetNodeId, _instance );
}
}
//-----------------------------------------------------------------------------
//
// Add a notification to the queue to be sent at a later, safe time.
//-----------------------------------------------------------------------------
void Driver::QueueNotification
(
Notification* _notification
)
{
m_notifications.push_back( _notification );
m_notificationsEvent->Set();
}
//-----------------------------------------------------------------------------
//
// Notify any watching objects of a value change
//-----------------------------------------------------------------------------
void Driver::NotifyWatchers
(
)
{
list