- Rename all related structures and enums.
Change-Id: Ibd5cb5ca465abf0ab6254765a9d41b72fe108de2
Signed-off-by: saerome kim <saerome.kim@samsung.com>
Signed-off-by: Jiwan Kim <ji-wan.kim@samsung.com>
* limitations under the License.
*/
-#ifndef __ZIGBEE_ALARM_TYPE_H__
-#define __ZIGBEE_ALARM_TYPE_H__
+#ifndef __ZIGBEE_ZCL_ALARM_TYPE_H__
+#define __ZIGBEE_ZCL_ALARM_TYPE_H__
#include <zigbee_types.h>
/**
- * @brief Definition for get alarm count structure.
+ * @brief Definition for ZCL Alarm get alarm count structure.
* @since_tizen 3.0
*/
typedef struct {
char eui64[ZIGBEE_EUI64_SIZE]; /**< EUI64 (an IEEE address) */
char endpoint; /**< Endpoint */
-} ZigbeeAlarmGetAlarmCount_t;
+} ZigbeeZclAlarmGetAlarmCount_t;
/**
- * @brief Definition for reset alarm structure.
+ * @brief Definition for ZCL Alarm reset alarm structure.
* @since_tizen 3.0
*/
typedef struct {
char endpoint; /**< Endpoint */
char alarm_code; /**< Alarm code */
short cluster_id; /**< Cluster ID */
-} ZigbeeAlarmResetAlarm_t;
+} ZigbeeZclAlarmResetAlarm_t;
/**
- * @brief Definition for reset all alarm structure.
+ * @brief Definition for ZCL Alarm reset all alarm structure.
* @since_tizen 3.0
*/
typedef struct {
short node_id; /**< Node ID */
char endpoint; /**< Endpoint */
-} ZigbeeAlarmResetAllAlarm_t;
+} ZigbeeZclAlarmResetAllAlarm_t;
/**
- * @brief Definition for alarm structure.
+ * @brief Definition for ZCL Alarm alarm structure.
* @since_tizen 3.0
*/
typedef struct {
char endpoint; /**< Endpoint */
char alarm_code; /**< Alarm code */
short cluster_id; /**< Cluster ID */
-} ZigbeeAlarmAlarm_t;
+} ZigbeeZclAlarmAlarm_t;
/**
- * @brief Definition for reset all alarm logs structure.
+ * @brief Definition for ZCL Alarm reset all alarm logs structure.
* @since_tizen 3.0
*/
typedef struct {
short node_id; /**< Node ID */
char endpoint; /**< Endpoint */
-} ZigbeeAlarmResetAlarmLogs_t;
+} ZigbeeZclAlarmResetAlarmLogs_t;
/**
- * @brief Definition for get alarm structure.
+ * @brief Definition for ZCL Alarm get alarm structure.
* @since_tizen 3.0
*/
typedef struct {
short node_id; /**< Node ID */
char endpoint; /**< Endpoint */
-} ZigbeeAlarmGetAlarm_t;
+} ZigbeeZclAlarmGetAlarm_t;
-#endif /* __ZIGBEE_ALARM_TYPE_H__ */
+#endif /* __ZIGBEE_ZCL_ALARM_TYPE_H__ */
* limitations under the License.
*/
-#ifndef __ZIGBEE_ZCLBASIC_CONTROL_TYPE_H__
-#define __ZIGBEE_ZCLBASIC_CONTROL_TYPE_H__
+#ifndef __ZIGBEE_ZCL_BASIC_TYPE_H__
+#define __ZIGBEE_ZCL_BASIC_TYPE_H__
#include <zigbee_types.h>
/**
- * @brief Definition for Zclbasic control reset factort default structure.
+ * @brief Definition for ZCL Basic reset factory default structure.
* @since_tizen 3.0
*/
typedef struct {
short node_id; /**< Node ID */
char dest_ep; /**< Destination endpoint */
-} ZigbeeZclbasicControlResetFactoryDefault_t;
+} ZigbeeZclBasicResetFactoryDefault_t;
-#endif /* __ZIGBEE_ZCLBASIC_CONTROL_TYPE_H__ */
+#endif /* __ZIGBEE_ZCL_BASIC_TYPE_H__ */
* limitations under the License.
*/
-#ifndef __ZIGBEE_ZCL_COLOR_TYPE_H__
-#define __ZIGBEE_ZCL_COLOR_TYPE_H__
+#ifndef __ZIGBEE_ZCL_COLOR_CONTROL_TYPE_H__
+#define __ZIGBEE_ZCL_COLOR_CONTROL_TYPE_H__
#include <zigbee_types.h>
/**
- * @brief Definition for Zcl color move to hue structure.
+ * @brief Definition for ZCL color control move to hue structure.
* @since_tizen 3.0
*/
typedef struct {
char dest_ep; /**< Destination endpoint */
char hue; /**< Hue */
char direction; /**< Direction */
- short transition_time; /**< Transtion time */
-} ZigbeeZclColorMoveToHue_t;
+ short transition_time; /**< Transition time */
+} ZigbeeZclColorControlMoveToHue_t;
/**
- * @brief Definition for Zcl color move hue structure.
+ * @brief Definition for ZCL color control move hue structure.
* @since_tizen 3.0
*/
typedef struct {
char dest_ep; /**< Destination endpoint */
char move_mode; /**< Move mode */
char rate; /**< Rate */
-} ZigbeeZclColorMoveHue_t;
+} ZigbeeZclColorControlMoveHue_t;
/**
- * @brief Definition for Zcl color step hue structure.
+ * @brief Definition for ZCL color control step hue structure.
* @since_tizen 3.0
*/
typedef struct {
char dest_ep; /**< Destination endpoint */
char step_mode; /**< Step mode */
char step_size; /**< Step size */
- short transition_time; /**< Transtion time */
-} ZigbeeZclColorStepHue_t;
+ short transition_time; /**< Transition time */
+} ZigbeeZclColorControlStepHue_t;
/**
- * @brief Definition for Zcl color move to staturation structure.
+ * @brief Definition for ZCL color control move to saturation structure.
* @since_tizen 3.0
*/
typedef struct {
short node_id; /**< Node ID */
char dest_ep; /**< Destination endpoint */
char saturation; /**< Saturation */
- short transition_time; /**< Transtion time */
-} ZigbeeZclColorMoveToSaturation_t;
+ short transition_time; /**< Transition time */
+} ZigbeeZclColorControlMoveToSaturation_t;
/**
- * @brief Definition for Zcl color move staturation structure.
+ * @brief Definition for ZCL color control move saturation structure.
* @since_tizen 3.0
*/
typedef struct {
char dest_ep; /**< Destination endpoint */
char move_mode; /**< Move mode */
char rate; /**< Rate */
-} ZigbeeZclColorMoveSaturation_t;
+} ZigbeeZclColorControlMoveSaturation_t;
/**
- * @brief Definition for Zcl color step saturation structure.
+ * @brief Definition for ZCL color control step saturation structure.
* @since_tizen 3.0
*/
typedef struct {
char dest_ep; /**< Destination endpoint */
char step_mode; /**< Step mode */
char step_size; /**< Step size */
- short transition_time; /**< Transtion time */
-} ZigbeeZclColorStepSaturation_t;
+ short transition_time; /**< Transition time */
+} ZigbeeZclColorControlStepSaturation_t;
/**
- * @brief Definition for Zcl color move to hue and saturation structure.
+ * @brief Definition for ZCL color control move to hue and saturation structure.
* @since_tizen 3.0
*/
typedef struct {
char dest_ep; /**< Destination endpoint */
char hue; /**< Hue */
char saturation; /**< Saturation */
- short transition_time; /**< Transtion time */
-} ZigbeeZclColorMoveToHueAndSaturation_t;
+ short transition_time; /**< Transition time */
+} ZigbeeZclColorControlMoveToHueAndSaturation_t;
/**
- * @brief Definition for Zcl color move to color structure.
+ * @brief Definition for ZCL color control move to color structure.
* @since_tizen 3.0
*/
typedef struct {
char dest_ep; /**< Destination endpoint */
short color_x; /**< Color X */
short color_y; /**< Color Y */
- short transition_time; /**< Transtion time */
-} ZigbeeZclColorMoveToColor_t;
+ short transition_time; /**< Transition time */
+} ZigbeeZclColorControlMoveToColor_t;
/**
- * @brief Definition for Zcl color move color structure.
+ * @brief Definition for ZCL color control move color structure.
* @since_tizen 3.0
*/
typedef struct {
char dest_ep; /**< Destination endpoint */
short rate_x; /**< Rate X */
short rate_y; /**< Rate Y */
-} ZigbeeZclColorMoveColor_t;
+} ZigbeeZclColorControlMoveColor_t;
/**
- * @brief Definition for Zcl color step color structure.
+ * @brief Definition for ZCL color control step color structure.
* @since_tizen 3.0
*/
typedef struct {
char dest_ep; /**< Destination endpoint */
short rate_x; /**< Rate X */
short rate_y; /**< Rate Y */
- short transition_time; /**< Transtion time */
-} ZigbeeZclColorStepColor_t;
+ short transition_time; /**< Transition time */
+} ZigbeeZclColorControlStepColor_t;
/**
- * @brief Definition for Zcl color move color temperature structure.
+ * @brief Definition for ZCL color control move color temperature structure.
* @since_tizen 3.0
*/
typedef struct {
short node_id; /**< Node ID */
char dest_ep; /**< Destination endpoint */
short color_temperature; /**< Color temperature*/
- short transition_time; /**< Transtion time */
-} ZigbeeZclColorMoveColorTemperature_t;
+ short transition_time; /**< Transition time */
+} ZigbeeZclColorControlMoveColorTemperature_t;
-#endif /* __ZIGBEE_ZCL_COLOR_TYPE_H__ */
+#endif /* __ZIGBEE_ZCL_COLOR_CONTROL_TYPE_H__ */
* limitations under the License.
*/
-#ifndef __ZIGBEE_DOOR_LOCK_TYPE_H__
-#define __ZIGBEE_DOOR_LOCK_TYPE_H__
+#ifndef __ZIGBEE_ZCL_DOOR_LOCK_TYPE_H__
+#define __ZIGBEE_ZCL_DOOR_LOCK_TYPE_H__
#include <zigbee_types.h>
/**
- * @brief Definition for subscriber lock event structure.
+ * @brief Definition for ZCL door lock subscriber lock event structure.
* @since_tizen 3.0
*/
typedef struct {
char eui64[ZIGBEE_EUI64_SIZE]; /**< EUI64 (an IEEE address) */
char endpoint; /**< Endpoint */
-} ZigbeeDoorLockSubscriberLockEvent_t;
+} ZigbeeZclDoorLockSubscriberLockEvent_t;
/**
- * @brief Definition for set door lock pin structure.
+ * @brief Definition for ZCL door lock set door lock pin structure.
* @since_tizen 3.0
*/
typedef struct {
char eui64[ZIGBEE_EUI64_SIZE]; /**< EUI64 (an IEEE address) */
char endpoint; /**< Endpoint */
char pin[ZIGBEE_DOOR_LOCK_MAX_PIN_LEN + 1];
-} ZigbeeDoorLockSetDoorLockPin_t;
+} ZigbeeZclDoorLockSetDoorLockPin_t;
/**
- * @brief Definition for set door lock state structure.
+ * @brief Definition for ZCL door lock set door lock state structure.
* @since_tizen 3.0
*/
typedef struct {
char endpoint; /**< Endpoint */
char pin[ZIGBEE_DOOR_LOCK_MAX_PIN_LEN + 1];
int lock_unlock_type;
-} ZigbeeDoorLockSetDoorLock_t;
+} ZigbeeZclDoorLockSetDoorLock_t;
/**
- * @brief Definition for get door lock state structure.
+ * @brief Definition for ZCL door lock get door lock state structure.
* @since_tizen 3.0
*/
typedef struct {
char eui64[ZIGBEE_EUI64_SIZE]; /**< EUI64 (an IEEE address) */
char endpoint; /**< Endpoint */
-} ZigbeeDoorLockGetDoorLock_t;
+} ZigbeeZclDoorLockGetDoorLock_t;
-#endif /* __ZIGBEE_DOOR_LOCK_TYPE_H__ */
+#endif /* __ZIGBEE_ZCL_DOOR_LOCK_TYPE_H__ */
* limitations under the License.
*/
-#ifndef __ZIGBEE_FAN_CONTROL_TYPE_H__
-#define __ZIGBEE_FAN_CONTROL_TYPE_H__
+#ifndef __ZIGBEE_ZCL_FAN_CONTROL_TYPE_H__
+#define __ZIGBEE_ZCL_FAN_CONTROL_TYPE_H__
#include <zigbee_types.h>
/**
- * @brief Definition for fan control set fan mode structure.
+ * @brief Definition for ZCL fan control set fan mode structure.
* @since_tizen 3.0
*/
typedef struct {
char eui64[ZIGBEE_EUI64_SIZE]; /**< EUI64 (an IEEE address) */
char endpoint; /**< Endpoint */
-} ZigbeeFanControlSetFanMode_t;
+} ZigbeeZclFanControlSetFanMode_t;
/**
- * @brief Definition for fan control get fan mode structure.
+ * @brief Definition for ZCL fan control get fan mode structure.
* @since_tizen 3.0
*/
typedef struct {
char eui64[ZIGBEE_EUI64_SIZE]; /**< EUI64 (an IEEE address) */
char endpoint; /**< Endpoint */
-} ZigbeeFanControlGetFanMode_t;
+} ZigbeeZclFanControlGetFanMode_t;
/**
- * @brief Definition for fan control set fan mode sequence structure.
+ * @brief Definition for ZCL fan control set fan mode sequence structure.
* @since_tizen 3.0
*/
typedef struct {
char eui64[ZIGBEE_EUI64_SIZE]; /**< EUI64 (an IEEE address) */
char endpoint; /**< Endpoint */
-} ZigbeeFanControlSetFanModeSequence_t;
+} ZigbeeZclFanControlSetFanModeSequence_t;
/**
- * @brief Definition for fan control get fan mode sequence structure.
+ * @brief Definition for ZCL fan control get fan mode sequence structure.
* @since_tizen 3.0
*/
typedef struct {
char eui64[ZIGBEE_EUI64_SIZE]; /**< EUI64 (an IEEE address) */
char endpoint; /**< Endpoint */
-} ZigbeeFanControlGetFanModeSequence_t;
+} ZigbeeZclFanControlGetFanModeSequence_t;
-#endif /* __ZIGBEE_FAN_CONTROL_TYPE_H__ */
+#endif /* __ZIGBEE_ZCL_FAN_CONTROL_TYPE_H__ */
* limitations under the License.
*/
-#ifndef __ZIGBEE_ZCLGLOBAL_CONTROL_TYPE_H__
-#define __ZIGBEE_ZCLGLOBAL_CONTROL_TYPE_H__
+#ifndef __ZIGBEE_ZCL_GLOBAL_CONTROL_TYPE_H__
+#define __ZIGBEE_ZCL_GLOBAL_CONTROL_TYPE_H__
#include <zigbee_types.h>
/**
- * @brief Definition for Zclglobal control read attributes request structure.
+ * @brief Definition for ZCL Global control read attributes request structure.
* @since_tizen 3.0
*/
typedef struct {
- char *attribute_id; /**< Atttribute ID */
- int attribute_id_len; /**< Atttribute ID length */
+ char *attribute_id; /**< Attribute ID */
+ int attribute_id_len; /**< Attribute ID length */
short node_id; /**< Node ID */
char cluster_id; /**< Cluster ID */
char zcl_frame_ctrl; /**< ZCL frame control */
char dest_ep; /**< Destination endpoint */
-} ZigbeeZclglobalControlReadAttributesRequest_t;
+} ZigbeeZclGlobalControlReadAttributesRequest_t;
/**
- * @brief Definition for Zclglobal control write attributes request structure.
+ * @brief Definition for ZCL Global control write attributes request structure.
* @since_tizen 3.0
*/
typedef struct {
char zcl_frame_ctrl; /**< ZCL frame control */
char src_ep; /**< Source endpoint */
char dest_ep; /**< Destination endpoint */
-} ZigbeeZclglobalControlWriteAttributesRequest_t;
+} ZigbeeZclGlobalControlWriteAttributesRequest_t;
/**
- * @brief Definition for Zclglobal control write attributes undividied request structure.
+ * @brief Definition for ZCL Global control write attributes undivided request structure.
* @since_tizen 3.0
*/
typedef struct {
char zcl_frame_ctrl; /**< ZCL frame control */
char src_ep; /**< Source endpoint */
char dest_ep; /**< Destination endpoint */
-} ZigbeeZclglobalControlWriteAttributesUndividedRequest_t;
+} ZigbeeZclGlobalControlWriteAttributesUndividedRequest_t;
/**
- * @brief Definition for Zclglobal control write attributes no response structure.
+ * @brief Definition for ZCL Global control write attributes no response structure.
* @since_tizen 3.0
*/
typedef struct {
char zcl_frame_ctrl; /**< ZCL frame control */
char src_ep; /**< Source endpoint */
char dest_ep; /**< Destination endpoint */
-} ZigbeeZclglobalControlWriteAttributesNoResponse_t;
+} ZigbeeZclGlobalControlWriteAttributesNoResponse_t;
/**
- * @brief Definition for Zclglobal control write attritbutes structured structure.
+ * @brief Definition for ZCL Global control write attributes structured structure.
* @since_tizen 3.0
*/
typedef struct {
char zcl_frame_ctrl; /**< ZCL frame control */
char src_ep; /**< Source endpoint */
char dest_ep; /**< Destination endpoint */
-} ZigbeeZclglobalControlWriteAttributesStructed_t;
+} ZigbeeZclGlobalControlWriteAttributesStructed_t;
/**
- * @brief Definition forZclglobal control read attributes structured structure.
+ * @brief Definition forZCL Global control read attributes structured structure.
* @since_tizen 3.0
*/
typedef struct {
char zcl_frame_ctrl; /**< ZCL frame control */
char src_ep; /**< Source endpoint */
char dest_ep; /**< Destination endpoint */
-} ZigbeeZclglobalControlReadAttributesStructed_t;
+} ZigbeeZclGlobalControlReadAttributesStructed_t;
/**
- * @brief Definition for Zclglobal control configure reporting request structure.
+ * @brief Definition for ZCL Global control configure reporting request structure.
* @since_tizen 3.0
*/
typedef struct {
char zcl_frame_ctrl; /**< ZCL frame control */
char src_ep; /**< Source endpoint */
char dest_ep; /**< Destination endpoint */
-} ZigbeeZclglobalControlConfigureReportingReq_t;
+} ZigbeeZclGlobalControlConfigureReportingReq_t;
/**
- * @brief Definition for Zclglobal control read configure reporting structure.
+ * @brief Definition for ZCL Global control read configure reporting structure.
* @since_tizen 3.0
*/
typedef struct {
char zcl_frame_ctrl; /**< ZCL frame control */
char src_ep; /**< Source endpoint */
char dest_ep; /**< Destination endpoint */
-} ZigbeeZclglobalControlReadConfigureReporting_t;
+} ZigbeeZclGlobalControlReadConfigureReporting_t;
/**
- * @brief Definition for Zclglobal control discover attributes structure.
+ * @brief Definition for ZCL Global control discover attributes structure.
* @since_tizen 3.0
*/
typedef struct {
char cluster_id; /**< Cluster ID */
char start_attribute; /**< Start attribute */
char max; /**< Maximum */
-} ZigbeeZclglobalControlDiscoverAttributes_t;
+} ZigbeeZclGlobalControlDiscoverAttributes_t;
/**
- * @brief Definition for Zclglobal control discover attributes extended structure.
+ * @brief Definition for ZCL Global control discover attributes extended structure.
* @since_tizen 3.0
*/
typedef struct {
char cluster_id; /**< Cluster ID */
char start_attribute; /**< Start attribute */
char max; /**< Maximum */
-} ZigbeeZclglobalControlDiscoverAttributesExtended_t;
+} ZigbeeZclGlobalControlDiscoverAttributesExtended_t;
/**
- * @brief Definition for Zclglobal control discover commands received structure.
+ * @brief Definition for ZCL Global control discover commands received structure.
* @since_tizen 3.0
*/
typedef struct {
char cluster_id; /**< Cluster ID */
char start_attribute; /**< Start attribute */
char max; /**< Maximum */
-} ZigbeeZclglobalControlDiscoverCommandsReceived_t;
+} ZigbeeZclGlobalControlDiscoverCommandsReceived_t;
/**
- * @brief Definition for Zclglobal control discover commands generated structure.
+ * @brief Definition for ZCL Global control discover commands generated structure.
* @since_tizen 3.0
*/
typedef struct {
char cluster_id; /**< Cluster ID */
char start_attribute; /**< Start attribute */
char max; /**< Maximum */
-} ZigbeeZclglobalControlDiscoverCommandsGenerated_t;
+} ZigbeeZclGlobalControlDiscoverCommandsGenerated_t;
-#endif /* __ZIGBEE_ZCLGLOBAL_CONTROL_TYPE_H__ */
+#endif /* __ZIGBEE_ZCL_GLOBAL_CONTROL_TYPE_H__ */
#include <zigbee_types.h>
/**
- * @brief Definition for Zcl group add group structure.
+ * @brief Definition for ZCL Group add group structure.
* @since_tizen 3.0
*/
typedef struct {
} ZigbeeZclGroupAddGroup_t;
/**
- * @brief Definition for Zcl group view group structure.
+ * @brief Definition for ZCL Group view group structure.
* @since_tizen 3.0
*/
typedef struct {
} ZigbeeZclGroupViewGroup_t;
/**
- * @brief Definition for Zcl group get group membership structure.
+ * @brief Definition for ZCL Group get group membership structure.
* @since_tizen 3.0
*/
typedef struct {
} ZigbeeZclGroupGetGroupMembership_t;
/**
- * @brief Definition for Zcl group remove group structure.
+ * @brief Definition for ZCL Group remove group structure.
* @since_tizen 3.0
*/
typedef struct {
} ZigbeeZclGroupRemoveGroup_t;
/**
- * @brief Definition for Zcl group remove all group structure.
+ * @brief Definition for ZCL Group remove all group structure.
* @since_tizen 3.0
*/
typedef struct {
} ZigbeeZclGroupRemoveAllGroup_t;
/**
- * @brief Definition for Zcl group add group if identifying structure.
+ * @brief Definition for ZCL Group add group if identifying structure.
* @since_tizen 3.0
*/
typedef struct {
* limitations under the License.
*/
-#ifndef __ZIGBEE_ZCLIAS_CONTROL_TYPE_H__
-#define __ZIGBEE_ZCLIAS_CONTROL_TYPE_H__
+#ifndef __ZIGBEE_ZCL_IAS_ZONE_TYPE_H__
+#define __ZIGBEE_ZCL_IAS_ZONE_TYPE_H__
#include <zigbee_types.h>
/**
- * @brief Definition for Zclias control enrol response structure.
+ * @brief Definition for ZCL IAS zone enroll response structure.
* @since_tizen 3.0
*/
typedef struct {
short node_id; /**< Node ID */
char dest_ep; /**< Destination endpoint */
- char enroll_code; /**< Enrol code */
+ char enroll_code; /**< Enroll code */
char zone_id; /**< Zone ID */
-} ZigbeeZcliasControlEnrolResponse_t;
+} ZigbeeZclIasZoneEnrollResponse_t;
-#endif /* __ZIGBEE_ZCLIAS_CONTROL_TYPE_H__ */
+#endif /* __ZIGBEE_ZCL_IAS_ZONE_TYPE_H__ */
* limitations under the License.
*/
-#ifndef __ZIGBEE_ZCLIDENTIFY_CONTROL_TYPE_H__
-#define __ZIGBEE_ZCLIDENTIFY_CONTROL_TYPE_H__
+#ifndef __ZIGBEE_ZCL_IDENTIFY_TYPE_H__
+#define __ZIGBEE_ZCL_IDENTIFY_TYPE_H__
#include <zigbee_types.h>
/**
- * @brief Definition for Zclidentify control identify structure.
+ * @brief Definition for ZCL Identify identify structure.
* @since_tizen 3.0
*/
typedef struct {
short node_id; /**< Node ID */
char dest_ep; /**< Destination endpoint */
short identify_time; /**< Identify time */
-} ZigbeeZclidentifyControlIdentify_t;
+} ZigbeeZclIdentifyIdentify_t;
/**
- * @brief Definition for Zclidentify control identify structure.
+ * @brief Definition for ZCL Identify query structure.
* @since_tizen 3.0
*/
typedef struct {
short node_id; /**< Node ID */
char dest_ep; /**< Destination endpoint */
-} ZigbeeZclidentifyControlQuery_t;
+} ZigbeeZclIdentifyQuery_t;
-#endif /* __ZIGBEE_ZCLIDENTIFY_CONTROL_TYPE_H__ */
+#endif /* __ZIGBEE_ZCL_IDENTIFY_TYPE_H__ */
* limitations under the License.
*/
-#ifndef __ZIGBEE_LEVEL_CONTROL_TYPE_H__
-#define __ZIGBEE_LEVEL_CONTROL_TYPE_H__
+#ifndef __ZIGBEE_ZCL_LEVEL_CONTROL_TYPE_H__
+#define __ZIGBEE_ZCL_LEVEL_CONTROL_TYPE_H__
#include <zigbee_types.h>
/**
- * @brief Definition for level control move to level structure.
+ * @brief Definition for ZCL level control move to level structure.
* @since_tizen 3.0
*/
typedef struct {
char endpoint; /**< Endpoint */
char level; /**< Level */
short transition; /**< Transition time */
-} ZigbeeLevelControlMoveToLevel_t;
+} ZigbeeZclLevelControlMoveToLevel_t;
/**
- * @brief Definition for level control move structure.
+ * @brief Definition for ZCL level control move structure.
* @since_tizen 3.0
*/
typedef struct {
char endpoint; /**< Endpoint */
char move_mode; /**< Move mode */
char rate; /**< Rate of movement */
-} ZigbeeLevelControlMove_t;
+} ZigbeeZclLevelControlMove_t;
/**
- * @brief Definition for level control step structure.
+ * @brief Definition for ZCL level control step structure.
* @since_tizen 3.0
*/
typedef struct {
char step_mode; /**< Step mode */
char move_mode; /**< Move mode */
short transition_time; /**< Transition time */
-} ZigbeeLevelControlStep_t;
+} ZigbeeZclLevelControlStep_t;
/**
- * @brief Definition for level control move to level with on/off structure.
+ * @brief Definition for ZCL level control move to level with on/off structure.
* @since_tizen 3.0
*/
typedef struct {
char endpoint; /**< Endpoint */
char level; /**< Level */
short transition; /**< Transition time */
-} ZigbeeLevelControlMoveToLevelWithOnOff_t;
+} ZigbeeZclLevelControlMoveToLevelWithOnOff_t;
/**
- * @brief Definition for level control move with on/off structure.
+ * @brief Definition for ZCL level control move with on/off structure.
* @since_tizen 3.0
*/
typedef struct {
char endpoint; /**< Endpoint */
char move_mode; /**< Move mode */
char rate; /**< Rate of movement */
-} ZigbeeLevelControlMoveWithOnOff_t;
+} ZigbeeZclLevelControlMoveWithOnOff_t;
/**
- * @brief Definition for level control step with on/off structure.
+ * @brief Definition for ZCL level control step with on/off structure.
* @since_tizen 3.0
*/
typedef struct {
char step_mode; /**< Step mode */
char move_mode; /**< Move mode */
short transition_time; /**< Transition time */
-} ZigbeeLevelControlStepWithOnOff_t;
+} ZigbeeZclLevelControlStepWithOnOff_t;
/**
- * @brief Definition for level control stop structure.
+ * @brief Definition for ZCL level control stop structure.
* @since_tizen 3.0
*/
typedef struct {
short node_id; /**< Node ID */
char endpoint; /**< Endpoint */
-} ZigbeeLevelControlStop_t;
+} ZigbeeZclLevelControlStop_t;
-#endif /* __ZIGBEE_LEVEL_CONTROL_TYPE_H__ */
+#endif /* __ZIGBEE_ZCL_LEVEL_CONTROL_TYPE_H__ */
* limitations under the License.
*/
-#ifndef __ZIGBEE_ON_OFF_TYPE_H__
-#define __ZIGBEE_ON_OFF_TYPE_H__
+#ifndef __ZIGBEE_ZCL_ON_OFF_TYPE_H__
+#define __ZIGBEE_ZCL_ON_OFF_TYPE_H__
#include <zigbee_types.h>
/**
- * @brief Definition for on/off set on/off structure.
+ * @brief Definition for ZCL on/off set on/off structure.
* @since_tizen 3.0
*/
typedef struct {
short node_id; /**< Node ID */
char endpoint; /**< Endpoint */
char on_off_type; /**< ON/OFF type */
-} ZigbeeOnOffSetOnOff_t;
+} ZigbeeZclOnOffSetOnOff_t;
/**
- * @brief Definition for on/off get on/off state structure.
+ * @brief Definition for ZCL on/off get on/off state structure.
* @since_tizen 3.0
*/
typedef struct {
short node_id; /**< Node ID */
char endpoint; /**< Endpoint */
-} ZigbeeOnOffGetOnOffState_t;
+} ZigbeeZclOnOffGetOnOffState_t;
-#endif /* __ZIGBEE_ON_OFF_TYPE_H__ */
+#endif /* __ZIGBEE_ZCL_ON_OFF_TYPE_H__ */
#include <zigbee_types.h>
/**
- * @brief Definition for Zcl poll control check in response structure.
+ * @brief Definition for ZCL poll control check in response structure.
* @since_tizen 3.0
*/
typedef struct {
} ZigbeeZclPollControlCheckInResponse_t;
/**
- * @brief Definition for Zcl poll control fast poll stop structure.
+ * @brief Definition for ZCL poll control fast poll stop structure.
* @since_tizen 3.0
*/
typedef struct {
} ZigbeeZclPollControlFastPollStop_t;
/**
- * @brief Definition for Zcl poll control set long poll interval structure.
+ * @brief Definition for ZCL poll control set long poll interval structure.
* @since_tizen 3.0
*/
typedef struct {
} ZigbeeZclPollControlSetLongPollInterval_t;
/**
- * @brief Definition for Zcl poll control set short poll interval structure.
+ * @brief Definition for ZCL poll control set short poll interval structure.
* @since_tizen 3.0
*/
typedef struct {
#include <zigbee_types.h>
/**
- * @brief Definition for Zcl scene add scene structure.
+ * @brief Definition for ZCL scene add scene structure.
* @since_tizen 3.0
*/
typedef struct {
} ZigbeeZclSceneAddScene_t;
/**
- * @brief Definition for Zcl scene view scene structure.
+ * @brief Definition for ZCL scene view scene structure.
* @since_tizen 3.0
*/
typedef struct {
} ZigbeeZclSceneViewScene_t;
/**
- * @brief Definition for Zcl scene remove scene structure.
+ * @brief Definition for ZCL scene remove scene structure.
* @since_tizen 3.0
*/
typedef struct {
} ZigbeeZclSceneRemoveScene_t;
/**
- * @brief Definition for Zcl scene store scene structure.
+ * @brief Definition for ZCL scene store scene structure.
* @since_tizen 3.0
*/
typedef struct {
} ZigbeeZclSceneStoreScene_t;
/**
- * @brief Definition for Zcl scene recall scene structure.
+ * @brief Definition for ZCL scene recall scene structure.
* @since_tizen 3.0
*/
typedef struct {
} ZigbeeZclSceneRecallScene_t;
/**
- * @brief Definition for Zcl scene remove all scene structure.
+ * @brief Definition for ZCL scene remove all scene structure.
* @since_tizen 3.0
*/
typedef struct {
} ZigbeeZclSceneRemoveAllScene_t;
/**
- * @brief Definition for Zcl scene get scene membership structure.
+ * @brief Definition for ZCL scene get scene membership structure.
* @since_tizen 3.0
*/
typedef struct {
* limitations under the License.
*/
-#ifndef __ZIGBEE_THERMOSTAT_TYPE_H__
-#define __ZIGBEE_THERMOSTAT_TYPE_H__
+#ifndef __ZIGBEE_ZCL_THERMOSTAT_TYPE_H__
+#define __ZIGBEE_ZCL_THERMOSTAT_TYPE_H__
#include <zigbee_types.h>
/**
- * @brief Definition for thermostat get local temperature structure.
+ * @brief Definition for ZCL thermostat get local temperature structure.
* @since_tizen 3.0
*/
typedef struct {
char eui64[ZIGBEE_EUI64_SIZE]; /**< EUI64 (an IEEE address) */
char endpoint; /**< Endpoint */
-} ZigbeeThermostatGetLocalTemp_t;
+} ZigbeeZclThermostatGetLocalTemp_t;
/**
- * @brief Definition for thermostat get weekly schedule structure.
+ * @brief Definition for ZCL thermostat get weekly schedule structure.
* @since_tizen 3.0
*/
typedef struct {
char endpoint; /**< Endpoint */
char num_of_days; /**< Number of days */
char mode; /**< Mode */
-} ZigbeeThermostatGetWeeklySchedule_t;
+} ZigbeeZclThermostatGetWeeklySchedule_t;
/**
- * @brief Definition for thermostat set weekly schedule structure.
+ * @brief Definition for ZCL thermostat set weekly schedule structure.
* @since_tizen 3.0
*/
typedef struct {
char mode; /**< Mode */
char payload[ZIGBEE_THERMSTAT_PAYLOAD_MAX_LEN]; /**< Payload */
char payload_len; /**< Payload length */
-} ZigbeeThermostatSetWeeklySchedule_t;
+} ZigbeeZclThermostatSetWeeklySchedule_t;
/**
- * @brief Definition for thermostat clear weekly schedule structure.
+ * @brief Definition for ZCL thermostat clear weekly schedule structure.
* @since_tizen 3.0
*/
typedef struct {
char eui64[ZIGBEE_EUI64_SIZE]; /**< EUI64 (an IEEE address) */
char endpoint; /**< Endpoint */
-} ZigbeeThermostatClearWeeklySchedule_t;
+} ZigbeeZclThermostatClearWeeklySchedule_t;
/**
- * @brief Definition for thermostat setpoint raise lower structure.
+ * @brief Definition for ZCL thermostat setpoint raise lower structure.
* @since_tizen 3.0
*/
typedef struct {
char endpoint; /**< Endpoint */
char mode; /**< Mode */
char amount; /**< Amount */
-} ZigbeeThermostatSetpointRaiseLower_t;
+} ZigbeeZclThermostatSetpointRaiseLower_t;
-#endif /* __ZIGBEE_THERMOSTAT_TYPE_H__ */
+#endif /* __ZIGBEE_ZCL_THERMOSTAT_TYPE_H__ */
#include <zigbee_types.h>
/**
- * @brief Definition for Zdo bind bind request structure.
+ * @brief Definition for ZDO bind bind request structure.
* @since_tizen 3.0
*/
typedef struct {
} ZigbeeZdoBindBindReq_t;
/**
- * @brief Definition for Zdo bind unbind request structure.
+ * @brief Definition for ZDO bind unbind request structure.
* @since_tizen 3.0
*/
typedef struct {
* limitations under the License.
*/
-#ifndef __ZIGBEE_ZDODEV_CONTROL_TYPE_H__
-#define __ZIGBEE_ZDODEV_CONTROL_TYPE_H__
+#ifndef __ZIGBEE_ZDO_DEV_CONTROL_TYPE_H__
+#define __ZIGBEE_ZDO_DEV_CONTROL_TYPE_H__
#include <zigbee_types.h>
/**
- * @brief Definition for Zdodev control network address request structure.
+ * @brief Definition for ZDO Dev control network address request structure.
* @since_tizen 3.0
*/
typedef struct {
char eui64[ZIGBEE_EUI64_SIZE]; /**< EUI64 (an IEEE address) */
char request_type; /**< Request type */
char start_index; /**< Start index */
-} ZigbeeZdodevControlNwkAddrReq_t;
+} ZigbeeZdoDevControlNwkAddrReq_t;
/**
- * @brief Definition for Zdodev control matched descriptor request structure.
+ * @brief Definition for ZDO Dev control matched descriptor request structure.
* @since_tizen 3.0
*/
typedef struct {
char *in_cl; /**< In CL */
char num_out_cl; /**< Number of out CL */
char *out_cl; /**< Out CL */
-} ZigbeeZdodevControlMatchedDescriptorReq_t;
+} ZigbeeZdoDevControlMatchedDescriptorReq_t;
/**
- * @brief Definition for Zdodev control IEEE address request structure.
+ * @brief Definition for ZDO Dev control IEEE address request structure.
* @since_tizen 3.0
*/
typedef struct {
short node_id; /**< Node ID */
-} ZigbeeZdodevControlIeeeAddrReq_t;
+} ZigbeeZdoDevControlIeeeAddrReq_t;
/**
- * @brief Definition for Zdodev control active endpoint structure.
+ * @brief Definition for ZDO Dev control active endpoint structure.
* @since_tizen 3.0
*/
typedef struct {
short node_id; /**< Node ID */
-} ZigbeeZdodevControlActiveEpReq_t;
+} ZigbeeZdoDevControlActiveEpReq_t;
/**
- * @brief Definition for Zdodev control node descriptor request structure.
+ * @brief Definition for ZDO Dev control node descriptor request structure.
* @since_tizen 3.0
*/
typedef struct {
short node_id; /**< Node ID */
-} ZigbeeZdodevControlNodeDescriptorReq_t;
+} ZigbeeZdoDevControlNodeDescriptorReq_t;
/**
- * @brief Definition for Zdodev control power descriptor request structure.
+ * @brief Definition for ZDO Dev control power descriptor request structure.
* @since_tizen 3.0
*/
typedef struct {
short node_id; /**< Node ID */
-} ZigbeeZdodevControlPowerDescriptorReq_t;
+} ZigbeeZdoDevControlPowerDescriptorReq_t;
/**
- * @brief Definition for Zdodev control complex descriptor request structure.
+ * @brief Definition for ZDO Dev control complex descriptor request structure.
* @since_tizen 3.0
*/
typedef struct {
short node_id; /**< Node ID */
-} ZigbeeZdodevControlComplexDescriptorReq_t;
+} ZigbeeZdoDevControlComplexDescriptorReq_t;
/**
- * @brief Definition for Zdodev control user descriptor request structure.
+ * @brief Definition for ZDO Dev control user descriptor request structure.
* @since_tizen 3.0
*/
typedef struct {
short node_id; /**< Node ID */
-} ZigbeeZdodevControlUserDescriptorReq_t;
+} ZigbeeZdoDevControlUserDescriptorReq_t;
/**
- * @brief Definition for Zdodev control user descriptor set request structure.
+ * @brief Definition for ZDO Dev control user descriptor set request structure.
* @since_tizen 3.0
*/
typedef struct {
char user_descriptor_len; /**< User descriptor length */
char user_descriptor[ZIGBEE_ZDODEV_CONTROL_USER_DECRIPTOR_MAX_LEN];
/**< User descriptor */
-} ZigbeeZdodevControlUserDescriptorSetReq_t;
+} ZigbeeZdoDevControlUserDescriptorSetReq_t;
/**
- * @brief Definition for Zdodev control device announce structure.
+ * @brief Definition for ZDO Dev control device announce structure.
* @since_tizen 3.0
*/
typedef struct {
short node_id; /**< Node ID */
char mac_addr[ZIGBEE_EUI64_SIZE]; /**< MAC address */
char capability; /**< Capability */
-} ZigbeeZdodevControlDeviceAnnounce_t;
+} ZigbeeZdoDevControlDeviceAnnounce_t;
/**
- * @brief Definition for Zdodev control simple descriptor request structure.
+ * @brief Definition for ZDO Dev control simple descriptor request structure.
* @since_tizen 3.0
*/
typedef struct {
short node_id; /**< Node ID */
char endpoint; /**< Endpoint */
-} ZigbeeZdodevControlSimpleDescriptorReq_t;
+} ZigbeeZdoDevControlSimpleDescriptorReq_t;
/**
- * @brief Definition for Zdodev control management LQI request structure.
+ * @brief Definition for ZDO Dev control management LQI request structure.
* @since_tizen 3.0
*/
typedef struct {
short node_id; /**< Node ID */
char start_index; /**< Start index */
-} ZigbeeZdodevControlMgmtLqiReq_t;
+} ZigbeeZdoDevControlMgmtLqiReq_t;
/**
- * @brief Definition for Zdodev control management RTG request structure.
+ * @brief Definition for ZDO Dev control management RTG request structure.
* @since_tizen 3.0
*/
typedef struct {
short node_id; /**< Node ID */
char start_index; /**< Start index */
-} ZigbeeZdodevControlMgmtRtgReq_t;
+} ZigbeeZdoDevControlMgmtRtgReq_t;
/**
- * @brief Definition for Zdodev control management bind request structure.
+ * @brief Definition for ZDO Dev control management bind request structure.
* @since_tizen 3.0
*/
typedef struct {
short node_id; /**< Node ID */
char start_index; /**< Start index */
-} ZigbeeZdodevControlMgmtBindReq_t;
+} ZigbeeZdoDevControlMgmtBindReq_t;
/**
- * @brief Definition for Zdodev control management permit join request structure.
+ * @brief Definition for ZDO Dev control management permit join request structure.
* @since_tizen 3.0
*/
typedef struct {
short addr; /**< Address */
char duration; /**< Duration */
char tc_significance; /**< TC significance */
-} ZigbeeZdodevControlMgmtPermitJoinReq_t;
+} ZigbeeZdoDevControlMgmtPermitJoinReq_t;
/**
- * @brief Definition for Zdodev control network update request structure.
+ * @brief Definition for ZDO Dev control network update request structure.
* @since_tizen 3.0
*/
typedef struct {
char scan_duration; /**< Scan duration */
char scan_count; /**< Scan count */
char network_update_id; /**< Network update ID */
-} ZigbeeZdodevControlNwkUpdateReq_t;
+} ZigbeeZdoDevControlNwkUpdateReq_t;
/**
- * @brief Definition for Zdodev control network descriptor request structure.
+ * @brief Definition for ZDO Dev control network descriptor request structure.
* @since_tizen 3.0
*/
typedef struct {
char scan_duration; /**< Scan duration */
short scan_count; /**< Scan count */
char start_index; /**< Start index */
-} ZigbeeZdodevControlNwkDescriptorReq_t;
+} ZigbeeZdoDevControlNwkDescriptorReq_t;
-#endif /* __ZIGBEE_ZDODEV_CONTROL_TYPE_H__ */
+#endif /* __ZIGBEE_ZDO_DEV_CONTROL_TYPE_H__ */
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeAlarmGetAlarmCount_t req;
+ ZigbeeZclAlarmGetAlarmCount_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
GVariantIter *iter = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeAlarmGetAlarmCount_t));
+ memset(&req, 0x0, sizeof(ZigbeeZclAlarmGetAlarmCount_t));
/* Update request structure */
g_variant_get(eui64, "ay", &iter);
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_ALARM,
- ZBLIB_ALARM_OPS_GET_ALARM_COUNT,
+ ZBLIB_DRIVER_TYPE_ZCL_ALARM,
+ ZBLIB_ZCL_ALARM_OPS_GET_ALARM_COUNT,
&req, sizeof(req),
on_alarm_get_alarm_count_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeAlarmResetAlarm_t req;
+ ZigbeeZclAlarmResetAlarm_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeAlarmResetAlarm_t));
+ memset(&req, 0x0, sizeof(ZigbeeZclAlarmResetAlarm_t));
/* Update request structure */
req.node_id = node_id;
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_ALARM,
- ZBLIB_ALARM_OPS_RESET_ALARM,
+ ZBLIB_DRIVER_TYPE_ZCL_ALARM,
+ ZBLIB_ZCL_ALARM_OPS_RESET_ALARM,
&req, sizeof(req),
on_alarm_reset_alarm_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeAlarmResetAllAlarm_t req;
+ ZigbeeZclAlarmResetAllAlarm_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeAlarmResetAllAlarm_t));
+ memset(&req, 0x0, sizeof(ZigbeeZclAlarmResetAllAlarm_t));
/* Update request structure */
req.node_id = node_id;
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_ALARM,
- ZBLIB_ALARM_OPS_RESET_ALL_ALARM,
+ ZBLIB_DRIVER_TYPE_ZCL_ALARM,
+ ZBLIB_ZCL_ALARM_OPS_RESET_ALL_ALARM,
&req, sizeof(req),
on_alarm_reset_all_alarm_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeAlarmAlarm_t req;
+ ZigbeeZclAlarmAlarm_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
GVariantIter *iter = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeAlarmAlarm_t));
+ memset(&req, 0x0, sizeof(ZigbeeZclAlarmAlarm_t));
/* Update request structure */
g_variant_get(eui64, "ay", &iter);
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_ALARM,
- ZBLIB_ALARM_OPS_ALARM,
+ ZBLIB_DRIVER_TYPE_ZCL_ALARM,
+ ZBLIB_ZCL_ALARM_OPS_ALARM,
&req, sizeof(req),
on_alarm_alarm_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeAlarmResetAlarmLogs_t req;
+ ZigbeeZclAlarmResetAlarmLogs_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeAlarmResetAlarmLogs_t));
+ memset(&req, 0x0, sizeof(ZigbeeZclAlarmResetAlarmLogs_t));
/* Update request structure */
req.node_id = node_id;
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_ALARM,
- ZBLIB_ALARM_OPS_RESET_ALARM_LOG,
+ ZBLIB_DRIVER_TYPE_ZCL_ALARM,
+ ZBLIB_ZCL_ALARM_OPS_RESET_ALARM_LOG,
&req, sizeof(req),
on_alarm_reset_alarm_log_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeAlarmGetAlarm_t req;
+ ZigbeeZclAlarmGetAlarm_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeAlarmGetAlarm_t));
+ memset(&req, 0x0, sizeof(ZigbeeZclAlarmGetAlarm_t));
/* Update request structure */
req.node_id = node_id;
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_ALARM,
- ZBLIB_ALARM_OPS_GET_ALARM,
+ ZBLIB_DRIVER_TYPE_ZCL_ALARM,
+ ZBLIB_ZCL_ALARM_OPS_GET_ALARM,
&req, sizeof(req),
on_alarm_get_alarm_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeZclbasicControlResetFactoryDefault_t req;
+ ZigbeeZclBasicResetFactoryDefault_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeZclbasicControlResetFactoryDefault_t));
+ memset(&req, 0x0, sizeof(ZigbeeZclBasicResetFactoryDefault_t));
/* Update request structure */
req.node_id = node_id;
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_ZCLBASIC_CONTROL,
- ZBLIB_ZCLBASIC_CONTROL_OPS_RESET_FACTORY_DEFAULT,
+ ZBLIB_DRIVER_TYPE_ZCL_BASIC,
+ ZBLIB_ZCL_BASIC_OPS_RESET_FACTORY_DEFAULT,
&req, sizeof(req),
on_zclbasic_control_reset_factory_default_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeZclColorMoveToHue_t req;
+ ZigbeeZclColorControlMoveToHue_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeZclColorMoveToHue_t));
+ memset(&req, 0x0, sizeof(ZigbeeZclColorControlMoveToHue_t));
/* Update request structure */
req.node_id = node_id;
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_ZCL_COLOR,
- ZBLIB_ZCL_COLOR_OPS_MOVE_TO_HUE,
+ ZBLIB_DRIVER_TYPE_ZCL_COLOR_CONTROL,
+ ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_HUE,
&req, sizeof(req),
on_zcl_color_move_to_hue_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeZclColorMoveHue_t req;
+ ZigbeeZclColorControlMoveHue_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeZclColorMoveHue_t));
+ memset(&req, 0x0, sizeof(ZigbeeZclColorControlMoveHue_t));
/* Update request structure */
req.node_id = node_id;
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_ZCL_COLOR,
- ZBLIB_ZCL_COLOR_OPS_MOVE_HUE,
+ ZBLIB_DRIVER_TYPE_ZCL_COLOR_CONTROL,
+ ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_HUE,
&req, sizeof(req),
on_zcl_color_move_hue_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeZclColorStepHue_t req;
+ ZigbeeZclColorControlStepHue_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeZclColorStepHue_t));
+ memset(&req, 0x0, sizeof(ZigbeeZclColorControlStepHue_t));
/* Update request structure */
req.node_id = node_id;
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_ZCL_COLOR,
- ZBLIB_ZCL_COLOR_OPS_STEP_HUE,
+ ZBLIB_DRIVER_TYPE_ZCL_COLOR_CONTROL,
+ ZBLIB_ZCL_COLOR_CONTROL_OPS_STEP_HUE,
&req, sizeof(req),
on_zcl_color_step_hue_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeZclColorMoveToSaturation_t req;
+ ZigbeeZclColorControlMoveToSaturation_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeZclColorMoveToSaturation_t));
+ memset(&req, 0x0, sizeof(ZigbeeZclColorControlMoveToSaturation_t));
/* Update request structure */
req.node_id = node_id;
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_ZCL_COLOR,
- ZBLIB_ZCL_COLOR_OPS_MOVE_TO_STAURATION,
+ ZBLIB_DRIVER_TYPE_ZCL_COLOR_CONTROL,
+ ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_STAURATION,
&req, sizeof(req),
on_zcl_color_move_to_saturation_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeZclColorMoveSaturation_t req;
+ ZigbeeZclColorControlMoveSaturation_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeZclColorMoveSaturation_t));
+ memset(&req, 0x0, sizeof(ZigbeeZclColorControlMoveSaturation_t));
/* Update request structure */
req.node_id = node_id;
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_ZCL_COLOR,
- ZBLIB_ZCL_COLOR_OPS_MOVE_STAURATION,
+ ZBLIB_DRIVER_TYPE_ZCL_COLOR_CONTROL,
+ ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_STAURATION,
&req, sizeof(req),
on_zcl_color_move_saturation_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeZclColorStepSaturation_t req;
+ ZigbeeZclColorControlStepSaturation_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeZclColorStepSaturation_t));
+ memset(&req, 0x0, sizeof(ZigbeeZclColorControlStepSaturation_t));
/* Update request structure */
req.node_id = node_id;
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_ZCL_COLOR,
- ZBLIB_ZCL_COLOR_OPS_STEP_STAURATION,
+ ZBLIB_DRIVER_TYPE_ZCL_COLOR_CONTROL,
+ ZBLIB_ZCL_COLOR_CONTROL_OPS_STEP_STAURATION,
&req, sizeof(req),
on_zcl_color_step_saturation_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeZclColorMoveToHueAndSaturation_t req;
+ ZigbeeZclColorControlMoveToHueAndSaturation_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeZclColorMoveToHueAndSaturation_t));
+ memset(&req, 0x0, sizeof(ZigbeeZclColorControlMoveToHueAndSaturation_t));
/* Update request structure */
req.node_id = node_id;
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_ZCL_COLOR,
- ZBLIB_ZCL_COLOR_OPS_MOVE_TO_HUE_AND_SATURATION,
+ ZBLIB_DRIVER_TYPE_ZCL_COLOR_CONTROL,
+ ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_HUE_AND_SATURATION,
&req, sizeof(req),
on_zcl_color_move_to_hue_and_saturation_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeZclColorMoveToColor_t req;
+ ZigbeeZclColorControlMoveToColor_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeZclColorMoveToColor_t));
+ memset(&req, 0x0, sizeof(ZigbeeZclColorControlMoveToColor_t));
/* Update request structure */
req.node_id = node_id;
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_ZCL_COLOR,
- ZBLIB_ZCL_COLOR_OPS_MOVE_TO_COLOR,
+ ZBLIB_DRIVER_TYPE_ZCL_COLOR_CONTROL,
+ ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_COLOR,
&req, sizeof(req),
on_zcl_color_move_to_color_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeZclColorMoveColor_t req;
+ ZigbeeZclColorControlMoveColor_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeZclColorMoveColor_t));
+ memset(&req, 0x0, sizeof(ZigbeeZclColorControlMoveColor_t));
/* Update request structure */
req.node_id = node_id;
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_ZCL_COLOR,
- ZBLIB_ZCL_COLOR_OPS_MOVE_COLOR,
+ ZBLIB_DRIVER_TYPE_ZCL_COLOR_CONTROL,
+ ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_COLOR,
&req, sizeof(req),
on_zcl_color_move_color_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeZclColorStepColor_t req;
+ ZigbeeZclColorControlStepColor_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeZclColorStepColor_t));
+ memset(&req, 0x0, sizeof(ZigbeeZclColorControlStepColor_t));
/* Update request structure */
req.node_id = node_id;
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_ZCL_COLOR,
- ZBLIB_ZCL_COLOR_OPS_STEP_COLOR,
+ ZBLIB_DRIVER_TYPE_ZCL_COLOR_CONTROL,
+ ZBLIB_ZCL_COLOR_CONTROL_OPS_STEP_COLOR,
&req, sizeof(req),
on_zcl_color_step_color_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeZclColorMoveColorTemperature_t req;
+ ZigbeeZclColorControlMoveColorTemperature_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeZclColorMoveColorTemperature_t));
+ memset(&req, 0x0, sizeof(ZigbeeZclColorControlMoveColorTemperature_t));
/* Update request structure */
req.node_id = node_id;
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_ZCL_COLOR,
- ZBLIB_ZCL_COLOR_OPS_MOVE_COLOR_TEMPERATURE,
+ ZBLIB_DRIVER_TYPE_ZCL_COLOR_CONTROL,
+ ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_COLOR_TEMPERATURE,
&req, sizeof(req),
on_zcl_color_move_color_temperature_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeDoorLockSubscriberLockEvent_t req;
+ ZigbeeZclDoorLockSubscriberLockEvent_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
GVariantIter *iter = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeDoorLockSubscriberLockEvent_t));
+ memset(&req, 0x0, sizeof(ZigbeeZclDoorLockSubscriberLockEvent_t));
/* Update request structure */
g_variant_get(eui64, "ay", &iter);
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_DOOR_LOCK,
- ZBLIB_DOOR_LOCK_OPS_SUBSCRIBE_LOCK_EVENT,
+ ZBLIB_DRIVER_TYPE_ZCL_DOOR_LOCK,
+ ZBLIB_ZCL_DOOR_LOCK_OPS_SUBSCRIBE_LOCK_EVENT,
&req, sizeof(req),
on_door_lock_subscribe_lock_event_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeDoorLockSetDoorLockPin_t req;
+ ZigbeeZclDoorLockSetDoorLockPin_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
GVariantIter *iter = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeDoorLockSetDoorLockPin_t));
+ memset(&req, 0x0, sizeof(ZigbeeZclDoorLockSetDoorLockPin_t));
/* Update request structure */
req.uid = uid;
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_DOOR_LOCK,
- ZBLIB_DOOR_LOCK_OPS_SET_DOOR_LOCK_PIN,
+ ZBLIB_DRIVER_TYPE_ZCL_DOOR_LOCK,
+ ZBLIB_ZCL_DOOR_LOCK_OPS_SET_DOOR_LOCK_PIN,
&req, sizeof(req),
on_door_lock_set_door_lock_pin_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeDoorLockSetDoorLock_t req;
+ ZigbeeZclDoorLockSetDoorLock_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
GVariantIter *iter = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeDoorLockSetDoorLock_t));
+ memset(&req, 0x0, sizeof(ZigbeeZclDoorLockSetDoorLock_t));
/* Update request structure */
g_variant_get(eui64, "ay", &iter);
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_DOOR_LOCK,
- ZBLIB_DOOR_LOCK_OPS_SET_DOOR_LOCK,
+ ZBLIB_DRIVER_TYPE_ZCL_DOOR_LOCK,
+ ZBLIB_ZCL_DOOR_LOCK_OPS_SET_DOOR_LOCK,
&req, sizeof(req),
on_door_lock_set_door_lock_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeDoorLockGetDoorLock_t req;
+ ZigbeeZclDoorLockGetDoorLock_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
GVariantIter *iter = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeDoorLockGetDoorLock_t));
+ memset(&req, 0x0, sizeof(ZigbeeZclDoorLockGetDoorLock_t));
/* Update request structure */
g_variant_get(eui64, "ay", &iter);
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_DOOR_LOCK,
- ZBLIB_DOOR_LOCK_OPS_GET_LOCK_STATE,
+ ZBLIB_DRIVER_TYPE_ZCL_DOOR_LOCK,
+ ZBLIB_ZCL_DOOR_LOCK_OPS_GET_LOCK_STATE,
&req, sizeof(req),
on_door_lock_get_lock_state_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeFanControlSetFanMode_t req;
+ ZigbeeZclFanControlSetFanMode_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
GVariantIter *iter = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeFanControlSetFanMode_t));
+ memset(&req, 0x0, sizeof(ZigbeeZclFanControlSetFanMode_t));
/* Update request structure */
g_variant_get(eui64, "ay", &iter);
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_FAN_CONTROL,
- ZBLIB_FAN_CONTROL_OPS_SET_FAN_MODE,
+ ZBLIB_DRIVER_TYPE_ZCL_FAN_CONTROL,
+ ZBLIB_ZCL_FAN_CONTROL_OPS_SET_FAN_MODE,
&req, sizeof(req),
on_fan_control_set_fan_mode_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeFanControlGetFanMode_t req;
+ ZigbeeZclFanControlGetFanMode_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
GVariantIter *iter = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeFanControlGetFanMode_t));
+ memset(&req, 0x0, sizeof(ZigbeeZclFanControlGetFanMode_t));
/* Update request structure */
g_variant_get(eui64, "ay", &iter);
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_FAN_CONTROL,
- ZBLIB_FAN_CONTROL_OPS_GET_FAN_MODE,
+ ZBLIB_DRIVER_TYPE_ZCL_FAN_CONTROL,
+ ZBLIB_ZCL_FAN_CONTROL_OPS_GET_FAN_MODE,
&req, sizeof(req),
on_fan_control_get_fan_mode_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeFanControlSetFanModeSequence_t req;
+ ZigbeeZclFanControlSetFanModeSequence_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
GVariantIter *iter = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeFanControlSetFanModeSequence_t));
+ memset(&req, 0x0, sizeof(ZigbeeZclFanControlSetFanModeSequence_t));
/* Update request structure */
g_variant_get(eui64, "ay", &iter);
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_FAN_CONTROL,
- ZBLIB_FAN_CONTROL_OPS_SET_FAN_MODE_SEQUENCE,
+ ZBLIB_DRIVER_TYPE_ZCL_FAN_CONTROL,
+ ZBLIB_ZCL_FAN_CONTROL_OPS_SET_FAN_MODE_SEQUENCE,
&req, sizeof(req),
on_fan_control_set_fan_mode_sequence_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeFanControlGetFanModeSequence_t req;
+ ZigbeeZclFanControlGetFanModeSequence_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
GVariantIter *iter = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeFanControlGetFanModeSequence_t));
+ memset(&req, 0x0, sizeof(ZigbeeZclFanControlGetFanModeSequence_t));
/* Update request structure */
g_variant_get(eui64, "ay", &iter);
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_FAN_CONTROL,
- ZBLIB_FAN_CONTROL_OPS_GET_FAN_MODE_SEQUENCE,
+ ZBLIB_DRIVER_TYPE_ZCL_FAN_CONTROL,
+ ZBLIB_ZCL_FAN_CONTROL_OPS_GET_FAN_MODE_SEQUENCE,
&req, sizeof(req),
on_fan_control_get_fan_mode_sequence_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeZclglobalControlReadAttributesRequest_t req;
+ ZigbeeZclGlobalControlReadAttributesRequest_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
GVariantIter *iter = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeZclglobalControlReadAttributesRequest_t));
+ memset(&req, 0x0, sizeof(ZigbeeZclGlobalControlReadAttributesRequest_t));
/* Update request structure */
g_variant_get(attribute_id, "ay", &iter);
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_ZCLGLOBAL_CONTROL,
- ZBLIB_ZCLGLOBAL_CONTROL_OPS_READ_ATTRIBUTES_REQ,
+ ZBLIB_DRIVER_TYPE_ZCL_GLOBAL_CONTROL,
+ ZBLIB_ZCL_GLOBAL_CONTROL_OPS_READ_ATTRIBUTES_REQ,
&req, sizeof(req),
on_zclglobal_control_read_attributes_req_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeZclglobalControlWriteAttributesRequest_t req;
+ ZigbeeZclGlobalControlWriteAttributesRequest_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
GVariantIter *iter = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeZclglobalControlReadAttributesRequest_t));
+ memset(&req, 0x0, sizeof(ZigbeeZclGlobalControlReadAttributesRequest_t));
/* Update request structure */
g_variant_get(write_attribute, "ay", &iter);
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_ZCLGLOBAL_CONTROL,
- ZBLIB_ZCLGLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_REQ,
+ ZBLIB_DRIVER_TYPE_ZCL_GLOBAL_CONTROL,
+ ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_REQ,
&req, sizeof(req),
on_zclglobal_control_write_attributes_req_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeZclglobalControlWriteAttributesUndividedRequest_t req;
+ ZigbeeZclGlobalControlWriteAttributesUndividedRequest_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
GVariantIter *iter = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeZclglobalControlWriteAttributesUndividedRequest_t));
+ memset(&req, 0x0, sizeof(ZigbeeZclGlobalControlWriteAttributesUndividedRequest_t));
/* Update request structure */
g_variant_get(write_attribute, "ay", &iter);
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_ZCLGLOBAL_CONTROL,
- ZBLIB_ZCLGLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_UNDIVIDED_REQ,
+ ZBLIB_DRIVER_TYPE_ZCL_GLOBAL_CONTROL,
+ ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_UNDIVIDED_REQ,
&req, sizeof(req),
on_zclglobal_control_write_attributes_undivided_req_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeZclglobalControlWriteAttributesNoResponse_t req;
+ ZigbeeZclGlobalControlWriteAttributesNoResponse_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
GVariantIter *iter = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeZclglobalControlWriteAttributesNoResponse_t));
+ memset(&req, 0x0, sizeof(ZigbeeZclGlobalControlWriteAttributesNoResponse_t));
/* Update request structure */
g_variant_get(write_attribute, "ay", &iter);
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_ZCLGLOBAL_CONTROL,
- ZBLIB_ZCLGLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_NO_RESP,
+ ZBLIB_DRIVER_TYPE_ZCL_GLOBAL_CONTROL,
+ ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_NO_RESP,
&req, sizeof(req),
on_zclglobal_control_write_attributes_no_resp_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeZclglobalControlWriteAttributesStructed_t req;
+ ZigbeeZclGlobalControlWriteAttributesStructed_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
GVariantIter *iter = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeZclglobalControlWriteAttributesStructed_t));
+ memset(&req, 0x0, sizeof(ZigbeeZclGlobalControlWriteAttributesStructed_t));
/* Update request structure */
g_variant_get(write_attribute, "ay", &iter);
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_ZCLGLOBAL_CONTROL,
- ZBLIB_ZCLGLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_STRUCTURED,
+ ZBLIB_DRIVER_TYPE_ZCL_GLOBAL_CONTROL,
+ ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_STRUCTURED,
&req, sizeof(req),
on_zclglobal_control_write_attributes_structured_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeZclglobalControlReadAttributesStructed_t req;
+ ZigbeeZclGlobalControlReadAttributesStructed_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
GVariantIter *iter = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeZclglobalControlReadAttributesStructed_t));
+ memset(&req, 0x0, sizeof(ZigbeeZclGlobalControlReadAttributesStructed_t));
/* Update request structure */
g_variant_get(read_attribute, "ay", &iter);
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_ZCLGLOBAL_CONTROL,
- ZBLIB_ZCLGLOBAL_CONTROL_OPS_READ_ATTRIBUTES_STRUCTURED,
+ ZBLIB_DRIVER_TYPE_ZCL_GLOBAL_CONTROL,
+ ZBLIB_ZCL_GLOBAL_CONTROL_OPS_READ_ATTRIBUTES_STRUCTURED,
&req, sizeof(req),
on_zclglobal_control_read_attributes_structured_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeZclglobalControlConfigureReportingReq_t req;
+ ZigbeeZclGlobalControlConfigureReportingReq_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
GVariantIter *iter = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeZclglobalControlConfigureReportingReq_t));
+ memset(&req, 0x0, sizeof(ZigbeeZclGlobalControlConfigureReportingReq_t));
/* Update request structure */
g_variant_get(read_attribute, "ay", &iter);
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_ZCLGLOBAL_CONTROL,
- ZBLIB_ZCLGLOBAL_CONTROL_OPS_CONFIGURE_REPORTING_REQ,
+ ZBLIB_DRIVER_TYPE_ZCL_GLOBAL_CONTROL,
+ ZBLIB_ZCL_GLOBAL_CONTROL_OPS_CONFIGURE_REPORTING_REQ,
&req, sizeof(req),
on_zclglobal_control_configure_reporting_req_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeZclglobalControlReadConfigureReporting_t req;
+ ZigbeeZclGlobalControlReadConfigureReporting_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
GVariantIter *iter = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeZclglobalControlReadConfigureReporting_t));
+ memset(&req, 0x0, sizeof(ZigbeeZclGlobalControlReadConfigureReporting_t));
/* Update request structure */
g_variant_get(read_attribute, "ay", &iter);
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_ZCLGLOBAL_CONTROL,
- ZBLIB_ZCLGLOBAL_CONTROL_OPS_READ_CONFIGURE_REPORTING,
+ ZBLIB_DRIVER_TYPE_ZCL_GLOBAL_CONTROL,
+ ZBLIB_ZCL_GLOBAL_CONTROL_OPS_READ_CONFIGURE_REPORTING,
&req, sizeof(req),
on_zclglobal_control_read_configure_reporting_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeZclglobalControlDiscoverAttributes_t req;
+ ZigbeeZclGlobalControlDiscoverAttributes_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeZclglobalControlDiscoverAttributes_t));
+ memset(&req, 0x0, sizeof(ZigbeeZclGlobalControlDiscoverAttributes_t));
/* Update request structure */
req.node_id = node_id;
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_ZCLGLOBAL_CONTROL,
- ZBLIB_ZCLGLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES,
+ ZBLIB_DRIVER_TYPE_ZCL_GLOBAL_CONTROL,
+ ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES,
&req, sizeof(req),
on_zclglobal_control_discover_attributes_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeZclglobalControlDiscoverAttributesExtended_t req;
+ ZigbeeZclGlobalControlDiscoverAttributesExtended_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeZclglobalControlDiscoverAttributesExtended_t));
+ memset(&req, 0x0, sizeof(ZigbeeZclGlobalControlDiscoverAttributesExtended_t));
/* Update request structure */
req.node_id = node_id;
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_ZCLGLOBAL_CONTROL,
- ZBLIB_ZCLGLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES_EXTENDED,
+ ZBLIB_DRIVER_TYPE_ZCL_GLOBAL_CONTROL,
+ ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES_EXTENDED,
&req, sizeof(req),
on_zclglobal_control_discover_attributes_extended_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeZclglobalControlDiscoverCommandsReceived_t req;
+ ZigbeeZclGlobalControlDiscoverCommandsReceived_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeZclglobalControlDiscoverCommandsReceived_t));
+ memset(&req, 0x0, sizeof(ZigbeeZclGlobalControlDiscoverCommandsReceived_t));
/* Update request structure */
req.node_id = node_id;
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_ZCLGLOBAL_CONTROL,
- ZBLIB_ZCLGLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_RECEIVED,
+ ZBLIB_DRIVER_TYPE_ZCL_GLOBAL_CONTROL,
+ ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_RECEIVED,
&req, sizeof(req),
on_zclglobal_control_discover_commands_received_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeZclglobalControlDiscoverCommandsGenerated_t req;
+ ZigbeeZclGlobalControlDiscoverCommandsGenerated_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeZclglobalControlDiscoverCommandsGenerated_t));
+ memset(&req, 0x0, sizeof(ZigbeeZclGlobalControlDiscoverCommandsGenerated_t));
/* Update request structure */
req.node_id = node_id;
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_ZCLGLOBAL_CONTROL,
- ZBLIB_ZCLGLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_GENERATED,
+ ZBLIB_DRIVER_TYPE_ZCL_GLOBAL_CONTROL,
+ ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_GENERATED,
&req, sizeof(req),
on_zclglobal_control_discover_commands_generated_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeZcliasControlEnrolResponse_t req;
+ ZigbeeZclIasZoneEnrollResponse_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeZcliasControlEnrolResponse_t));
+ memset(&req, 0x0, sizeof(ZigbeeZclIasZoneEnrollResponse_t));
/* Update request structure */
req.node_id = node_id;
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_ZCLIAS_CONTROL,
- ZBLIB_ZCLIAS_CONTROL_OPS_ENROLL_RESPONSE,
+ ZBLIB_DRIVER_TYPE_ZCL_IAS_ZONE,
+ ZBLIB_ZCL_IAS_ZONE_OPS_ENROLL_RESPONSE,
&req, sizeof(req),
on_zclias_control_enroll_response_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeZclidentifyControlIdentify_t req;
+ ZigbeeZclIdentifyIdentify_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeZclidentifyControlIdentify_t));
+ memset(&req, 0x0, sizeof(ZigbeeZclIdentifyIdentify_t));
/* Update request structure */
req.node_id = node_id;
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_ZCLIDENTIFY_CONTROL,
- ZBLIB_ZCLIDENTIFY_CONTROL_OPS_IDENTIFY,
+ ZBLIB_DRIVER_TYPE_ZCL_IDENTIFY,
+ ZBLIB_ZCL_IDENTIFY_OPS_IDENTIFY,
&req, sizeof(req),
on_zclidentify_control_identify_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeZclidentifyControlQuery_t req;
+ ZigbeeZclIdentifyQuery_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeZclidentifyControlQuery_t));
+ memset(&req, 0x0, sizeof(ZigbeeZclIdentifyQuery_t));
/* Update request structure */
req.node_id = node_id;
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_ZCLIDENTIFY_CONTROL,
- ZBLIB_ZCLIDENTIFY_CONTROL_OPS_QUERY,
+ ZBLIB_DRIVER_TYPE_ZCL_IDENTIFY,
+ ZBLIB_ZCL_IDENTIFY_OPS_QUERY,
&req, sizeof(req),
on_zclidentify_control_query_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeLevelControlMoveToLevel_t req;
+ ZigbeeZclLevelControlMoveToLevel_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeLevelControlMoveToLevel_t));
+ memset(&req, 0x0, sizeof(ZigbeeZclLevelControlMoveToLevel_t));
/* Update request structure */
req.node_id = node_id;
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_LEVEL_CONTROL,
- ZBLIB_LEVEL_CONTROL_OPS_MOVE_TO_LEVEL,
+ ZBLIB_DRIVER_TYPE_ZCL_LEVEL_CONTROL,
+ ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE_TO_LEVEL,
&req, sizeof(req),
on_level_control_move_to_level_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeLevelControlMove_t req;
+ ZigbeeZclLevelControlMove_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeLevelControlMove_t));
+ memset(&req, 0x0, sizeof(ZigbeeZclLevelControlMove_t));
/* Update request structure */
req.node_id = node_id;
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_LEVEL_CONTROL,
- ZBLIB_LEVEL_CONTROL_OPS_MOVE,
+ ZBLIB_DRIVER_TYPE_ZCL_LEVEL_CONTROL,
+ ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE,
&req, sizeof(req),
on_level_control_move_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeLevelControlStep_t req;
+ ZigbeeZclLevelControlStep_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeLevelControlStep_t));
+ memset(&req, 0x0, sizeof(ZigbeeZclLevelControlStep_t));
/* Update request structure */
req.node_id = node_id;
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_LEVEL_CONTROL,
- ZBLIB_LEVEL_CONTROL_OPS_STEP,
+ ZBLIB_DRIVER_TYPE_ZCL_LEVEL_CONTROL,
+ ZBLIB_ZCL_LEVEL_CONTROL_OPS_STEP,
&req, sizeof(req),
on_level_control_step_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeLevelControlMoveToLevelWithOnOff_t req;
+ ZigbeeZclLevelControlMoveToLevelWithOnOff_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeLevelControlMoveToLevelWithOnOff_t));
+ memset(&req, 0x0, sizeof(ZigbeeZclLevelControlMoveToLevelWithOnOff_t));
/* Update request structure */
req.node_id = node_id;
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_LEVEL_CONTROL,
- ZBLIB_LEVEL_CONTROL_OPS_MOVE_TO_LEVEL_WITH_ON_OFF,
+ ZBLIB_DRIVER_TYPE_ZCL_LEVEL_CONTROL,
+ ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE_TO_LEVEL_WITH_ON_OFF,
&req, sizeof(req),
on_level_control_move_to_level_with_on_off_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeLevelControlMoveWithOnOff_t req;
+ ZigbeeZclLevelControlMoveWithOnOff_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeLevelControlMoveWithOnOff_t));
+ memset(&req, 0x0, sizeof(ZigbeeZclLevelControlMoveWithOnOff_t));
/* Update request structure */
req.node_id = node_id;
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_LEVEL_CONTROL,
- ZBLIB_LEVEL_CONTROL_OPS_MOVE_WITH_ON_OFF,
+ ZBLIB_DRIVER_TYPE_ZCL_LEVEL_CONTROL,
+ ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE_WITH_ON_OFF,
&req, sizeof(req),
on_level_control_move_with_on_off_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeLevelControlStepWithOnOff_t req;
+ ZigbeeZclLevelControlStepWithOnOff_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeLevelControlStepWithOnOff_t));
+ memset(&req, 0x0, sizeof(ZigbeeZclLevelControlStepWithOnOff_t));
/* Update request structure */
req.node_id = node_id;
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_LEVEL_CONTROL,
- ZBLIB_LEVEL_CONTROL_OPS_STEP_WITH_ON_OFF,
+ ZBLIB_DRIVER_TYPE_ZCL_LEVEL_CONTROL,
+ ZBLIB_ZCL_LEVEL_CONTROL_OPS_STEP_WITH_ON_OFF,
&req, sizeof(req),
on_level_control_step_with_on_off_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeLevelControlStop_t req;
+ ZigbeeZclLevelControlStop_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeLevelControlStop_t));
+ memset(&req, 0x0, sizeof(ZigbeeZclLevelControlStop_t));
/* Update request structure */
req.node_id = node_id;
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_LEVEL_CONTROL,
- ZBLIB_LEVEL_CONTROL_OPS_STOP,
+ ZBLIB_DRIVER_TYPE_ZCL_LEVEL_CONTROL,
+ ZBLIB_ZCL_LEVEL_CONTROL_OPS_STOP,
&req, sizeof(req),
on_level_control_stop_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeOnOffSetOnOff_t req;
+ ZigbeeZclOnOffSetOnOff_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeOnOffSetOnOff_t));
+ memset(&req, 0x0, sizeof(ZigbeeZclOnOffSetOnOff_t));
/* Update request structure */
req.node_id = node_id;
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_ON_OFF,
- ZBLIB_ON_OFF_OPS_SET_ON_OFF,
+ ZBLIB_DRIVER_TYPE_ZCL_ON_OFF,
+ ZBLIB_ZCL_ON_OFF_OPS_SET_ON_OFF,
&req, sizeof(req),
on_on_off_set_on_off_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeOnOffGetOnOffState_t req;
+ ZigbeeZclOnOffGetOnOffState_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeOnOffGetOnOffState_t));
+ memset(&req, 0x0, sizeof(ZigbeeZclOnOffGetOnOffState_t));
/* Update request structure */
req.node_id = node_id;
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_ON_OFF,
- ZBLIB_ON_OFF_OPS_GET_ON_OFF_STATE,
+ ZBLIB_DRIVER_TYPE_ZCL_ON_OFF,
+ ZBLIB_ZCL_ON_OFF_OPS_GET_ON_OFF_STATE,
&req, sizeof(req),
on_on_off_get_on_off_state_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeThermostatGetLocalTemp_t req;
+ ZigbeeZclThermostatGetLocalTemp_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
GVariantIter *iter = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeThermostatGetLocalTemp_t));
+ memset(&req, 0x0, sizeof(ZigbeeZclThermostatGetLocalTemp_t));
/* Update request structure */
g_variant_get(eui64, "ay", &iter);
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_THERMOSTAT,
- ZBLIB_THERMOSTAT_OPS_GET_LOCAL_TEMP,
+ ZBLIB_DRIVER_TYPE_ZCL_THERMOSTAT,
+ ZBLIB_ZCL_THERMOSTAT_OPS_GET_LOCAL_TEMP,
&req, sizeof(req),
on_thermostat_get_local_temp_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeThermostatGetWeeklySchedule_t req;
+ ZigbeeZclThermostatGetWeeklySchedule_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
GVariantIter *iter = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeThermostatGetWeeklySchedule_t));
+ memset(&req, 0x0, sizeof(ZigbeeZclThermostatGetWeeklySchedule_t));
/* Update request structure */
g_variant_get(eui64, "ay", &iter);
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_THERMOSTAT,
- ZBLIB_THERMOSTAT_OPS_GET_WEEKLY_SCHEDULE,
+ ZBLIB_DRIVER_TYPE_ZCL_THERMOSTAT,
+ ZBLIB_ZCL_THERMOSTAT_OPS_GET_WEEKLY_SCHEDULE,
&req, sizeof(req),
on_thermostat_get_weekly_schedule_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeThermostatSetWeeklySchedule_t req;
+ ZigbeeZclThermostatSetWeeklySchedule_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
GVariantIter *iter = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeThermostatSetWeeklySchedule_t));
+ memset(&req, 0x0, sizeof(ZigbeeZclThermostatSetWeeklySchedule_t));
/* Update request structure */
g_variant_get(eui64, "ay", &iter);
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_THERMOSTAT,
- ZBLIB_THERMOSTAT_OPS_SET_WEEKLY_SCHEDULE,
+ ZBLIB_DRIVER_TYPE_ZCL_THERMOSTAT,
+ ZBLIB_ZCL_THERMOSTAT_OPS_SET_WEEKLY_SCHEDULE,
&req, sizeof(req),
on_thermostat_set_weekly_schedule_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeThermostatClearWeeklySchedule_t req;
+ ZigbeeZclThermostatClearWeeklySchedule_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
GVariantIter *iter = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeThermostatClearWeeklySchedule_t));
+ memset(&req, 0x0, sizeof(ZigbeeZclThermostatClearWeeklySchedule_t));
/* Update request structure */
g_variant_get(eui64, "ay", &iter);
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_THERMOSTAT,
- ZBLIB_THERMOSTAT_OPS_CLEAR_WEEKLY_SCHEDULE,
+ ZBLIB_DRIVER_TYPE_ZCL_THERMOSTAT,
+ ZBLIB_ZCL_THERMOSTAT_OPS_CLEAR_WEEKLY_SCHEDULE,
&req, sizeof(req),
on_thermostat_clear_weekly_schedule_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeThermostatSetpointRaiseLower_t req;
+ ZigbeeZclThermostatSetpointRaiseLower_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeThermostatSetpointRaiseLower_t));
+ memset(&req, 0x0, sizeof(ZigbeeZclThermostatSetpointRaiseLower_t));
/* Update request structure */
req.node_id = node_id;
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_THERMOSTAT,
- ZBLIB_THERMOSTAT_OPS_SETPOINT_RAISE_LOWER,
+ ZBLIB_DRIVER_TYPE_ZCL_THERMOSTAT,
+ ZBLIB_ZCL_THERMOSTAT_OPS_SETPOINT_RAISE_LOWER,
&req, sizeof(req),
on_thermostat_setpoint_raise_lower_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeZdodevControlNwkAddrReq_t req;
+ ZigbeeZdoDevControlNwkAddrReq_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
GVariantIter *iter = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeZdodevControlNwkAddrReq_t));
+ memset(&req, 0x0, sizeof(ZigbeeZdoDevControlNwkAddrReq_t));
/* Update request structure */
g_variant_get(eui64, "ay", &iter);
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_ZDODEV_CONTROL,
- ZBLIB_ZDODEV_CONTROL_OPS_NWK_ADDR_REQ,
+ ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
+ ZBLIB_ZDO_DEV_CONTROL_OPS_NWK_ADDR_REQ,
&req, sizeof(req),
on_zdodev_control_nwk_addr_req_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeZdodevControlMatchedDescriptorReq_t req;
+ ZigbeeZdoDevControlMatchedDescriptorReq_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
GVariantIter *iter = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeZdodevControlMatchedDescriptorReq_t));
+ memset(&req, 0x0, sizeof(ZigbeeZdoDevControlMatchedDescriptorReq_t));
/* Update request structure */
req.node_id = node_id;
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_ZDODEV_CONTROL,
- ZBLIB_ZDODEV_CONTROL_OPS_MATCHED_DESCRIPTOR_REQ,
+ ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
+ ZBLIB_ZDO_DEV_CONTROL_OPS_MATCHED_DESCRIPTOR_REQ,
&req, sizeof(req),
on_zdodev_control_matched_descriptor_req_resp, resp_cb_data);
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeZdodevControlIeeeAddrReq_t req;
+ ZigbeeZdoDevControlIeeeAddrReq_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeZdodevControlIeeeAddrReq_t));
+ memset(&req, 0x0, sizeof(ZigbeeZdoDevControlIeeeAddrReq_t));
/* Update request structure */
req.node_id = node_id;
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_ZDODEV_CONTROL,
- ZBLIB_ZDODEV_CONTROL_OPS_IEEE_ADDR_REQ,
+ ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
+ ZBLIB_ZDO_DEV_CONTROL_OPS_IEEE_ADDR_REQ,
&req, sizeof(req),
on_zdodev_control_ieee_addr_req_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeZdodevControlActiveEpReq_t req;
+ ZigbeeZdoDevControlActiveEpReq_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeZdodevControlActiveEpReq_t));
+ memset(&req, 0x0, sizeof(ZigbeeZdoDevControlActiveEpReq_t));
/* Update request structure */
req.node_id = node_id;
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_ZDODEV_CONTROL,
- ZBLIB_ZDODEV_CONTROL_OPS_ACTIVE_EP_REQ,
+ ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
+ ZBLIB_ZDO_DEV_CONTROL_OPS_ACTIVE_EP_REQ,
&req, sizeof(req),
on_zdodev_control_active_ep_req_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeZdodevControlNodeDescriptorReq_t req;
+ ZigbeeZdoDevControlNodeDescriptorReq_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeZdodevControlNodeDescriptorReq_t));
+ memset(&req, 0x0, sizeof(ZigbeeZdoDevControlNodeDescriptorReq_t));
/* Update request structure */
req.node_id = node_id;
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_ZDODEV_CONTROL,
- ZBLIB_ZDODEV_CONTROL_OPS_NODE_DESC_REQ,
+ ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
+ ZBLIB_ZDO_DEV_CONTROL_OPS_NODE_DESC_REQ,
&req, sizeof(req),
on_zdodev_control_node_desc_req_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeZdodevControlPowerDescriptorReq_t req;
+ ZigbeeZdoDevControlPowerDescriptorReq_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeZdodevControlPowerDescriptorReq_t));
+ memset(&req, 0x0, sizeof(ZigbeeZdoDevControlPowerDescriptorReq_t));
/* Update request structure */
req.node_id = node_id;
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_ZDODEV_CONTROL,
- ZBLIB_ZDODEV_CONTROL_OPS_POWER_DESC_REQ,
+ ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
+ ZBLIB_ZDO_DEV_CONTROL_OPS_POWER_DESC_REQ,
&req, sizeof(req),
on_zdodev_control_power_desc_req_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeZdodevControlComplexDescriptorReq_t req;
+ ZigbeeZdoDevControlComplexDescriptorReq_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeZdodevControlComplexDescriptorReq_t));
+ memset(&req, 0x0, sizeof(ZigbeeZdoDevControlComplexDescriptorReq_t));
/* Update request structure */
req.node_id = node_id;
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_ZDODEV_CONTROL,
- ZBLIB_ZDODEV_CONTROL_OPS_COMPLEX_DESC_REQ,
+ ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
+ ZBLIB_ZDO_DEV_CONTROL_OPS_COMPLEX_DESC_REQ,
&req, sizeof(req),
on_zdodev_control_complex_desc_req_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeZdodevControlUserDescriptorReq_t req;
+ ZigbeeZdoDevControlUserDescriptorReq_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeZdodevControlUserDescriptorReq_t));
+ memset(&req, 0x0, sizeof(ZigbeeZdoDevControlUserDescriptorReq_t));
/* Update request structure */
req.node_id = node_id;
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_ZDODEV_CONTROL,
- ZBLIB_ZDODEV_CONTROL_OPS_USER_DESC_REQ,
+ ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
+ ZBLIB_ZDO_DEV_CONTROL_OPS_USER_DESC_REQ,
&req, sizeof(req),
on_zdodev_control_user_desc_req_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeZdodevControlUserDescriptorSetReq_t req;
+ ZigbeeZdoDevControlUserDescriptorSetReq_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
GVariantIter *iter = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeZdodevControlUserDescriptorSetReq_t));
+ memset(&req, 0x0, sizeof(ZigbeeZdoDevControlUserDescriptorSetReq_t));
/* Update request structure */
req.node_id = node_id;
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_ZDODEV_CONTROL,
- ZBLIB_ZDODEV_CONTROL_OPS_USER_DESC_SET_REQ,
+ ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
+ ZBLIB_ZDO_DEV_CONTROL_OPS_USER_DESC_SET_REQ,
&req, sizeof(req),
on_zdodev_control_user_desc_set_req_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeZdodevControlDeviceAnnounce_t req;
+ ZigbeeZdoDevControlDeviceAnnounce_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
GVariantIter *iter = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeZdodevControlDeviceAnnounce_t));
+ memset(&req, 0x0, sizeof(ZigbeeZdoDevControlDeviceAnnounce_t));
/* Update request structure */
req.node_id = node_id;
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_ZDODEV_CONTROL,
- ZBLIB_ZDODEV_CONTROL_OPS_DEVICE_ANNOUNCE,
+ ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
+ ZBLIB_ZDO_DEV_CONTROL_OPS_DEVICE_ANNOUNCE,
&req, sizeof(req),
on_zdodev_control_device_announce_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeZdodevControlSimpleDescriptorReq_t req;
+ ZigbeeZdoDevControlSimpleDescriptorReq_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeZdodevControlSimpleDescriptorReq_t));
+ memset(&req, 0x0, sizeof(ZigbeeZdoDevControlSimpleDescriptorReq_t));
/* Update request structure */
req.node_id = node_id;
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_ZDODEV_CONTROL,
- ZBLIB_ZDODEV_CONTROL_OPS_SIMPLE_DESC_REQ,
+ ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
+ ZBLIB_ZDO_DEV_CONTROL_OPS_SIMPLE_DESC_REQ,
&req, sizeof(req),
on_zdodev_control_simple_desc_req_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeZdodevControlMgmtLqiReq_t req;
+ ZigbeeZdoDevControlMgmtLqiReq_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeZdodevControlMgmtLqiReq_t));
+ memset(&req, 0x0, sizeof(ZigbeeZdoDevControlMgmtLqiReq_t));
/* Update request structure */
req.node_id = node_id;
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_ZDODEV_CONTROL,
- ZBLIB_ZDODEV_CONTROL_OPS_MGMT_LQI_REQ,
+ ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
+ ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_LQI_REQ,
&req, sizeof(req),
on_zdodev_control_mgmt_lqi_req_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeZdodevControlMgmtRtgReq_t req;
+ ZigbeeZdoDevControlMgmtRtgReq_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeZdodevControlMgmtRtgReq_t));
+ memset(&req, 0x0, sizeof(ZigbeeZdoDevControlMgmtRtgReq_t));
/* Update request structure */
req.node_id = node_id;
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_ZDODEV_CONTROL,
- ZBLIB_ZDODEV_CONTROL_OPS_MGMT_RTG_REQ,
+ ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
+ ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_RTG_REQ,
&req, sizeof(req),
on_zdodev_control_mgmt_rtg_req_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeZdodevControlMgmtBindReq_t req;
+ ZigbeeZdoDevControlMgmtBindReq_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeZdodevControlMgmtBindReq_t));
+ memset(&req, 0x0, sizeof(ZigbeeZdoDevControlMgmtBindReq_t));
/* Update request structure */
req.node_id = node_id;
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_ZDODEV_CONTROL,
- ZBLIB_ZDODEV_CONTROL_OPS_MGMT_BIND_REQ,
+ ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
+ ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_BIND_REQ,
&req, sizeof(req),
on_zdodev_control_mgmt_bind_req_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeZdodevControlMgmtPermitJoinReq_t req;
+ ZigbeeZdoDevControlMgmtPermitJoinReq_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeZdodevControlMgmtPermitJoinReq_t));
+ memset(&req, 0x0, sizeof(ZigbeeZdoDevControlMgmtPermitJoinReq_t));
/* Update request structure */
req.addr = addr16;
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_ZDODEV_CONTROL,
- ZBLIB_ZDODEV_CONTROL_OPS_MGMT_PERMIT_JOIN_REQ,
+ ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
+ ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_PERMIT_JOIN_REQ,
&req, sizeof(req),
on_zdodev_control_mgmt_permit_join_req_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeZdodevControlNwkUpdateReq_t req;
+ ZigbeeZdoDevControlNwkUpdateReq_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeZdodevControlNwkUpdateReq_t));
+ memset(&req, 0x0, sizeof(ZigbeeZdoDevControlNwkUpdateReq_t));
/* Update request structure */
req.node_id = node_id;
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_ZDODEV_CONTROL,
- ZBLIB_ZDODEV_CONTROL_OPS_NWK_UPDATE_REQ,
+ ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
+ ZBLIB_ZDO_DEV_CONTROL_OPS_NWK_UPDATE_REQ,
&req, sizeof(req),
on_zdodev_control_nwk_update_req_resp, resp_cb_data);
if (FALSE == ret) {
gpointer user_data)
{
ZigBeeServiceInterface *service_interface = (ZigBeeServiceInterface *)user_data;
- ZigbeeZdodevControlNwkDescriptorReq_t req;
+ ZigbeeZdoDevControlNwkDescriptorReq_t req;
ZigbeeServiceInterfaceRespCbData_t *resp_cb_data = NULL;
gboolean ret;
- memset(&req, 0x0, sizeof(ZigbeeZdodevControlNwkDescriptorReq_t));
+ memset(&req, 0x0, sizeof(ZigbeeZdoDevControlNwkDescriptorReq_t));
/* Update request structure */
req.node_id = node_id;
/* Dispatch request */
ret = zigbee_service_dbus_interface_dispatch_request(service_interface,
- ZBLIB_DRIVER_TYPE_ZDODEV_CONTROL,
- ZBLIB_ZDODEV_CONTROL_OPS_NWK_DISC_REQ,
+ ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL,
+ ZBLIB_ZDO_DEV_CONTROL_OPS_NWK_DISC_REQ,
&req, sizeof(req),
on_zdodev_control_nwk_disc_req_resp, resp_cb_data);
if (FALSE == ret) {
#include <zblib_log.h>
#include <zblib_common.h>
-#include <zigbee_alarm_type.h>
+#include <zigbee_service_type.h>
#include <zigbee_custom_type.h>
-#include <zigbee_door_lock_type.h>
-#include <zigbee_fan_control_type.h>
-#include <zigbee_level_control_type.h>
#include <zigbee_mfglib_control_type.h>
-#include <zigbee_on_off_type.h>
-#include <zigbee_service_type.h>
-#include <zigbee_thermostat_type.h>
-#include <zigbee_zclbasic_control_type.h>
-#include <zigbee_zclglobal_control_type.h>
-#include <zigbee_zclias_control_type.h>
-#include <zigbee_zclidentify_control_type.h>
-#include <zigbee_zcl_color_type.h>
+#include <zigbee_zdo_dev_control_type.h>
+#include <zigbee_zdo_bind_type.h>
+#include <zigbee_zcl_global_control_type.h>
+#include <zigbee_zcl_alarm_type.h>
+#include <zigbee_zcl_basic_type.h>
+#include <zigbee_zcl_color_control_type.h>
+#include <zigbee_zcl_door_lock_type.h>
+#include <zigbee_zcl_fan_control_type.h>
#include <zigbee_zcl_group_type.h>
+#include <zigbee_zcl_ias_zone_type.h>
+#include <zigbee_zcl_identify_type.h>
+#include <zigbee_zcl_level_control_type.h>
+#include <zigbee_zcl_on_off_type.h>
#include <zigbee_zcl_poll_control_type.h>
#include <zigbee_zcl_scene_type.h>
-#include <zigbee_zdodev_control_type.h>
-#include <zigbee_zdo_bind_type.h>
+#include <zigbee_zcl_thermostat_type.h>
#define NOT_USED(var) ((var) = (var))
/**< ZigBee driver types */
typedef enum {
ZBLIB_DRIVER_TYPE_NONE, /**< None */
- ZBLIB_DRIVER_TYPE_ALARM, /**< Alarm */
+ ZBLIB_DRIVER_TYPE_SERVICE, /**< Service */
+ ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL, /**< ZDO Dev control */
+ ZBLIB_DRIVER_TYPE_ZDO_BIND, /**< ZDO bind */
+ ZBLIB_DRIVER_TYPE_ZCL_GLOBAL_CONTROL, /**< ZCL Global control */
+ ZBLIB_DRIVER_TYPE_ZCL_ALARM, /**< ZCL Alarm */
+ ZBLIB_DRIVER_TYPE_ZCL_BASIC, /**< ZCL Basic control */
+ ZBLIB_DRIVER_TYPE_ZCL_COLOR_CONTROL, /**< ZCL color */
+ ZBLIB_DRIVER_TYPE_ZCL_DOOR_LOCK, /**< ZCL Door lock */
+ ZBLIB_DRIVER_TYPE_ZCL_FAN_CONTROL, /**< ZCL Fan control */
+ ZBLIB_DRIVER_TYPE_ZCL_GROUP, /**< ZCL group */
+ ZBLIB_DRIVER_TYPE_ZCL_IAS_ZONE, /**< ZCL IAS zone */
+ ZBLIB_DRIVER_TYPE_ZCL_IDENTIFY, /**< ZCL Identify */
+ ZBLIB_DRIVER_TYPE_ZCL_LEVEL_CONTROL, /**< ZCL Level control */
+ ZBLIB_DRIVER_TYPE_ZCL_ON_OFF, /**< ZCL On Off */
+ ZBLIB_DRIVER_TYPE_ZCL_POLL_CONTROL, /**< ZCL poll control */
+ ZBLIB_DRIVER_TYPE_ZCL_SCENE, /**< ZCL scene */
+ ZBLIB_DRIVER_TYPE_ZCL_THERMOSTAT, /**< ZCL Thermostat */
ZBLIB_DRIVER_TYPE_CUSTOM, /**< Custom */
- ZBLIB_DRIVER_TYPE_DOOR_LOCK, /**< Door lock */
- ZBLIB_DRIVER_TYPE_FAN_CONTROL, /**< Fan control */
- ZBLIB_DRIVER_TYPE_LEVEL_CONTROL, /**< Level control */
ZBLIB_DRIVER_TYPE_MFGLIB_CONTROL, /**< Mfglib control */
- ZBLIB_DRIVER_TYPE_ON_OFF, /**< On Off */
- ZBLIB_DRIVER_TYPE_SERVICE, /**< Service */
- ZBLIB_DRIVER_TYPE_THERMOSTAT, /**< Thermostat */
- ZBLIB_DRIVER_TYPE_ZCLBASIC_CONTROL, /**< Zclbasic control */
- ZBLIB_DRIVER_TYPE_ZCLGLOBAL_CONTROL, /**< Zclglobal control */
- ZBLIB_DRIVER_TYPE_ZCLIAS_CONTROL, /**< Zclias control */
- ZBLIB_DRIVER_TYPE_ZCLIDENTIFY_CONTROL, /**< Zclidentify control */
- ZBLIB_DRIVER_TYPE_ZCL_COLOR, /**< Zcl color */
- ZBLIB_DRIVER_TYPE_ZCL_GROUP, /**< Zcl group */
- ZBLIB_DRIVER_TYPE_ZCL_POLL_CONTROL, /**< Zcl poll control */
- ZBLIB_DRIVER_TYPE_ZCL_SCENE, /**< Zcl scene */
- ZBLIB_DRIVER_TYPE_ZDODEV_CONTROL, /**< Zdodev control */
- ZBLIB_DRIVER_TYPE_ZDO_BIND, /**< Zdo bind */
+
} ZblibDriverType_e;
#endif /* __ZIGBEE_LIB_H__ */
#ifndef __ZIGBEE_LIB_DRIVER_ZCL_ALARM_H__
#define __ZIGBEE_LIB_DRIVER_ZCL_ALARM_H__
-/**< ZigBee 'alarm' driver operations */
+/**< ZigBee 'ZCL alarm' driver operations */
typedef struct {
gboolean (*get_alarm_count)(ZigBeeDriver *driver, guint request_id);
gboolean (*reset_alarm)(ZigBeeDriver *driver, guint request_id);
gboolean (*get_alarm)(ZigBeeDriver *driver, guint request_id);
} ZblibDriverZclAlarmOps_t;
-/**< ZigBee 'alarm' ops IDs */
+/**< ZigBee 'ZCL alarm' ops IDs */
typedef enum {
- ZBLIB_ALARM_OPS_GET_ALARM_COUNT = 1, /**< Get alarm count */
- ZBLIB_ALARM_OPS_RESET_ALARM, /**< Reset alarm */
- ZBLIB_ALARM_OPS_RESET_ALL_ALARM, /**< Reset all alarm */
- ZBLIB_ALARM_OPS_ALARM, /**< Alarm */
- ZBLIB_ALARM_OPS_RESET_ALARM_LOG, /**< Reset alarm log */
- ZBLIB_ALARM_OPS_GET_ALARM, /**< Get alarm */
-} ZblibAlarmOps_e;
+ ZBLIB_ZCL_ALARM_OPS_GET_ALARM_COUNT = 1, /**< Get alarm count */
+ ZBLIB_ZCL_ALARM_OPS_RESET_ALARM, /**< Reset alarm */
+ ZBLIB_ZCL_ALARM_OPS_RESET_ALL_ALARM, /**< Reset all alarm */
+ ZBLIB_ZCL_ALARM_OPS_ALARM, /**< Alarm */
+ ZBLIB_ZCL_ALARM_OPS_RESET_ALARM_LOG, /**< Reset alarm log */
+ ZBLIB_ZCL_ALARM_OPS_GET_ALARM, /**< Get alarm */
+} ZblibZclAlarmOps_e;
/* ZigBee 'alarm' driver APIs */
ZigBeeDriver *zblib_driver_zcl_alarm_new(ZigBeePlugin *plugin,
#ifndef __ZIGBEE_LIB_DRIVER_ZCL_BASIC_H__
#define __ZIGBEE_LIB_DRIVER_ZCL_BASIC_H__
-/**< ZigBee 'Zclbasic control' driver operations */
+/**< ZigBee 'ZCL Basic' driver operations */
typedef struct {
gboolean (*reset_factory_default)(ZigBeeDriver *driver, guint request_id);
-} ZblibDriverZclbasicControlOps_t;
+} ZblibDriverZclBasicOps_t;
-/**< ZigBee 'Zclbasic control' ops IDs */
+/**< ZigBee 'ZCL Basic' ops IDs */
typedef enum {
- ZBLIB_ZCLBASIC_CONTROL_OPS_RESET_FACTORY_DEFAULT = 1, /**< Reset factory default */
-} ZblibZclbasicControlOps_e;
+ ZBLIB_ZCL_BASIC_OPS_RESET_FACTORY_DEFAULT = 1, /**< Reset factory default */
+} ZblibZclBasicOps_e;
-/* ZigBee 'Zclbasic control' driver APIs */
+/* ZigBee 'ZCL Basic' driver APIs */
ZigBeeDriver *zblib_driver_zcl_basic_new(ZigBeePlugin *plugin,
const gchar *driver_name,
- ZblibDriverZclbasicControlOps_t *ops);
+ ZblibDriverZclBasicOps_t *ops);
void zblib_driver_zcl_basic_free(ZigBeeDriver *driver);
#endif /* __ZIGBEE_LIB_DRIVER_ZCL_BASIC_H__ */
#ifndef __ZIGBEE_LIB_DRIVER_ZCL_COLOR_CONTROL_H__
#define __ZIGBEE_LIB_DRIVER_ZCL_COLOR_CONTROL_H__
-/**< ZigBee 'Zcl color' driver operations */
+/**< ZigBee 'ZCL color control' driver operations */
typedef struct {
gboolean (*move_to_hue)(ZigBeeDriver *driver, guint request_id);
gboolean (*move_hue)(ZigBeeDriver *driver, guint request_id);
gboolean (*move_color)(ZigBeeDriver *driver, guint request_id);
gboolean (*step_color)(ZigBeeDriver *driver, guint request_id);
gboolean (*move_color_temperature)(ZigBeeDriver *driver, guint request_id);
-} ZblibDriverZclColorOps_t;
+} ZblibDriverZclColorControlOps_t;
-/**< ZigBee 'Zcl color' ops IDs */
+/**< ZigBee 'ZCL color control' ops IDs */
typedef enum {
- ZBLIB_ZCL_COLOR_OPS_MOVE_TO_HUE = 1, /**< Move to hue */
- ZBLIB_ZCL_COLOR_OPS_MOVE_HUE, /**< Move hue */
- ZBLIB_ZCL_COLOR_OPS_STEP_HUE, /**< Step hue */
- ZBLIB_ZCL_COLOR_OPS_MOVE_TO_STAURATION, /**< Move to saturation */
- ZBLIB_ZCL_COLOR_OPS_MOVE_STAURATION, /**< Move saturation */
- ZBLIB_ZCL_COLOR_OPS_STEP_STAURATION, /**< Step saturation */
- ZBLIB_ZCL_COLOR_OPS_MOVE_TO_HUE_AND_SATURATION, /**< Move to hue and saturation */
- ZBLIB_ZCL_COLOR_OPS_MOVE_TO_COLOR, /**< Move to color */
- ZBLIB_ZCL_COLOR_OPS_MOVE_COLOR, /**< Move color */
- ZBLIB_ZCL_COLOR_OPS_STEP_COLOR, /**< Step color */
- ZBLIB_ZCL_COLOR_OPS_MOVE_COLOR_TEMPERATURE, /**< Move color temperature */
-} ZblibZclColorOps_e;
+ ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_HUE = 1, /**< Move to hue */
+ ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_HUE, /**< Move hue */
+ ZBLIB_ZCL_COLOR_CONTROL_OPS_STEP_HUE, /**< Step hue */
+ ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_STAURATION, /**< Move to saturation */
+ ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_STAURATION, /**< Move saturation */
+ ZBLIB_ZCL_COLOR_CONTROL_OPS_STEP_STAURATION, /**< Step saturation */
+ ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_HUE_AND_SATURATION, /**< Move to hue and saturation */
+ ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_COLOR, /**< Move to color */
+ ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_COLOR, /**< Move color */
+ ZBLIB_ZCL_COLOR_CONTROL_OPS_STEP_COLOR, /**< Step color */
+ ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_COLOR_TEMPERATURE, /**< Move color temperature */
+} ZblibZclColorControlOps_e;
/* ZigBee 'Zcl color' driver APIs */
ZigBeeDriver *zblib_driver_zcl_color_control_new(ZigBeePlugin *plugin,
const gchar *driver_name,
- ZblibDriverZclColorOps_t *ops);
+ ZblibDriverZclColorControlOps_t *ops);
void zblib_driver_zcl_color_control_free(ZigBeeDriver *driver);
#endif /* __ZIGBEE_LIB_DRIVER_ZCL_COLOR_CONTROL_H__ */
#ifndef __ZIGBEE_LIB_DRIVER_ZCL_DOOR_LOCK_H__
#define __ZIGBEE_LIB_DRIVER_ZCL_DOOR_LOCK_H__
-/**< ZigBee 'door lock' driver operations */
+/**< ZigBee 'ZCL door lock' driver operations */
typedef struct {
gboolean (*subscribe_lock_event)(ZigBeeDriver *driver, guint request_id);
gboolean (*set_door_lock_pin)(ZigBeeDriver *driver, guint request_id);
gboolean (*get_lock_state)(ZigBeeDriver *driver, guint request_id);
} ZblibDriverZclDoorLockOps_t;
-/**< ZigBee 'door lock' ops IDs */
+/**< ZigBee 'ZCL door lock' ops IDs */
typedef enum {
- ZBLIB_DOOR_LOCK_OPS_SUBSCRIBE_LOCK_EVENT = 1, /**< Subscribe lock event */
- ZBLIB_DOOR_LOCK_OPS_SET_DOOR_LOCK_PIN, /**< Set door lock pin */
- ZBLIB_DOOR_LOCK_OPS_SET_DOOR_LOCK, /**< Set door lock */
- ZBLIB_DOOR_LOCK_OPS_GET_LOCK_STATE, /**< Get lock state */
+ ZBLIB_ZCL_DOOR_LOCK_OPS_SUBSCRIBE_LOCK_EVENT = 1, /**< Subscribe lock event */
+ ZBLIB_ZCL_DOOR_LOCK_OPS_SET_DOOR_LOCK_PIN, /**< Set door lock pin */
+ ZBLIB_ZCL_DOOR_LOCK_OPS_SET_DOOR_LOCK, /**< Set door lock */
+ ZBLIB_ZCL_DOOR_LOCK_OPS_GET_LOCK_STATE, /**< Get lock state */
} ZblibZclDoorLockOps_e;
-/* ZigBee 'door lock' driver APIs */
+/* ZigBee 'ZCL door lock' driver APIs */
ZigBeeDriver *zblib_driver_zcl_door_lock_new(ZigBeePlugin *plugin,
const gchar *driver_name,
ZblibDriverZclDoorLockOps_t *ops);
* limitations under the License.
*/
-#ifndef __ZIGBEE_LIB_DRIVER_FAN_CONTROL_H__
-#define __ZIGBEE_LIB_DRIVER_FAN_CONTROL_H__
+#ifndef __ZIGBEE_LIB_DRIVER_ZCL_FAN_CONTROL_H__
+#define __ZIGBEE_LIB_DRIVER_ZCL_FAN_CONTROL_H__
-/**< ZigBee 'fan control' driver operations */
+/**< ZigBee 'ZCL fan control' driver operations */
typedef struct {
gboolean (*set_fan_mode)(ZigBeeDriver *driver, guint request_id);
gboolean (*get_fan_mode)(ZigBeeDriver *driver, guint request_id);
gboolean (*set_fan_mode_sequence)(ZigBeeDriver *driver, guint request_id);
gboolean (*get_fan_mode_sequence)(ZigBeeDriver *driver, guint request_id);
-} ZblibDriverFanControlOps_t;
+} ZblibDriverZclFanControlOps_t;
-/**< ZigBee 'fan control' ops IDs */
+/**< ZigBee 'ZCL fan control' ops IDs */
typedef enum {
- ZBLIB_FAN_CONTROL_OPS_SET_FAN_MODE = 1, /**< Set fan mode */
- ZBLIB_FAN_CONTROL_OPS_GET_FAN_MODE, /**< Get fan mode */
- ZBLIB_FAN_CONTROL_OPS_SET_FAN_MODE_SEQUENCE, /**< Set fan mode sequence */
- ZBLIB_FAN_CONTROL_OPS_GET_FAN_MODE_SEQUENCE, /**< Get fan mode sequence */
-} ZblibFanControlOps_e;
+ ZBLIB_ZCL_FAN_CONTROL_OPS_SET_FAN_MODE = 1, /**< Set fan mode */
+ ZBLIB_ZCL_FAN_CONTROL_OPS_GET_FAN_MODE, /**< Get fan mode */
+ ZBLIB_ZCL_FAN_CONTROL_OPS_SET_FAN_MODE_SEQUENCE, /**< Set fan mode sequence */
+ ZBLIB_ZCL_FAN_CONTROL_OPS_GET_FAN_MODE_SEQUENCE, /**< Get fan mode sequence */
+} ZblibZclFanControlOps_e;
-/* ZigBee 'fan control' driver APIs */
+/* ZigBee 'ZCL fan control' driver APIs */
ZigBeeDriver *zblib_driver_zcl_fan_control_new(ZigBeePlugin *plugin,
const gchar *driver_name,
- ZblibDriverFanControlOps_t *ops);
+ ZblibDriverZclFanControlOps_t *ops);
void zblib_driver_zcl_fan_control_free(ZigBeeDriver *driver);
-#endif /* __ZIGBEE_LIB_DRIVER_FAN_CONTROL_H__ */
+#endif /* __ZIGBEE_LIB_DRIVER_ZCL_FAN_CONTROL_H__ */
* limitations under the License.
*/
-#ifndef __ZIGBEE_LIB_DRIVER_ZCLGLOBAL_CONTROL_H__
-#define __ZIGBEE_LIB_DRIVER_ZCLGLOBAL_CONTROL_H__
+#ifndef __ZIGBEE_LIB_DRIVER_ZCL_GLOBAL_CONTROL_H__
+#define __ZIGBEE_LIB_DRIVER_ZCL_GLOBAL_CONTROL_H__
-/**< ZigBee 'Zclglobal control' driver operations */
+/**< ZigBee 'ZCL global control' driver operations */
typedef struct {
gboolean (*read_attributes_req)(ZigBeeDriver *driver, guint request_id);
gboolean (*write_attributes_req)(ZigBeeDriver *driver, guint request_id);
gboolean (*discover_attributes_extended)(ZigBeeDriver *driver, guint request_id);
gboolean (*discover_commands_received)(ZigBeeDriver *driver, guint request_id);
gboolean (*discover_commands_generated)(ZigBeeDriver *driver, guint request_id);
-} ZblibDriverZclglobalControlOps_t;
+} ZblibDriverZclGlobalControlOps_t;
-/**< ZigBee 'Zclglobal control' ops IDs */
+/**< ZigBee 'ZCL global control' ops IDs */
typedef enum {
- ZBLIB_ZCLGLOBAL_CONTROL_OPS_READ_ATTRIBUTES_REQ = 1, /**< Read attributes req */
- ZBLIB_ZCLGLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_REQ, /**< Write attributes req */
- ZBLIB_ZCLGLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_UNDIVIDED_REQ, /**< Write attributes undivided req */
- ZBLIB_ZCLGLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_NO_RESP, /**< Write attributes no resp */
- ZBLIB_ZCLGLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_STRUCTURED, /**< Write attributes structured */
- ZBLIB_ZCLGLOBAL_CONTROL_OPS_READ_ATTRIBUTES_STRUCTURED, /**< Read attributes structured */
- ZBLIB_ZCLGLOBAL_CONTROL_OPS_CONFIGURE_REPORTING_REQ, /**< Configure reporting req */
- ZBLIB_ZCLGLOBAL_CONTROL_OPS_READ_CONFIGURE_REPORTING, /**< Read configure reporting */
- ZBLIB_ZCLGLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES, /**< Discover attributes */
- ZBLIB_ZCLGLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES_EXTENDED, /**< Discover attributes extended */
- ZBLIB_ZCLGLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_RECEIVED, /**< Discover commands received */
- ZBLIB_ZCLGLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_GENERATED, /**< Discover commands generated */
-} ZblibZclglobalControlOps_e;
+ ZBLIB_ZCL_GLOBAL_CONTROL_OPS_READ_ATTRIBUTES_REQ = 1, /**< Read attributes req */
+ ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_REQ, /**< Write attributes req */
+ ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_UNDIVIDED_REQ, /**< Write attributes undivided req */
+ ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_NO_RESP, /**< Write attributes no resp */
+ ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_STRUCTURED, /**< Write attributes structured */
+ ZBLIB_ZCL_GLOBAL_CONTROL_OPS_READ_ATTRIBUTES_STRUCTURED, /**< Read attributes structured */
+ ZBLIB_ZCL_GLOBAL_CONTROL_OPS_CONFIGURE_REPORTING_REQ, /**< Configure reporting req */
+ ZBLIB_ZCL_GLOBAL_CONTROL_OPS_READ_CONFIGURE_REPORTING, /**< Read configure reporting */
+ ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES, /**< Discover attributes */
+ ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES_EXTENDED, /**< Discover attributes extended */
+ ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_RECEIVED, /**< Discover commands received */
+ ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_GENERATED, /**< Discover commands generated */
+} ZblibZclGlobalControlOps_e;
-/* ZigBee 'Zclglobal control' driver APIs */
+/* ZigBee 'ZCL global control' driver APIs */
ZigBeeDriver *zblib_driver_zcl_global_control_new(ZigBeePlugin *plugin,
const gchar *driver_name,
- ZblibDriverZclglobalControlOps_t *ops);
+ ZblibDriverZclGlobalControlOps_t *ops);
void zblib_driver_zcl_global_control_free(ZigBeeDriver *driver);
-#endif /* __ZIGBEE_LIB_DRIVER_ZCLGLOBAL_CONTROL_H__ */
+#endif /* __ZIGBEE_LIB_DRIVER_ZCL_GLOBAL_CONTROL_H__ */
#ifndef __ZIGBEE_LIB_DRIVER_ZCL_GROUP_H__
#define __ZIGBEE_LIB_DRIVER_ZCL_GROUP_H__
-/**< ZigBee 'Zcl group' driver operations */
+/**< ZigBee 'ZCL Group' driver operations */
typedef struct {
gboolean (*add_group)(ZigBeeDriver *driver, guint request_id);
gboolean (*view_group)(ZigBeeDriver *driver, guint request_id);
gboolean (*add_group_if_identifying)(ZigBeeDriver *driver, guint request_id);
} ZblibDriverZclGroupOps_t;
-/**< ZigBee 'Zcl group' ops IDs */
+/**< ZigBee 'ZCL Group' ops IDs */
typedef enum {
ZBLIB_ZCL_GROUP_OPS_ADD_GROUP = 1, /**< Move add group */
ZBLIB_ZCL_GROUP_OPS_VIEW_GROUP, /**< View group */
* limitations under the License.
*/
-#ifndef __ZIGBEE_LIB_DRIVER_ZCLIAS_CONTROL_H__
-#define __ZIGBEE_LIB_DRIVER_ZCLIAS_CONTROL_H__
+#ifndef __ZIGBEE_LIB_DRIVER_ZCL_IAS_ZONE_H__
+#define __ZIGBEE_LIB_DRIVER_ZCL_IAS_ZONE_H__
-/**< ZigBee 'Zclias control' driver operations */
+/**< ZigBee 'ZCL IAS zone' driver operations */
typedef struct {
gboolean (*enroll_response)(ZigBeeDriver *driver, guint request_id);
-} ZblibDriverZcliasZoneOps_t;
+} ZblibDriverZclIasZoneOps_t;
-/**< ZigBee 'Zclias control' ops IDs */
+/**< ZigBee 'ZCL IAS zone' ops IDs */
typedef enum {
- ZBLIB_ZCLIAS_CONTROL_OPS_ENROLL_RESPONSE = 1, /**< Enroll response */
-} ZblibZcliasZoneOps_e;
+ ZBLIB_ZCL_IAS_ZONE_OPS_ENROLL_RESPONSE = 1, /**< Enroll response */
+} ZblibZclIasZoneOps_e;
-/* ZigBee 'Zclias control' driver APIs */
+/* ZigBee 'ZCL IAS zone' driver APIs */
ZigBeeDriver *zblib_driver_zcl_ias_zone_new(ZigBeePlugin *plugin,
const gchar *driver_name,
- ZblibDriverZcliasZoneOps_t *ops);
+ ZblibDriverZclIasZoneOps_t *ops);
void zblib_driver_zcl_ias_zone_free(ZigBeeDriver *driver);
-#endif /* __ZIGBEE_LIB_DRIVER_ZCLIAS_CONTROL_H__ */
+#endif /* __ZIGBEE_LIB_DRIVER_ZCL_IAS_ZONE_H__ */
* limitations under the License.
*/
-#ifndef __ZIGBEE_LIB_DRIVER_ZCLIDENTIFY_CONTROL_H__
-#define __ZIGBEE_LIB_DRIVER_ZCLIDENTIFY_CONTROL_H__
+#ifndef __ZIGBEE_LIB_DRIVER_ZCL_IDENTIFY_H__
+#define __ZIGBEE_LIB_DRIVER_ZCL_IDENTIFY_H__
-/**< ZigBee 'Zclidentify control' driver operations */
+/**< ZigBee 'ZCL Identify' driver operations */
typedef struct {
gboolean (*identify)(ZigBeeDriver *driver, guint request_id);
gboolean (*query)(ZigBeeDriver *driver, guint request_id);
-} ZblibDriverZclidentifyOps_t;
+} ZblibDriverZclIdentifyOps_t;
-/**< ZigBee 'Zclidentify control' ops IDs */
+/**< ZigBee 'ZCL Identify' ops IDs */
typedef enum {
- ZBLIB_ZCLIDENTIFY_CONTROL_OPS_IDENTIFY = 1, /**< Identify */
- ZBLIB_ZCLIDENTIFY_CONTROL_OPS_QUERY, /**< Query */
-} ZblibZclidentifyOps_e;
+ ZBLIB_ZCL_IDENTIFY_OPS_IDENTIFY = 1, /**< Identify */
+ ZBLIB_ZCL_IDENTIFY_OPS_QUERY, /**< Query */
+} ZblibZclIdentifyOps_e;
-/* ZigBee 'Zclidentify control' driver APIs */
+/* ZigBee 'ZCL Identify' driver APIs */
ZigBeeDriver *zblib_driver_zcl_identify_new(ZigBeePlugin *plugin,
const gchar *driver_name,
- ZblibDriverZclidentifyOps_t *ops);
+ ZblibDriverZclIdentifyOps_t *ops);
void zblib_driver_zcl_identify_free(ZigBeeDriver *driver);
-#endif /* __ZIGBEE_LIB_DRIVER_ZCLIDENTIFY_CONTROL_H__ */
+#endif /* __ZIGBEE_LIB_DRIVER_ZCL_IDENTIFY_H__ */
* limitations under the License.
*/
-#ifndef __ZIGBEE_LIB_DRIVER_LEVEL_CONTROL_H__
-#define __ZIGBEE_LIB_DRIVER_LEVEL_CONTROL_H__
+#ifndef __ZIGBEE_LIB_DRIVER_ZCL_LEVEL_CONTROL_H__
+#define __ZIGBEE_LIB_DRIVER_ZCL_LEVEL_CONTROL_H__
-/**< ZigBee 'level control' driver operations */
+/**< ZigBee 'ZCL level control' driver operations */
typedef struct {
gboolean (*move_to_level)(ZigBeeDriver *driver, guint request_id);
gboolean (*move)(ZigBeeDriver *driver, guint request_id);
gboolean (*move_with_on_off)(ZigBeeDriver *driver, guint request_id);
gboolean (*step_with_on_off)(ZigBeeDriver *driver, guint request_id);
gboolean (*stop)(ZigBeeDriver *driver, guint request_id);
-} ZblibDriverLevelControlOps_t;
+} ZblibDriverZclLevelControlOps_t;
-/**< ZigBee 'level control' ops IDs */
+/**< ZigBee 'ZCL level control' ops IDs */
typedef enum {
- ZBLIB_LEVEL_CONTROL_OPS_MOVE_TO_LEVEL = 1, /**< Move to level */
- ZBLIB_LEVEL_CONTROL_OPS_MOVE, /**< Move */
- ZBLIB_LEVEL_CONTROL_OPS_STEP, /**< Step */
- ZBLIB_LEVEL_CONTROL_OPS_MOVE_TO_LEVEL_WITH_ON_OFF, /**< Move to level with on off */
- ZBLIB_LEVEL_CONTROL_OPS_MOVE_WITH_ON_OFF, /**< Move with on off */
- ZBLIB_LEVEL_CONTROL_OPS_STEP_WITH_ON_OFF, /**< Step with on off */
- ZBLIB_LEVEL_CONTROL_OPS_STOP, /**< Stop */
-} ZblibLevelControlOps_e;
+ ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE_TO_LEVEL = 1, /**< Move to level */
+ ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE, /**< Move */
+ ZBLIB_ZCL_LEVEL_CONTROL_OPS_STEP, /**< Step */
+ ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE_TO_LEVEL_WITH_ON_OFF, /**< Move to level with on off */
+ ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE_WITH_ON_OFF, /**< Move with on off */
+ ZBLIB_ZCL_LEVEL_CONTROL_OPS_STEP_WITH_ON_OFF, /**< Step with on off */
+ ZBLIB_ZCL_LEVEL_CONTROL_OPS_STOP, /**< Stop */
+} ZblibZclLevelControlOps_e;
-/* ZigBee 'level control' driver APIs */
+/* ZigBee 'ZCL level control' driver APIs */
ZigBeeDriver *zblib_driver_zcl_level_control_new(ZigBeePlugin *plugin,
const gchar *driver_name,
- ZblibDriverLevelControlOps_t *ops);
+ ZblibDriverZclLevelControlOps_t *ops);
void zblib_driver_zcl_level_control_free(ZigBeeDriver *driver);
-#endif /* __ZIGBEE_LIB_DRIVER_LEVEL_CONTROL_H__ */
+#endif /* __ZIGBEE_LIB_DRIVER_ZCL_LEVEL_CONTROL_H__ */
* limitations under the License.
*/
-#ifndef __ZIGBEE_LIB_DRIVER_ON_OFF_H__
-#define __ZIGBEE_LIB_DRIVER_ON_OFF_H__
+#ifndef __ZIGBEE_LIB_DRIVER_ZCL_ON_OFF_H__
+#define __ZIGBEE_LIB_DRIVER_ZCL_ON_OFF_H__
-/**< ZigBee 'on off' driver operations */
+/**< ZigBee 'ZCL on off' driver operations */
typedef struct {
gboolean (*set_on_off)(ZigBeeDriver *driver, guint request_id);
gboolean (*get_on_off_state)(ZigBeeDriver *driver, guint request_id);
} ZblibDriverZclOnOffOps_t;
-/**< ZigBee 'on off' ops IDs */
+/**< ZigBee 'ZCL on off' ops IDs */
typedef enum {
- ZBLIB_ON_OFF_OPS_SET_ON_OFF = 1, /**< Set ON OFF */
- ZBLIB_ON_OFF_OPS_GET_ON_OFF_STATE, /**< Get ON OFF state */
+ ZBLIB_ZCL_ON_OFF_OPS_SET_ON_OFF = 1, /**< Set ON OFF */
+ ZBLIB_ZCL_ON_OFF_OPS_GET_ON_OFF_STATE, /**< Get ON OFF state */
} ZblibZclOnOffOps_e;
-/* ZigBee 'on off' driver APIs */
+/* ZigBee 'ZCL on off' driver APIs */
ZigBeeDriver *zblib_driver_zcl_on_off_new(ZigBeePlugin *plugin,
const gchar *driver_name,
ZblibDriverZclOnOffOps_t *ops);
void zblib_driver_zcl_on_off_free(ZigBeeDriver *driver);
-#endif /* __ZIGBEE_LIB_DRIVER_ON_OFF_H__ */
+#endif /* __ZIGBEE_LIB_DRIVER_ZCL_ON_OFF_H__ */
#ifndef __ZIGBEE_LIB_DRIVER_ZCL_POLL_CONTROL_H__
#define __ZIGBEE_LIB_DRIVER_ZCL_POLL_CONTROL_H__
-/**< ZigBee 'Zcl poll control' driver operations */
+/**< ZigBee 'ZCL poll control' driver operations */
typedef struct {
gboolean (*check_in_response)(ZigBeeDriver *driver, guint request_id);
gboolean (*fast_poll_stop)(ZigBeeDriver *driver, guint request_id);
gboolean (*set_short_poll_interval)(ZigBeeDriver *driver, guint request_id);
} ZblibDriverZclPollControlOps_t;
-/**< ZigBee 'Zcl poll control' ops IDs */
+/**< ZigBee 'ZCL poll control' ops IDs */
typedef enum {
ZBLIB_ZCL_POLL_CONTROL_OPS_CHECK_IN_RESPONSE = 1, /**< Check in response */
ZBLIB_ZCL_POLL_CONTROL_OPS_FAST_POLL_STOP, /**< Fast poll stop */
#ifndef __ZIGBEE_LIB_DRIVER_ZCL_SCENE_H__
#define __ZIGBEE_LIB_DRIVER_ZCL_SCENE_H__
-/**< ZigBee 'Zcl scene' driver operations */
+/**< ZigBee 'ZCL scene' driver operations */
typedef struct {
gboolean (*add_scene)(ZigBeeDriver *driver, guint request_id);
gboolean (*view_scene)(ZigBeeDriver *driver, guint request_id);
gboolean (*get_scene_membership)(ZigBeeDriver *driver, guint request_id);
} ZblibDriverZclSceneOps_t;
-/**< ZigBee 'Zcl scene' ops IDs */
+/**< ZigBee 'ZCL scene' ops IDs */
typedef enum {
ZBLIB_ZCL_SCENE_OPS_ADD_SCENE = 1, /**< Add scene */
ZBLIB_ZCL_SCENE_OPS_VIEW_SCENE, /**< View scene */
ZBLIB_ZCL_SCENE_OPS_GET_SCENE_MEMBERSHIP, /**< Get scene membership */
} ZblibZclSceneOps_e;
-/* ZigBee 'Zcl scene' driver APIs */
+/* ZigBee 'ZCL scene' driver APIs */
ZigBeeDriver *zblib_driver_zcl_scene_new(ZigBeePlugin *plugin,
const gchar *driver_name,
ZblibDriverZclSceneOps_t *ops);
* limitations under the License.
*/
-#ifndef __ZIGBEE_LIB_DRIVER_THERMOSTAT_H__
-#define __ZIGBEE_LIB_DRIVER_THERMOSTAT_H__
+#ifndef __ZIGBEE_LIB_DRIVER_ZCL_THERMOSTAT_H__
+#define __ZIGBEE_LIB_DRIVER_ZCL_THERMOSTAT_H__
-/**< ZigBee 'thermostat' driver operations */
+/**< ZigBee 'ZCL thermostat' driver operations */
typedef struct {
gboolean (*get_local_temp)(ZigBeeDriver *driver, guint request_id);
gboolean (*get_weekly_schedule)(ZigBeeDriver *driver, guint request_id);
gboolean (*setpoint_raise_lower)(ZigBeeDriver *driver, guint request_id);
} ZblibDriverZclThermostatOps_t;
-/**< ZigBee 'thermostat' ops IDs */
+/**< ZigBee 'ZCL thermostat' ops IDs */
typedef enum {
- ZBLIB_THERMOSTAT_OPS_GET_LOCAL_TEMP = 1, /**< Get local temp */
- ZBLIB_THERMOSTAT_OPS_GET_WEEKLY_SCHEDULE, /**< Get weekly schedule */
- ZBLIB_THERMOSTAT_OPS_SET_WEEKLY_SCHEDULE, /**< Set weekly schedule */
- ZBLIB_THERMOSTAT_OPS_CLEAR_WEEKLY_SCHEDULE, /**< Clear weekly schedule */
- ZBLIB_THERMOSTAT_OPS_SETPOINT_RAISE_LOWER, /**< Setpoint raise lower */
+ ZBLIB_ZCL_THERMOSTAT_OPS_GET_LOCAL_TEMP = 1, /**< Get local temp */
+ ZBLIB_ZCL_THERMOSTAT_OPS_GET_WEEKLY_SCHEDULE, /**< Get weekly schedule */
+ ZBLIB_ZCL_THERMOSTAT_OPS_SET_WEEKLY_SCHEDULE, /**< Set weekly schedule */
+ ZBLIB_ZCL_THERMOSTAT_OPS_CLEAR_WEEKLY_SCHEDULE, /**< Clear weekly schedule */
+ ZBLIB_ZCL_THERMOSTAT_OPS_SETPOINT_RAISE_LOWER, /**< Setpoint raise lower */
} ZblibZclThermostatOps_e;
-/* ZigBee 'thermostat' driver APIs */
+/* ZigBee 'ZCL thermostat' driver APIs */
ZigBeeDriver *zblib_driver_zcl_thermostat_new(ZigBeePlugin *plugin,
const gchar *driver_name,
ZblibDriverZclThermostatOps_t *ops);
void zblib_driver_zcl_thermostat_free(ZigBeeDriver *driver);
-#endif /* __ZIGBEE_LIB_DRIVER_THERMOSTAT_H__ */
+#endif /* __ZIGBEE_LIB_DRIVER_ZCL_THERMOSTAT_H__ */
#ifndef __ZIGBEE_LIB_DRIVER_ZDO_BIND_H__
#define __ZIGBEE_LIB_DRIVER_ZDO_BIND_H__
-/**< ZigBee 'Zdo bind' driver operations */
+/**< ZigBee 'ZDO bind' driver operations */
typedef struct {
gboolean (*bind_req)(ZigBeeDriver *driver, guint request_id);
gboolean (*unbind_req)(ZigBeeDriver *driver, guint request_id);
} ZblibDriverZdoBindOps_t;
-/**< ZigBee 'Zdo bind' ops IDs */
+/**< ZigBee 'ZDO bind' ops IDs */
typedef enum {
ZBLIB_ZDO_BIND_OPS_BIND_REQ = 1, /**< Bind req */
ZBLIB_ZDO_BIND_OPS_UNBIND_REQ, /**< Unbind req */
} ZblibZdoBindOps_e;
-/* ZigBee 'Zdo bind' driver APIs */
+/* ZigBee 'ZDO bind' driver APIs */
ZigBeeDriver *zblib_driver_zdo_bind_new(ZigBeePlugin *plugin,
const gchar *driver_name,
ZblibDriverZdoBindOps_t *ops);
* limitations under the License.
*/
-#ifndef __ZIGBEE_LIB_DRIVER_ZDODEV_CONTROL_H__
-#define __ZIGBEE_LIB_DRIVER_ZDODEV_CONTROL_H__
+#ifndef __ZIGBEE_LIB_DRIVER_ZDO_DEV_CONTROL_H__
+#define __ZIGBEE_LIB_DRIVER_ZDO_DEV_CONTROL_H__
-/**< ZigBee 'Zdodev control' driver operations */
+/**< ZigBee 'ZDO Dev control' driver operations */
typedef struct {
gboolean (*nwk_addr_req)(ZigBeeDriver *driver, guint request_id);
gboolean (*matched_descriptor_req)(ZigBeeDriver *driver, guint request_id);
gboolean (*mgmt_permit_join_req)(ZigBeeDriver *driver, guint request_id);
gboolean (*nwk_update_req)(ZigBeeDriver *driver, guint request_id);
gboolean (*nwk_disc_req)(ZigBeeDriver *driver, guint request_id);
-} ZblibDriverZdodevControlOps_t;
+} ZblibDriverZdoDevControlOps_t;
-/**< ZigBee 'Zdodev control' ops IDs */
+/**< ZigBee 'ZDO Dev control' ops IDs */
typedef enum {
- ZBLIB_ZDODEV_CONTROL_OPS_NWK_ADDR_REQ = 1, /**< Nwk addr req */
- ZBLIB_ZDODEV_CONTROL_OPS_MATCHED_DESCRIPTOR_REQ, /**< Matched descriptor req */
- ZBLIB_ZDODEV_CONTROL_OPS_IEEE_ADDR_REQ, /**< IEEE addr req */
- ZBLIB_ZDODEV_CONTROL_OPS_ACTIVE_EP_REQ, /**< Active ep req */
- ZBLIB_ZDODEV_CONTROL_OPS_NODE_DESC_REQ, /**< Mode desc req */
- ZBLIB_ZDODEV_CONTROL_OPS_POWER_DESC_REQ, /**< Power desc req */
- ZBLIB_ZDODEV_CONTROL_OPS_COMPLEX_DESC_REQ, /**< Complex desc req */
- ZBLIB_ZDODEV_CONTROL_OPS_USER_DESC_REQ, /**< User desc req */
- ZBLIB_ZDODEV_CONTROL_OPS_USER_DESC_SET_REQ, /**< User desc set req */
- ZBLIB_ZDODEV_CONTROL_OPS_DEVICE_ANNOUNCE, /**< Device announce */
- ZBLIB_ZDODEV_CONTROL_OPS_SIMPLE_DESC_REQ, /**< Simple desc req */
- ZBLIB_ZDODEV_CONTROL_OPS_MGMT_LQI_REQ, /**< Mgmt lqi req */
- ZBLIB_ZDODEV_CONTROL_OPS_MGMT_RTG_REQ, /**< Mgmt rtg req */
- ZBLIB_ZDODEV_CONTROL_OPS_MGMT_BIND_REQ, /**< mgmt bind req */
- ZBLIB_ZDODEV_CONTROL_OPS_MGMT_PERMIT_JOIN_REQ, /**< mgmt permit join req */
- ZBLIB_ZDODEV_CONTROL_OPS_NWK_UPDATE_REQ, /**< Nwk update req */
- ZBLIB_ZDODEV_CONTROL_OPS_NWK_DISC_REQ, /**< Nwk disc req */
-} ZblibZdodevControlOps_e;
+ ZBLIB_ZDO_DEV_CONTROL_OPS_NWK_ADDR_REQ = 1, /**< Nwk addr req */
+ ZBLIB_ZDO_DEV_CONTROL_OPS_MATCHED_DESCRIPTOR_REQ, /**< Matched descriptor req */
+ ZBLIB_ZDO_DEV_CONTROL_OPS_IEEE_ADDR_REQ, /**< IEEE addr req */
+ ZBLIB_ZDO_DEV_CONTROL_OPS_ACTIVE_EP_REQ, /**< Active ep req */
+ ZBLIB_ZDO_DEV_CONTROL_OPS_NODE_DESC_REQ, /**< Mode desc req */
+ ZBLIB_ZDO_DEV_CONTROL_OPS_POWER_DESC_REQ, /**< Power desc req */
+ ZBLIB_ZDO_DEV_CONTROL_OPS_COMPLEX_DESC_REQ, /**< Complex desc req */
+ ZBLIB_ZDO_DEV_CONTROL_OPS_USER_DESC_REQ, /**< User desc req */
+ ZBLIB_ZDO_DEV_CONTROL_OPS_USER_DESC_SET_REQ, /**< User desc set req */
+ ZBLIB_ZDO_DEV_CONTROL_OPS_DEVICE_ANNOUNCE, /**< Device announce */
+ ZBLIB_ZDO_DEV_CONTROL_OPS_SIMPLE_DESC_REQ, /**< Simple desc req */
+ ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_LQI_REQ, /**< Mgmt lqi req */
+ ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_RTG_REQ, /**< Mgmt rtg req */
+ ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_BIND_REQ, /**< mgmt bind req */
+ ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_PERMIT_JOIN_REQ, /**< mgmt permit join req */
+ ZBLIB_ZDO_DEV_CONTROL_OPS_NWK_UPDATE_REQ, /**< Nwk update req */
+ ZBLIB_ZDO_DEV_CONTROL_OPS_NWK_DISC_REQ, /**< Nwk disc req */
+} ZblibZdoDevControlOps_e;
-/* ZigBee 'Zdodev control' driver APIs */
+/* ZigBee 'ZDO Dev control' driver APIs */
ZigBeeDriver *zblib_driver_zdo_dev_control_new(ZigBeePlugin *plugin,
const gchar *driver_name,
- ZblibDriverZdodevControlOps_t *ops);
+ ZblibDriverZdoDevControlOps_t *ops);
void zblib_driver_zdo_dev_control_free(ZigBeeDriver *driver);
-#endif /* __ZIGBEE_LIB_DRIVER_ZDODEV_CONTROL_H__ */
+#endif /* __ZIGBEE_LIB_DRIVER_ZDO_DEV_CONTROL_H__ */
/* Fetch ops ID */
ops_id = zblib_request_get_ops_id(request_type);
switch (ops_id) {
- case ZBLIB_ALARM_OPS_GET_ALARM_COUNT: {
+ case ZBLIB_ZCL_ALARM_OPS_GET_ALARM_COUNT: {
zblib_check_null_ret_error("ops->get_alarm_count",
ops->get_alarm_count, FALSE);
}
break;
- case ZBLIB_ALARM_OPS_RESET_ALARM: {
+ case ZBLIB_ZCL_ALARM_OPS_RESET_ALARM: {
zblib_check_null_ret_error("ops->reset_alarm",
ops->reset_alarm, FALSE);
}
break;
- case ZBLIB_ALARM_OPS_RESET_ALL_ALARM: {
+ case ZBLIB_ZCL_ALARM_OPS_RESET_ALL_ALARM: {
zblib_check_null_ret_error("ops->reset_all_alarm",
ops->reset_all_alarm, FALSE);
}
break;
- case ZBLIB_ALARM_OPS_ALARM: {
+ case ZBLIB_ZCL_ALARM_OPS_ALARM: {
zblib_check_null_ret_error("ops->alarm",
ops->alarm, FALSE);
}
break;
- case ZBLIB_ALARM_OPS_RESET_ALARM_LOG: {
+ case ZBLIB_ZCL_ALARM_OPS_RESET_ALARM_LOG: {
zblib_check_null_ret_error("ops->reset_alarm_log",
ops->reset_alarm_log, FALSE);
}
break;
- case ZBLIB_ALARM_OPS_GET_ALARM: {
+ case ZBLIB_ZCL_ALARM_OPS_GET_ALARM: {
zblib_check_null_ret_error("ops->get_alarm",
ops->get_alarm, FALSE);
zblib_check_null_ret_error("plugin", plugin, NULL);
/* Create new driver */
- driver = zblib_driver_new(plugin, driver_name, ZBLIB_DRIVER_TYPE_ALARM);
+ driver = zblib_driver_new(plugin, driver_name, ZBLIB_DRIVER_TYPE_ZCL_ALARM);
zblib_check_null_ret_error("driver", driver, NULL);
/* Allocate memory for private data */
/**< Private data */
typedef struct {
- ZblibDriverZclbasicControlOps_t *ops; /**< Operations */
-} ZblibDriverZclbasicControlPrivData_t;
+ ZblibDriverZclBasicOps_t *ops; /**< Operations */
+} ZblibDriverZclBasicPrivData_t;
static gboolean __zblib_driver_zcl_basic_dispatcher(ZigBeeDriver *driver, guint request_id)
{
ZigBeeService *service = NULL;
- ZblibDriverZclbasicControlPrivData_t *priv_data = NULL;
- ZblibDriverZclbasicControlOps_t *ops = NULL;
+ ZblibDriverZclBasicPrivData_t *priv_data = NULL;
+ ZblibDriverZclBasicOps_t *ops = NULL;
guint request_type;
guint ops_id;
gboolean ret = FALSE;
/* Fetch ops ID */
ops_id = zblib_request_get_ops_id(request_type);
switch (ops_id) {
- case ZBLIB_ZCLBASIC_CONTROL_OPS_RESET_FACTORY_DEFAULT: {
+ case ZBLIB_ZCL_BASIC_OPS_RESET_FACTORY_DEFAULT: {
zblib_check_null_ret_error("ops->reset_factory_default",
ops->reset_factory_default, FALSE);
static void __zblib_driver_zcl_basic_free_hook(ZigBeeDriver *driver)
{
- ZblibDriverZclbasicControlPrivData_t *priv_data = NULL;
+ ZblibDriverZclBasicPrivData_t *priv_data = NULL;
zblib_check_null_ret("driver", driver);
ZigBeeDriver *zblib_driver_zcl_basic_new(ZigBeePlugin *plugin,
const gchar *driver_name,
- ZblibDriverZclbasicControlOps_t *ops)
+ ZblibDriverZclBasicOps_t *ops)
{
ZigBeeDriver *driver = NULL;
- ZblibDriverZclbasicControlPrivData_t *priv_data = NULL;
+ ZblibDriverZclBasicPrivData_t *priv_data = NULL;
gboolean ret;
zblib_check_null_ret_error("plugin", plugin, NULL);
/* Create new driver */
- driver = zblib_driver_new(plugin, driver_name, ZBLIB_DRIVER_TYPE_ZCLBASIC_CONTROL);
+ driver = zblib_driver_new(plugin, driver_name, ZBLIB_DRIVER_TYPE_ZCL_BASIC);
zblib_check_null_ret_error("driver", driver, NULL);
/* Allocate memory for private data */
- priv_data = g_malloc0(sizeof(ZblibDriverZclbasicControlPrivData_t));
+ priv_data = g_malloc0(sizeof(ZblibDriverZclBasicPrivData_t));
/* Update private data */
priv_data->ops = ops;
/**< Private data */
typedef struct {
- ZblibDriverZclColorOps_t *ops; /**< Operations */
-} ZblibDriverZclColorPrivData_t;
+ ZblibDriverZclColorControlOps_t *ops; /**< Operations */
+} ZblibDriverZclColorControlPrivData_t;
static gboolean __zblib_driver_zcl_color_control_dispatcher(ZigBeeDriver *driver, guint request_id)
{
ZigBeeService *service = NULL;
- ZblibDriverZclColorPrivData_t *priv_data = NULL;
- ZblibDriverZclColorOps_t *ops = NULL;
+ ZblibDriverZclColorControlPrivData_t *priv_data = NULL;
+ ZblibDriverZclColorControlOps_t *ops = NULL;
guint request_type;
guint ops_id;
gboolean ret = FALSE;
/* Fetch ops ID */
ops_id = zblib_request_get_ops_id(request_type);
switch (ops_id) {
- case ZBLIB_ZCL_COLOR_OPS_MOVE_TO_HUE: {
+ case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_HUE: {
zblib_check_null_ret_error("ops->move_to_hue",
ops->move_to_hue, FALSE);
}
break;
- case ZBLIB_ZCL_COLOR_OPS_MOVE_HUE: {
+ case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_HUE: {
zblib_check_null_ret_error("ops->move_hue",
ops->move_hue, FALSE);
}
break;
- case ZBLIB_ZCL_COLOR_OPS_STEP_HUE: {
+ case ZBLIB_ZCL_COLOR_CONTROL_OPS_STEP_HUE: {
zblib_check_null_ret_error("ops->step_hue",
ops->step_hue, FALSE);
}
break;
- case ZBLIB_ZCL_COLOR_OPS_MOVE_TO_STAURATION: {
+ case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_STAURATION: {
zblib_check_null_ret_error("ops->move_to_saturation",
ops->move_to_saturation, FALSE);
}
break;
- case ZBLIB_ZCL_COLOR_OPS_MOVE_STAURATION: {
+ case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_STAURATION: {
zblib_check_null_ret_error("ops->move_saturation",
ops->move_saturation, FALSE);
}
break;
- case ZBLIB_ZCL_COLOR_OPS_STEP_STAURATION: {
+ case ZBLIB_ZCL_COLOR_CONTROL_OPS_STEP_STAURATION: {
zblib_check_null_ret_error("ops->step_saturation",
ops->step_saturation, FALSE);
}
break;
- case ZBLIB_ZCL_COLOR_OPS_MOVE_TO_HUE_AND_SATURATION: {
+ case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_HUE_AND_SATURATION: {
zblib_check_null_ret_error("ops->move_to_hue_and_saturation",
ops->move_to_hue_and_saturation, FALSE);
}
break;
- case ZBLIB_ZCL_COLOR_OPS_MOVE_TO_COLOR: {
+ case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_COLOR: {
zblib_check_null_ret_error("ops->move_to_color",
ops->move_to_color, FALSE);
}
break;
- case ZBLIB_ZCL_COLOR_OPS_MOVE_COLOR: {
+ case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_COLOR: {
zblib_check_null_ret_error("ops->move_color",
ops->move_color, FALSE);
}
break;
- case ZBLIB_ZCL_COLOR_OPS_STEP_COLOR: {
+ case ZBLIB_ZCL_COLOR_CONTROL_OPS_STEP_COLOR: {
zblib_check_null_ret_error("ops->step_color",
ops->step_color, FALSE);
}
break;
- case ZBLIB_ZCL_COLOR_OPS_MOVE_COLOR_TEMPERATURE: {
+ case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_COLOR_TEMPERATURE: {
zblib_check_null_ret_error("ops->move_color_temperature",
ops->move_color_temperature, FALSE);
static void __zblib_driver_zcl_color_control_free_hook(ZigBeeDriver *driver)
{
- ZblibDriverZclColorPrivData_t *priv_data = NULL;
+ ZblibDriverZclColorControlPrivData_t *priv_data = NULL;
zblib_check_null_ret("driver", driver);
ZigBeeDriver *zblib_driver_zcl_color_control_new(ZigBeePlugin *plugin,
const gchar *driver_name,
- ZblibDriverZclColorOps_t *ops)
+ ZblibDriverZclColorControlOps_t *ops)
{
ZigBeeDriver *driver = NULL;
- ZblibDriverZclColorPrivData_t *priv_data = NULL;
+ ZblibDriverZclColorControlPrivData_t *priv_data = NULL;
gboolean ret;
zblib_check_null_ret_error("plugin", plugin, NULL);
/* Create new driver */
- driver = zblib_driver_new(plugin, driver_name, ZBLIB_DRIVER_TYPE_ZCL_COLOR);
+ driver = zblib_driver_new(plugin, driver_name, ZBLIB_DRIVER_TYPE_ZCL_COLOR_CONTROL);
zblib_check_null_ret_error("driver", driver, NULL);
/* Allocate memory for private data */
- priv_data = g_malloc0(sizeof(ZblibDriverZclColorPrivData_t));
+ priv_data = g_malloc0(sizeof(ZblibDriverZclColorControlPrivData_t));
/* Update private data */
priv_data->ops = ops;
/* Fetch ops ID */
ops_id = zblib_request_get_ops_id(request_type);
switch (ops_id) {
- case ZBLIB_DOOR_LOCK_OPS_SUBSCRIBE_LOCK_EVENT: {
+ case ZBLIB_ZCL_DOOR_LOCK_OPS_SUBSCRIBE_LOCK_EVENT: {
zblib_check_null_ret_error("ops->subscribe_lock_event",
ops->subscribe_lock_event, FALSE);
}
break;
- case ZBLIB_DOOR_LOCK_OPS_SET_DOOR_LOCK_PIN: {
+ case ZBLIB_ZCL_DOOR_LOCK_OPS_SET_DOOR_LOCK_PIN: {
zblib_check_null_ret_error("ops->set_door_lock_pin",
ops->set_door_lock_pin, FALSE);
}
break;
- case ZBLIB_DOOR_LOCK_OPS_SET_DOOR_LOCK: {
+ case ZBLIB_ZCL_DOOR_LOCK_OPS_SET_DOOR_LOCK: {
zblib_check_null_ret_error("ops->set_door_lock",
ops->set_door_lock, FALSE);
}
break;
- case ZBLIB_DOOR_LOCK_OPS_GET_LOCK_STATE: {
+ case ZBLIB_ZCL_DOOR_LOCK_OPS_GET_LOCK_STATE: {
zblib_check_null_ret_error("ops->get_lock_state", ops->get_lock_state, FALSE);
ret = ops->get_lock_state(driver, request_id);
zblib_check_null_ret_error("plugin", plugin, NULL);
/* Create new driver */
- driver = zblib_driver_new(plugin, driver_name, ZBLIB_DRIVER_TYPE_DOOR_LOCK);
+ driver = zblib_driver_new(plugin, driver_name, ZBLIB_DRIVER_TYPE_ZCL_DOOR_LOCK);
zblib_check_null_ret_error("driver", driver, NULL);
/* Allocate memory for private data */
/**< Private data */
typedef struct {
- ZblibDriverFanControlOps_t *ops; /**< Operations */
-} ZblibDriverFanControlPrivData_t;
+ ZblibDriverZclFanControlOps_t *ops; /**< Operations */
+} ZblibDriverZclFanControlPrivData_t;
static gboolean __zblib_driver_zcl_fan_control_dispatcher(ZigBeeDriver *driver, guint request_id)
{
ZigBeeService *service = NULL;
- ZblibDriverFanControlPrivData_t *priv_data = NULL;
- ZblibDriverFanControlOps_t *ops = NULL;
+ ZblibDriverZclFanControlPrivData_t *priv_data = NULL;
+ ZblibDriverZclFanControlOps_t *ops = NULL;
guint request_type;
guint ops_id;
gboolean ret = FALSE;
/* Fetch ops ID */
ops_id = zblib_request_get_ops_id(request_type);
switch (ops_id) {
- case ZBLIB_FAN_CONTROL_OPS_SET_FAN_MODE: {
+ case ZBLIB_ZCL_FAN_CONTROL_OPS_SET_FAN_MODE: {
zblib_check_null_ret_error("ops->set_fan_mode",
ops->set_fan_mode, FALSE);
}
break;
- case ZBLIB_FAN_CONTROL_OPS_GET_FAN_MODE: {
+ case ZBLIB_ZCL_FAN_CONTROL_OPS_GET_FAN_MODE: {
zblib_check_null_ret_error("ops->get_fan_mode",
ops->get_fan_mode, FALSE);
}
break;
- case ZBLIB_FAN_CONTROL_OPS_SET_FAN_MODE_SEQUENCE: {
+ case ZBLIB_ZCL_FAN_CONTROL_OPS_SET_FAN_MODE_SEQUENCE: {
zblib_check_null_ret_error("ops->set_fan_mode_sequence",
ops->set_fan_mode_sequence, FALSE);
}
break;
- case ZBLIB_FAN_CONTROL_OPS_GET_FAN_MODE_SEQUENCE: {
+ case ZBLIB_ZCL_FAN_CONTROL_OPS_GET_FAN_MODE_SEQUENCE: {
zblib_check_null_ret_error("ops->get_fan_mode_sequence",
ops->get_fan_mode_sequence, FALSE);
static void __zblib_driver_zcl_fan_control_free_hook(ZigBeeDriver *driver)
{
- ZblibDriverFanControlPrivData_t *priv_data = NULL;
+ ZblibDriverZclFanControlPrivData_t *priv_data = NULL;
zblib_check_null_ret("driver", driver);
ZigBeeDriver *zblib_driver_zcl_fan_control_new(ZigBeePlugin *plugin,
const gchar *driver_name,
- ZblibDriverFanControlOps_t *ops)
+ ZblibDriverZclFanControlOps_t *ops)
{
ZigBeeDriver *driver = NULL;
- ZblibDriverFanControlPrivData_t *priv_data = NULL;
+ ZblibDriverZclFanControlPrivData_t *priv_data = NULL;
gboolean ret;
zblib_check_null_ret_error("plugin", plugin, NULL);
/* Create new driver */
- driver = zblib_driver_new(plugin, driver_name, ZBLIB_DRIVER_TYPE_FAN_CONTROL);
+ driver = zblib_driver_new(plugin, driver_name, ZBLIB_DRIVER_TYPE_ZCL_FAN_CONTROL);
zblib_check_null_ret_error("driver", driver, NULL);
/* Allocate memory for private data */
- priv_data = g_malloc0(sizeof(ZblibDriverFanControlPrivData_t));
+ priv_data = g_malloc0(sizeof(ZblibDriverZclFanControlPrivData_t));
/* Update private data */
priv_data->ops = ops;
/**< Private data */
typedef struct {
- ZblibDriverZclglobalControlOps_t *ops; /**< Operations */
+ ZblibDriverZclGlobalControlOps_t *ops; /**< Operations */
} ZblibDriverZclglobalControlPrivData_t;
static gboolean __zblib_driver_zcl_global_control_dispatcher(ZigBeeDriver *driver, guint request_id)
{
ZigBeeService *service = NULL;
ZblibDriverZclglobalControlPrivData_t *priv_data = NULL;
- ZblibDriverZclglobalControlOps_t *ops = NULL;
+ ZblibDriverZclGlobalControlOps_t *ops = NULL;
guint request_type;
guint ops_id;
gboolean ret = FALSE;
/* Fetch ops ID */
ops_id = zblib_request_get_ops_id(request_type);
switch (ops_id) {
- case ZBLIB_ZCLGLOBAL_CONTROL_OPS_READ_ATTRIBUTES_REQ: {
+ case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_READ_ATTRIBUTES_REQ: {
zblib_check_null_ret_error("ops->read_attributes_req",
ops->read_attributes_req, FALSE);
}
break;
- case ZBLIB_ZCLGLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_REQ: {
+ case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_REQ: {
zblib_check_null_ret_error("ops->write_attributes_req",
ops->write_attributes_req, FALSE);
}
break;
- case ZBLIB_ZCLGLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_UNDIVIDED_REQ: {
+ case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_UNDIVIDED_REQ: {
zblib_check_null_ret_error("ops->write_attributes_undivided_req",
ops->write_attributes_undivided_req, FALSE);
}
break;
- case ZBLIB_ZCLGLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_NO_RESP: {
+ case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_NO_RESP: {
zblib_check_null_ret_error("ops->write_attributes_no_resp",
ops->write_attributes_no_resp, FALSE);
}
break;
- case ZBLIB_ZCLGLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_STRUCTURED: {
+ case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_STRUCTURED: {
zblib_check_null_ret_error("ops->write_attributes_structured",
ops->write_attributes_structured, FALSE);
}
break;
- case ZBLIB_ZCLGLOBAL_CONTROL_OPS_READ_ATTRIBUTES_STRUCTURED: {
+ case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_READ_ATTRIBUTES_STRUCTURED: {
zblib_check_null_ret_error("ops->read_attributes_structured",
ops->read_attributes_structured, FALSE);
}
break;
- case ZBLIB_ZCLGLOBAL_CONTROL_OPS_CONFIGURE_REPORTING_REQ: {
+ case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_CONFIGURE_REPORTING_REQ: {
zblib_check_null_ret_error("ops->configure_reporting_req",
ops->configure_reporting_req, FALSE);
}
break;
- case ZBLIB_ZCLGLOBAL_CONTROL_OPS_READ_CONFIGURE_REPORTING: {
+ case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_READ_CONFIGURE_REPORTING: {
zblib_check_null_ret_error("ops->read_configure_reporting",
ops->read_configure_reporting, FALSE);
}
break;
- case ZBLIB_ZCLGLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES: {
+ case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES: {
zblib_check_null_ret_error("ops->discover_attributes",
ops->discover_attributes, FALSE);
}
break;
- case ZBLIB_ZCLGLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES_EXTENDED: {
+ case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES_EXTENDED: {
zblib_check_null_ret_error("ops->discover_attributes_extended",
ops->discover_attributes_extended, FALSE);
}
break;
- case ZBLIB_ZCLGLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_RECEIVED: {
+ case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_RECEIVED: {
zblib_check_null_ret_error("ops->discover_commands_received",
ops->discover_commands_received, FALSE);
}
break;
- case ZBLIB_ZCLGLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_GENERATED: {
+ case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_GENERATED: {
zblib_check_null_ret_error("ops->discover_commands_generated",
ops->discover_commands_generated, FALSE);
ZigBeeDriver *zblib_driver_zcl_global_control_new(ZigBeePlugin *plugin,
const gchar *driver_name,
- ZblibDriverZclglobalControlOps_t *ops)
+ ZblibDriverZclGlobalControlOps_t *ops)
{
ZigBeeDriver *driver = NULL;
ZblibDriverZclglobalControlPrivData_t *priv_data = NULL;
zblib_check_null_ret_error("plugin", plugin, NULL);
/* Create new driver */
- driver = zblib_driver_new(plugin, driver_name, ZBLIB_DRIVER_TYPE_ZCLGLOBAL_CONTROL);
+ driver = zblib_driver_new(plugin, driver_name, ZBLIB_DRIVER_TYPE_ZCL_GLOBAL_CONTROL);
zblib_check_null_ret_error("driver", driver, NULL);
/* Allocate memory for private data */
/**< Private data */
typedef struct {
- ZblibDriverZcliasZoneOps_t *ops; /**< Operations */
-} ZblibDriverZcliasZonePrivData_t;
+ ZblibDriverZclIasZoneOps_t *ops; /**< Operations */
+} ZblibDriverZclIasZonePrivData_t;
static gboolean __zblib_driver_zcl_ias_zone_dispatcher(ZigBeeDriver *driver, guint request_id)
{
ZigBeeService *service = NULL;
- ZblibDriverZcliasZonePrivData_t *priv_data = NULL;
- ZblibDriverZcliasZoneOps_t *ops = NULL;
+ ZblibDriverZclIasZonePrivData_t *priv_data = NULL;
+ ZblibDriverZclIasZoneOps_t *ops = NULL;
guint request_type;
guint ops_id;
gboolean ret = FALSE;
/* Fetch ops ID */
ops_id = zblib_request_get_ops_id(request_type);
switch (ops_id) {
- case ZBLIB_ZCLIAS_CONTROL_OPS_ENROLL_RESPONSE: {
+ case ZBLIB_ZCL_IAS_ZONE_OPS_ENROLL_RESPONSE: {
zblib_check_null_ret_error("ops->enroll_response",
ops->enroll_response, FALSE);
static void __zblib_driver_zcl_ias_zone_free_hook(ZigBeeDriver *driver)
{
- ZblibDriverZcliasZonePrivData_t *priv_data = NULL;
+ ZblibDriverZclIasZonePrivData_t *priv_data = NULL;
zblib_check_null_ret("driver", driver);
ZigBeeDriver *zblib_driver_zcl_ias_zone_new(ZigBeePlugin *plugin,
const gchar *driver_name,
- ZblibDriverZcliasZoneOps_t *ops)
+ ZblibDriverZclIasZoneOps_t *ops)
{
ZigBeeDriver *driver = NULL;
- ZblibDriverZcliasZonePrivData_t *priv_data = NULL;
+ ZblibDriverZclIasZonePrivData_t *priv_data = NULL;
gboolean ret;
zblib_check_null_ret_error("plugin", plugin, NULL);
/* Create new driver */
- driver = zblib_driver_new(plugin, driver_name, ZBLIB_DRIVER_TYPE_ZCLIAS_CONTROL);
+ driver = zblib_driver_new(plugin, driver_name, ZBLIB_DRIVER_TYPE_ZCL_IAS_ZONE);
zblib_check_null_ret_error("driver", driver, NULL);
/* Allocate memory for private data */
- priv_data = g_malloc0(sizeof(ZblibDriverZcliasZonePrivData_t));
+ priv_data = g_malloc0(sizeof(ZblibDriverZclIasZonePrivData_t));
/* Update private data */
priv_data->ops = ops;
/**< Private data */
typedef struct {
- ZblibDriverZclidentifyOps_t *ops; /**< Operations */
-} ZblibDriverZclidentifyPrivData_t;
+ ZblibDriverZclIdentifyOps_t *ops; /**< Operations */
+} ZblibDriverZclIdentifyPrivData_t;
static gboolean __zblib_driver_zcl_identify_dispatcher(ZigBeeDriver *driver, guint request_id)
{
ZigBeeService *service = NULL;
- ZblibDriverZclidentifyPrivData_t *priv_data = NULL;
- ZblibDriverZclidentifyOps_t *ops = NULL;
+ ZblibDriverZclIdentifyPrivData_t *priv_data = NULL;
+ ZblibDriverZclIdentifyOps_t *ops = NULL;
guint request_type;
guint ops_id;
gboolean ret = FALSE;
/* Fetch ops ID */
ops_id = zblib_request_get_ops_id(request_type);
switch (ops_id) {
- case ZBLIB_ZCLIDENTIFY_CONTROL_OPS_IDENTIFY: {
+ case ZBLIB_ZCL_IDENTIFY_OPS_IDENTIFY: {
zblib_check_null_ret_error("ops->identify",
ops->identify, FALSE);
}
break;
- case ZBLIB_ZCLIDENTIFY_CONTROL_OPS_QUERY: {
+ case ZBLIB_ZCL_IDENTIFY_OPS_QUERY: {
zblib_check_null_ret_error("ops->query",
ops->query, FALSE);
static void __zblib_driver_zcl_identify_free_hook(ZigBeeDriver *driver)
{
- ZblibDriverZclidentifyPrivData_t *priv_data = NULL;
+ ZblibDriverZclIdentifyPrivData_t *priv_data = NULL;
zblib_check_null_ret("driver", driver);
ZigBeeDriver *zblib_driver_zcl_identify_new(ZigBeePlugin *plugin,
const gchar *driver_name,
- ZblibDriverZclidentifyOps_t *ops)
+ ZblibDriverZclIdentifyOps_t *ops)
{
ZigBeeDriver *driver = NULL;
- ZblibDriverZclidentifyPrivData_t *priv_data = NULL;
+ ZblibDriverZclIdentifyPrivData_t *priv_data = NULL;
gboolean ret;
zblib_check_null_ret_error("plugin", plugin, NULL);
/* Create new driver */
- driver = zblib_driver_new(plugin, driver_name, ZBLIB_DRIVER_TYPE_ZCLIDENTIFY_CONTROL);
+ driver = zblib_driver_new(plugin, driver_name, ZBLIB_DRIVER_TYPE_ZCL_IDENTIFY);
zblib_check_null_ret_error("driver", driver, NULL);
/* Allocate memory for private data */
- priv_data = g_malloc0(sizeof(ZblibDriverZclidentifyPrivData_t));
+ priv_data = g_malloc0(sizeof(ZblibDriverZclIdentifyPrivData_t));
/* Update private data */
priv_data->ops = ops;
/**< Private data */
typedef struct {
- ZblibDriverLevelControlOps_t *ops; /**< Operations */
-} ZblibDriverLevelControlPrivData_t;
+ ZblibDriverZclLevelControlOps_t *ops; /**< Operations */
+} ZblibDriverZclLevelControlPrivData_t;
static gboolean __zblib_driver_zcl_level_control_dispatcher(ZigBeeDriver *driver, guint request_id)
{
ZigBeeService *service = NULL;
- ZblibDriverLevelControlPrivData_t *priv_data = NULL;
- ZblibDriverLevelControlOps_t *ops = NULL;
+ ZblibDriverZclLevelControlPrivData_t *priv_data = NULL;
+ ZblibDriverZclLevelControlOps_t *ops = NULL;
guint request_type;
guint ops_id;
gboolean ret = FALSE;
/* Fetch ops ID */
ops_id = zblib_request_get_ops_id(request_type);
switch (ops_id) {
- case ZBLIB_LEVEL_CONTROL_OPS_MOVE_TO_LEVEL: {
+ case ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE_TO_LEVEL: {
zblib_check_null_ret_error("ops->move_to_level",
ops->move_to_level, FALSE);
}
break;
- case ZBLIB_LEVEL_CONTROL_OPS_MOVE: {
+ case ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE: {
zblib_check_null_ret_error("ops->move",
ops->move, FALSE);
}
break;
- case ZBLIB_LEVEL_CONTROL_OPS_STEP: {
+ case ZBLIB_ZCL_LEVEL_CONTROL_OPS_STEP: {
zblib_check_null_ret_error("ops->step",
ops->step, FALSE);
}
break;
- case ZBLIB_LEVEL_CONTROL_OPS_MOVE_TO_LEVEL_WITH_ON_OFF: {
+ case ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE_TO_LEVEL_WITH_ON_OFF: {
zblib_check_null_ret_error("ops->move_to_level_with_on_off",
ops->move_to_level_with_on_off, FALSE);
}
break;
- case ZBLIB_LEVEL_CONTROL_OPS_MOVE_WITH_ON_OFF: {
+ case ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE_WITH_ON_OFF: {
zblib_check_null_ret_error("ops->move_with_on_off",
ops->move_with_on_off, FALSE);
}
break;
- case ZBLIB_LEVEL_CONTROL_OPS_STEP_WITH_ON_OFF: {
+ case ZBLIB_ZCL_LEVEL_CONTROL_OPS_STEP_WITH_ON_OFF: {
zblib_check_null_ret_error("ops->step_with_on_off",
ops->step_with_on_off, FALSE);
}
break;
- case ZBLIB_LEVEL_CONTROL_OPS_STOP: {
+ case ZBLIB_ZCL_LEVEL_CONTROL_OPS_STOP: {
zblib_check_null_ret_error("ops->stop",
ops->stop, FALSE);
static void __zblib_driver_zcl_level_control_free_hook(ZigBeeDriver *driver)
{
- ZblibDriverLevelControlPrivData_t *priv_data = NULL;
+ ZblibDriverZclLevelControlPrivData_t *priv_data = NULL;
zblib_check_null_ret("driver", driver);
ZigBeeDriver *zblib_driver_zcl_level_control_new(ZigBeePlugin *plugin,
const gchar *driver_name,
- ZblibDriverLevelControlOps_t *ops)
+ ZblibDriverZclLevelControlOps_t *ops)
{
ZigBeeDriver *driver = NULL;
- ZblibDriverLevelControlPrivData_t *priv_data = NULL;
+ ZblibDriverZclLevelControlPrivData_t *priv_data = NULL;
gboolean ret;
zblib_check_null_ret_error("plugin", plugin, NULL);
/* Create new driver */
- driver = zblib_driver_new(plugin, driver_name, ZBLIB_DRIVER_TYPE_LEVEL_CONTROL);
+ driver = zblib_driver_new(plugin, driver_name, ZBLIB_DRIVER_TYPE_ZCL_LEVEL_CONTROL);
zblib_check_null_ret_error("driver", driver, NULL);
/* Allocate memory for private data */
- priv_data = g_malloc0(sizeof(ZblibDriverLevelControlPrivData_t));
+ priv_data = g_malloc0(sizeof(ZblibDriverZclLevelControlPrivData_t));
/* Update private data */
priv_data->ops = ops;
/* Fetch ops ID */
ops_id = zblib_request_get_ops_id(request_type);
switch (ops_id) {
- case ZBLIB_ON_OFF_OPS_SET_ON_OFF: {
+ case ZBLIB_ZCL_ON_OFF_OPS_SET_ON_OFF: {
zblib_check_null_ret_error("ops->set_on_off",
ops->set_on_off, FALSE);
}
break;
- case ZBLIB_ON_OFF_OPS_GET_ON_OFF_STATE: {
+ case ZBLIB_ZCL_ON_OFF_OPS_GET_ON_OFF_STATE: {
zblib_check_null_ret_error("ops->get_on_off_state",
ops->get_on_off_state, FALSE);
zblib_check_null_ret_error("plugin", plugin, NULL);
/* Create new driver */
- driver = zblib_driver_new(plugin, driver_name, ZBLIB_DRIVER_TYPE_ON_OFF);
+ driver = zblib_driver_new(plugin, driver_name, ZBLIB_DRIVER_TYPE_ZCL_ON_OFF);
zblib_check_null_ret_error("driver", driver, NULL);
/* Allocate memory for private data */
/* Fetch ops ID */
ops_id = zblib_request_get_ops_id(request_type);
switch (ops_id) {
- case ZBLIB_THERMOSTAT_OPS_GET_LOCAL_TEMP: {
+ case ZBLIB_ZCL_THERMOSTAT_OPS_GET_LOCAL_TEMP: {
zblib_check_null_ret_error("ops->get_local_temp",
ops->get_local_temp, FALSE);
}
break;
- case ZBLIB_THERMOSTAT_OPS_GET_WEEKLY_SCHEDULE: {
+ case ZBLIB_ZCL_THERMOSTAT_OPS_GET_WEEKLY_SCHEDULE: {
zblib_check_null_ret_error("ops->get_weekly_schedule",
ops->get_weekly_schedule, FALSE);
}
break;
- case ZBLIB_THERMOSTAT_OPS_SET_WEEKLY_SCHEDULE: {
+ case ZBLIB_ZCL_THERMOSTAT_OPS_SET_WEEKLY_SCHEDULE: {
zblib_check_null_ret_error("ops->set_weekly_schedule",
ops->set_weekly_schedule, FALSE);
}
break;
- case ZBLIB_THERMOSTAT_OPS_CLEAR_WEEKLY_SCHEDULE: {
+ case ZBLIB_ZCL_THERMOSTAT_OPS_CLEAR_WEEKLY_SCHEDULE: {
zblib_check_null_ret_error("ops->clear_weekly_schedule",
ops->clear_weekly_schedule, FALSE);
}
break;
- case ZBLIB_THERMOSTAT_OPS_SETPOINT_RAISE_LOWER: {
+ case ZBLIB_ZCL_THERMOSTAT_OPS_SETPOINT_RAISE_LOWER: {
zblib_check_null_ret_error("ops->setpoint_raise_lower",
ops->setpoint_raise_lower, FALSE);
zblib_check_null_ret_error("plugin", plugin, NULL);
/* Create new driver */
- driver = zblib_driver_new(plugin, driver_name, ZBLIB_DRIVER_TYPE_THERMOSTAT);
+ driver = zblib_driver_new(plugin, driver_name, ZBLIB_DRIVER_TYPE_ZCL_THERMOSTAT);
zblib_check_null_ret_error("driver", driver, NULL);
/* Allocate memory for private data */
/**< Private data */
typedef struct {
- ZblibDriverZdodevControlOps_t *ops; /**< Operations */
-} ZblibDriverZdodevControlPrivData_t;
+ ZblibDriverZdoDevControlOps_t *ops; /**< Operations */
+} ZblibDriverZdoDevControlPrivData_t;
static gboolean __zblib_driver_zdo_dev_control_dispatcher(ZigBeeDriver *driver, guint request_id)
{
ZigBeeService *service = NULL;
- ZblibDriverZdodevControlPrivData_t *priv_data = NULL;
- ZblibDriverZdodevControlOps_t *ops = NULL;
+ ZblibDriverZdoDevControlPrivData_t *priv_data = NULL;
+ ZblibDriverZdoDevControlOps_t *ops = NULL;
guint request_type;
guint ops_id;
gboolean ret = FALSE;
/* Fetch ops ID */
ops_id = zblib_request_get_ops_id(request_type);
switch (ops_id) {
- case ZBLIB_ZDODEV_CONTROL_OPS_NWK_ADDR_REQ: {
+ case ZBLIB_ZDO_DEV_CONTROL_OPS_NWK_ADDR_REQ: {
zblib_check_null_ret_error("ops->nwk_addr_req",
ops->nwk_addr_req, FALSE);
}
break;
- case ZBLIB_ZDODEV_CONTROL_OPS_MATCHED_DESCRIPTOR_REQ: {
+ case ZBLIB_ZDO_DEV_CONTROL_OPS_MATCHED_DESCRIPTOR_REQ: {
zblib_check_null_ret_error("ops->matched_descriptor_req",
ops->matched_descriptor_req, FALSE);
}
break;
- case ZBLIB_ZDODEV_CONTROL_OPS_IEEE_ADDR_REQ: {
+ case ZBLIB_ZDO_DEV_CONTROL_OPS_IEEE_ADDR_REQ: {
zblib_check_null_ret_error("ops->ieee_addr_req",
ops->ieee_addr_req, FALSE);
}
break;
- case ZBLIB_ZDODEV_CONTROL_OPS_ACTIVE_EP_REQ: {
+ case ZBLIB_ZDO_DEV_CONTROL_OPS_ACTIVE_EP_REQ: {
zblib_check_null_ret_error("ops->active_ep_req",
ops->active_ep_req, FALSE);
}
break;
- case ZBLIB_ZDODEV_CONTROL_OPS_NODE_DESC_REQ: {
+ case ZBLIB_ZDO_DEV_CONTROL_OPS_NODE_DESC_REQ: {
zblib_check_null_ret_error("ops->node_desc_req",
ops->node_desc_req, FALSE);
}
break;
- case ZBLIB_ZDODEV_CONTROL_OPS_POWER_DESC_REQ: {
+ case ZBLIB_ZDO_DEV_CONTROL_OPS_POWER_DESC_REQ: {
zblib_check_null_ret_error("ops->power_desc_req",
ops->power_desc_req, FALSE);
}
break;
- case ZBLIB_ZDODEV_CONTROL_OPS_COMPLEX_DESC_REQ: {
+ case ZBLIB_ZDO_DEV_CONTROL_OPS_COMPLEX_DESC_REQ: {
zblib_check_null_ret_error("ops->complex_desc_req",
ops->complex_desc_req, FALSE);
}
break;
- case ZBLIB_ZDODEV_CONTROL_OPS_USER_DESC_REQ: {
+ case ZBLIB_ZDO_DEV_CONTROL_OPS_USER_DESC_REQ: {
zblib_check_null_ret_error("ops->user_desc_req",
ops->user_desc_req, FALSE);
}
break;
- case ZBLIB_ZDODEV_CONTROL_OPS_USER_DESC_SET_REQ: {
+ case ZBLIB_ZDO_DEV_CONTROL_OPS_USER_DESC_SET_REQ: {
zblib_check_null_ret_error("ops->user_desc_set_req",
ops->user_desc_set_req, FALSE);
}
break;
- case ZBLIB_ZDODEV_CONTROL_OPS_DEVICE_ANNOUNCE: {
+ case ZBLIB_ZDO_DEV_CONTROL_OPS_DEVICE_ANNOUNCE: {
zblib_check_null_ret_error("ops->device_announce",
ops->device_announce, FALSE);
}
break;
- case ZBLIB_ZDODEV_CONTROL_OPS_SIMPLE_DESC_REQ: {
+ case ZBLIB_ZDO_DEV_CONTROL_OPS_SIMPLE_DESC_REQ: {
zblib_check_null_ret_error("ops->simple_desc_req",
ops->simple_desc_req, FALSE);
}
break;
- case ZBLIB_ZDODEV_CONTROL_OPS_MGMT_LQI_REQ: {
+ case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_LQI_REQ: {
zblib_check_null_ret_error("ops->mgmt_lqi_req",
ops->mgmt_lqi_req, FALSE);
}
break;
- case ZBLIB_ZDODEV_CONTROL_OPS_MGMT_RTG_REQ: {
+ case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_RTG_REQ: {
zblib_check_null_ret_error("ops->mgmt_rtg_req",
ops->mgmt_rtg_req, FALSE);
}
break;
- case ZBLIB_ZDODEV_CONTROL_OPS_MGMT_BIND_REQ: {
+ case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_BIND_REQ: {
zblib_check_null_ret_error("ops->mgmt_bind_req",
ops->mgmt_bind_req, FALSE);
}
break;
- case ZBLIB_ZDODEV_CONTROL_OPS_MGMT_PERMIT_JOIN_REQ: {
+ case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_PERMIT_JOIN_REQ: {
zblib_check_null_ret_error("ops->mgmt_permit_join_req",
ops->mgmt_permit_join_req, FALSE);
}
break;
- case ZBLIB_ZDODEV_CONTROL_OPS_NWK_UPDATE_REQ: {
+ case ZBLIB_ZDO_DEV_CONTROL_OPS_NWK_UPDATE_REQ: {
zblib_check_null_ret_error("ops->nwk_update_req",
ops->nwk_update_req, FALSE);
}
break;
- case ZBLIB_ZDODEV_CONTROL_OPS_NWK_DISC_REQ: {
+ case ZBLIB_ZDO_DEV_CONTROL_OPS_NWK_DISC_REQ: {
zblib_check_null_ret_error("ops->nwk_disc_req",
ops->nwk_disc_req, FALSE);
static void __zblib_driver_zdo_dev_control_free_hook(ZigBeeDriver *driver)
{
- ZblibDriverZdodevControlPrivData_t *priv_data = NULL;
+ ZblibDriverZdoDevControlPrivData_t *priv_data = NULL;
zblib_check_null_ret("driver", driver);
ZigBeeDriver *zblib_driver_zdo_dev_control_new(ZigBeePlugin *plugin,
const gchar *driver_name,
- ZblibDriverZdodevControlOps_t *ops)
+ ZblibDriverZdoDevControlOps_t *ops)
{
ZigBeeDriver *driver = NULL;
- ZblibDriverZdodevControlPrivData_t *priv_data = NULL;
+ ZblibDriverZdoDevControlPrivData_t *priv_data = NULL;
gboolean ret;
zblib_check_null_ret_error("plugin", plugin, NULL);
/* Create new driver */
- driver = zblib_driver_new(plugin, driver_name, ZBLIB_DRIVER_TYPE_ZDODEV_CONTROL);
+ driver = zblib_driver_new(plugin, driver_name, ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL);
zblib_check_null_ret_error("driver", driver, NULL);
/* Allocate memory for private data */
- priv_data = g_malloc0(sizeof(ZblibDriverZdodevControlPrivData_t));
+ priv_data = g_malloc0(sizeof(ZblibDriverZdoDevControlPrivData_t));
/* Update private data */
priv_data->ops = ops;
#include <zblib_service_interface.h>
#include <zblib_driver.h>
-#include <zblib_driver_zcl_alarm.h>
#include <zblib_driver_custom.h>
-#include <zblib_driver_zcl_door_lock.h>
-#include <zblib_driver_zcl_fan_control.h>
-#include <zblib_driver_zcl_level_control.h>
#include <zblib_driver_mfglib_control.h>
-#include <zblib_driver_zcl_on_off.h>
#include <zblib_driver_service.h>
-#include <zblib_driver_zcl_thermostat.h>
+#include <zblib_driver_zcl_alarm.h>
#include <zblib_driver_zcl_basic.h>
+#include <zblib_driver_zcl_color_control.h>
+#include <zblib_driver_zcl_door_lock.h>
+#include <zblib_driver_zcl_fan_control.h>
#include <zblib_driver_zcl_global_control.h>
+#include <zblib_driver_zcl_group.h>
#include <zblib_driver_zcl_ias_zone.h>
#include <zblib_driver_zcl_identify.h>
-#include <zblib_driver_zcl_color_control.h>
-#include <zblib_driver_zcl_group.h>
+#include <zblib_driver_zcl_level_control.h>
+#include <zblib_driver_zcl_on_off.h>
#include <zblib_driver_zcl_poll_control.h>
#include <zblib_driver_zcl_scene.h>
-#include <zblib_driver_zdo_dev_control.h>
+#include <zblib_driver_zcl_thermostat.h>
#include <zblib_driver_zdo_bind.h>
+#include <zblib_driver_zdo_dev_control.h>
/**< ZigBee Request object */
struct zblib_request_type {
/* Look-up requets_id in request hash table */
request = (ZigBeeRequest *)g_hash_table_lookup(request_table, (gconstpointer)request_id);
if (NULL == request_table) {
- Z_LOGE("No request availabel for request_id: [%d]", request_id);
+ Z_LOGE("No request available for request_id: [%d]", request_id);
return NULL;
}
return request;
}
-static gpointer __zblib_request_create_alarm_request_data(guint request_type,
+static gpointer __zblib_request_create_zcl_alarm_request_data(guint request_type,
gpointer request_data, guint request_data_len)
{
gpointer alarm_request_data = NULL;
/* Fetch ops ID */
ops_id = __zblib_request_get_ops_id(request_type);
switch (ops_id) {
- case ZBLIB_ALARM_OPS_GET_ALARM_COUNT: {
- ZigbeeAlarmGetAlarmCount_t *in_req;
- ZigbeeAlarmGetAlarmCount_t *req = NULL;
+ case ZBLIB_ZCL_ALARM_OPS_GET_ALARM_COUNT: {
+ ZigbeeZclAlarmGetAlarmCount_t *in_req;
+ ZigbeeZclAlarmGetAlarmCount_t *req = NULL;
- in_req = (ZigbeeAlarmGetAlarmCount_t *)request_data;
+ in_req = (ZigbeeZclAlarmGetAlarmCount_t *)request_data;
if (NULL != in_req) {
/* Allocate memory */
- req = (ZigbeeAlarmGetAlarmCount_t *)
- g_malloc0(sizeof(ZigbeeAlarmGetAlarmCount_t));
+ req = (ZigbeeZclAlarmGetAlarmCount_t *)
+ g_malloc0(sizeof(ZigbeeZclAlarmGetAlarmCount_t));
/* Copy data */
memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
}
break;
- case ZBLIB_ALARM_OPS_RESET_ALARM: {
- ZigbeeAlarmResetAlarm_t *in_req;
- ZigbeeAlarmResetAlarm_t *req = NULL;
+ case ZBLIB_ZCL_ALARM_OPS_RESET_ALARM: {
+ ZigbeeZclAlarmResetAlarm_t *in_req;
+ ZigbeeZclAlarmResetAlarm_t *req = NULL;
- in_req = (ZigbeeAlarmResetAlarm_t *)request_data;
+ in_req = (ZigbeeZclAlarmResetAlarm_t *)request_data;
if (NULL != in_req) {
/* Allocate memory */
- req = (ZigbeeAlarmResetAlarm_t *)
- g_malloc0(sizeof(ZigbeeAlarmResetAlarm_t));
+ req = (ZigbeeZclAlarmResetAlarm_t *)
+ g_malloc0(sizeof(ZigbeeZclAlarmResetAlarm_t));
/* Copy data */
req->node_id = in_req->node_id;
}
break;
- case ZBLIB_ALARM_OPS_RESET_ALL_ALARM: {
- ZigbeeAlarmResetAllAlarm_t *in_req;
- ZigbeeAlarmResetAllAlarm_t *req = NULL;
+ case ZBLIB_ZCL_ALARM_OPS_RESET_ALL_ALARM: {
+ ZigbeeZclAlarmResetAllAlarm_t *in_req;
+ ZigbeeZclAlarmResetAllAlarm_t *req = NULL;
- in_req = (ZigbeeAlarmResetAllAlarm_t *)request_data;
+ in_req = (ZigbeeZclAlarmResetAllAlarm_t *)request_data;
if (in_req) {
/* Allocate memory */
- req = (ZigbeeAlarmResetAllAlarm_t *)
- g_malloc0(sizeof(ZigbeeAlarmResetAllAlarm_t));
+ req = (ZigbeeZclAlarmResetAllAlarm_t *)
+ g_malloc0(sizeof(ZigbeeZclAlarmResetAllAlarm_t));
/* Copy data */
req->node_id = in_req->node_id;
}
break;
- case ZBLIB_ALARM_OPS_ALARM: {
- ZigbeeAlarmAlarm_t *in_req;
- ZigbeeAlarmAlarm_t *req = NULL;
+ case ZBLIB_ZCL_ALARM_OPS_ALARM: {
+ ZigbeeZclAlarmAlarm_t *in_req;
+ ZigbeeZclAlarmAlarm_t *req = NULL;
- in_req = (ZigbeeAlarmAlarm_t *)request_data;
+ in_req = (ZigbeeZclAlarmAlarm_t *)request_data;
if (in_req) {
/* Allocate memory */
- req = (ZigbeeAlarmAlarm_t *)
- g_malloc0(sizeof(ZigbeeAlarmAlarm_t));
+ req = (ZigbeeZclAlarmAlarm_t *)
+ g_malloc0(sizeof(ZigbeeZclAlarmAlarm_t));
/* Copy data */
memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
}
break;
- case ZBLIB_ALARM_OPS_RESET_ALARM_LOG: {
- ZigbeeAlarmResetAlarmLogs_t *in_req;
- ZigbeeAlarmResetAlarmLogs_t *req = NULL;
+ case ZBLIB_ZCL_ALARM_OPS_RESET_ALARM_LOG: {
+ ZigbeeZclAlarmResetAlarmLogs_t *in_req;
+ ZigbeeZclAlarmResetAlarmLogs_t *req = NULL;
- in_req = (ZigbeeAlarmResetAlarmLogs_t *)request_data;
+ in_req = (ZigbeeZclAlarmResetAlarmLogs_t *)request_data;
if (in_req) {
/* Allocate memory */
- req = (ZigbeeAlarmResetAlarmLogs_t *)
- g_malloc0(sizeof(ZigbeeAlarmResetAlarmLogs_t));
+ req = (ZigbeeZclAlarmResetAlarmLogs_t *)
+ g_malloc0(sizeof(ZigbeeZclAlarmResetAlarmLogs_t));
/* Copy data */
req->node_id = in_req->node_id;
}
break;
- case ZBLIB_ALARM_OPS_GET_ALARM: {
+ case ZBLIB_ZCL_ALARM_OPS_GET_ALARM: {
alarm_request_data = NULL;
}
break;
return custom_request_data;
}
-static gpointer __zblib_request_create_door_lock_request_data(guint request_type,
+static gpointer __zblib_request_create_zcl_door_lock_request_data(guint request_type,
gpointer request_data, guint request_data_len)
{
gpointer door_lock_request_data = NULL;
/* Fetch ops ID */
ops_id = __zblib_request_get_ops_id(request_type);
switch (ops_id) {
- case ZBLIB_DOOR_LOCK_OPS_SUBSCRIBE_LOCK_EVENT: {
- ZigbeeDoorLockSubscriberLockEvent_t *in_req;
- ZigbeeDoorLockSubscriberLockEvent_t *req = NULL;
+ case ZBLIB_ZCL_DOOR_LOCK_OPS_SUBSCRIBE_LOCK_EVENT: {
+ ZigbeeZclDoorLockSubscriberLockEvent_t *in_req;
+ ZigbeeZclDoorLockSubscriberLockEvent_t *req = NULL;
- in_req = (ZigbeeDoorLockSubscriberLockEvent_t *)request_data;
+ in_req = (ZigbeeZclDoorLockSubscriberLockEvent_t *)request_data;
if (in_req) {
/* Allocate memory */
- req = (ZigbeeDoorLockSubscriberLockEvent_t *)
- g_malloc0(sizeof(ZigbeeDoorLockSubscriberLockEvent_t));
+ req = (ZigbeeZclDoorLockSubscriberLockEvent_t *)
+ g_malloc0(sizeof(ZigbeeZclDoorLockSubscriberLockEvent_t));
/* Copy data */
memcpy(req->eui64,
}
break;
- case ZBLIB_DOOR_LOCK_OPS_SET_DOOR_LOCK_PIN: {
- ZigbeeDoorLockSetDoorLockPin_t *in_req;
- ZigbeeDoorLockSetDoorLockPin_t *req = NULL;
+ case ZBLIB_ZCL_DOOR_LOCK_OPS_SET_DOOR_LOCK_PIN: {
+ ZigbeeZclDoorLockSetDoorLockPin_t *in_req;
+ ZigbeeZclDoorLockSetDoorLockPin_t *req = NULL;
- in_req = (ZigbeeDoorLockSetDoorLockPin_t *)request_data;
+ in_req = (ZigbeeZclDoorLockSetDoorLockPin_t *)request_data;
if (in_req) {
/* Allocate memory */
- req = (ZigbeeDoorLockSetDoorLockPin_t *)
- g_malloc0(sizeof(ZigbeeDoorLockSetDoorLockPin_t));
+ req = (ZigbeeZclDoorLockSetDoorLockPin_t *)
+ g_malloc0(sizeof(ZigbeeZclDoorLockSetDoorLockPin_t));
/* Copy data */
req->uid = in_req->uid;
}
break;
- case ZBLIB_DOOR_LOCK_OPS_SET_DOOR_LOCK: {
- ZigbeeDoorLockSetDoorLock_t *in_req;
- ZigbeeDoorLockSetDoorLock_t *req = NULL;
+ case ZBLIB_ZCL_DOOR_LOCK_OPS_SET_DOOR_LOCK: {
+ ZigbeeZclDoorLockSetDoorLock_t *in_req;
+ ZigbeeZclDoorLockSetDoorLock_t *req = NULL;
- in_req = (ZigbeeDoorLockSetDoorLock_t *)request_data;
+ in_req = (ZigbeeZclDoorLockSetDoorLock_t *)request_data;
if (in_req) {
/* Allocate memory */
- req = (ZigbeeDoorLockSetDoorLock_t *)
- g_malloc0(sizeof(ZigbeeDoorLockSetDoorLock_t));
+ req = (ZigbeeZclDoorLockSetDoorLock_t *)
+ g_malloc0(sizeof(ZigbeeZclDoorLockSetDoorLock_t));
/* Copy data */
memcpy(req->eui64,
}
break;
- case ZBLIB_DOOR_LOCK_OPS_GET_LOCK_STATE: {
- ZigbeeDoorLockGetDoorLock_t *in_req;
- ZigbeeDoorLockGetDoorLock_t *req = NULL;
+ case ZBLIB_ZCL_DOOR_LOCK_OPS_GET_LOCK_STATE: {
+ ZigbeeZclDoorLockGetDoorLock_t *in_req;
+ ZigbeeZclDoorLockGetDoorLock_t *req = NULL;
- in_req = (ZigbeeDoorLockGetDoorLock_t *)request_data;
+ in_req = (ZigbeeZclDoorLockGetDoorLock_t *)request_data;
if (in_req) {
/* Allocate memory */
- req = (ZigbeeDoorLockGetDoorLock_t *)
- g_malloc0(sizeof(ZigbeeDoorLockGetDoorLock_t));
+ req = (ZigbeeZclDoorLockGetDoorLock_t *)
+ g_malloc0(sizeof(ZigbeeZclDoorLockGetDoorLock_t));
/* Copy data */
memcpy(req->eui64,
return door_lock_request_data;
}
-static gpointer __zblib_request_create_fan_control_request_data(guint request_type,
+static gpointer __zblib_request_create_zcl_fan_control_request_data(guint request_type,
gpointer request_data, guint request_data_len)
{
gpointer fan_control_request_data = NULL;
/* Fetch ops ID */
ops_id = __zblib_request_get_ops_id(request_type);
switch (ops_id) {
- case ZBLIB_FAN_CONTROL_OPS_SET_FAN_MODE: {
- ZigbeeFanControlSetFanMode_t *in_req;
- ZigbeeFanControlSetFanMode_t *req = NULL;
+ case ZBLIB_ZCL_FAN_CONTROL_OPS_SET_FAN_MODE: {
+ ZigbeeZclFanControlSetFanMode_t *in_req;
+ ZigbeeZclFanControlSetFanMode_t *req = NULL;
- in_req = (ZigbeeFanControlSetFanMode_t *)request_data;
+ in_req = (ZigbeeZclFanControlSetFanMode_t *)request_data;
if (in_req) {
/* Allocate memory */
- req = (ZigbeeFanControlSetFanMode_t *)
- g_malloc0(sizeof(ZigbeeFanControlSetFanMode_t));
+ req = (ZigbeeZclFanControlSetFanMode_t *)
+ g_malloc0(sizeof(ZigbeeZclFanControlSetFanMode_t));
/* Copy data */
memcpy(req->eui64,
}
break;
- case ZBLIB_FAN_CONTROL_OPS_GET_FAN_MODE: {
- ZigbeeFanControlGetFanMode_t *in_req;
- ZigbeeFanControlGetFanMode_t *req = NULL;
+ case ZBLIB_ZCL_FAN_CONTROL_OPS_GET_FAN_MODE: {
+ ZigbeeZclFanControlGetFanMode_t *in_req;
+ ZigbeeZclFanControlGetFanMode_t *req = NULL;
- in_req = (ZigbeeFanControlGetFanMode_t *)request_data;
+ in_req = (ZigbeeZclFanControlGetFanMode_t *)request_data;
if (in_req) {
/* Allocate memory */
- req = (ZigbeeFanControlGetFanMode_t *)
- g_malloc0(sizeof(ZigbeeFanControlGetFanMode_t));
+ req = (ZigbeeZclFanControlGetFanMode_t *)
+ g_malloc0(sizeof(ZigbeeZclFanControlGetFanMode_t));
/* Copy data */
memcpy(req->eui64,
}
break;
- case ZBLIB_FAN_CONTROL_OPS_SET_FAN_MODE_SEQUENCE: {
- ZigbeeFanControlSetFanModeSequence_t *in_req;
- ZigbeeFanControlSetFanModeSequence_t *req = NULL;
+ case ZBLIB_ZCL_FAN_CONTROL_OPS_SET_FAN_MODE_SEQUENCE: {
+ ZigbeeZclFanControlSetFanModeSequence_t *in_req;
+ ZigbeeZclFanControlSetFanModeSequence_t *req = NULL;
- in_req = (ZigbeeFanControlSetFanModeSequence_t *)request_data;
+ in_req = (ZigbeeZclFanControlSetFanModeSequence_t *)request_data;
if (in_req) {
/* Allocate memory */
- req = (ZigbeeFanControlSetFanModeSequence_t *)
- g_malloc0(sizeof(ZigbeeFanControlSetFanModeSequence_t));
+ req = (ZigbeeZclFanControlSetFanModeSequence_t *)
+ g_malloc0(sizeof(ZigbeeZclFanControlSetFanModeSequence_t));
/* Copy data */
memcpy(req->eui64,
}
break;
- case ZBLIB_FAN_CONTROL_OPS_GET_FAN_MODE_SEQUENCE: {
- ZigbeeFanControlGetFanModeSequence_t *in_req;
- ZigbeeFanControlGetFanModeSequence_t *req = NULL;
+ case ZBLIB_ZCL_FAN_CONTROL_OPS_GET_FAN_MODE_SEQUENCE: {
+ ZigbeeZclFanControlGetFanModeSequence_t *in_req;
+ ZigbeeZclFanControlGetFanModeSequence_t *req = NULL;
- in_req = (ZigbeeFanControlGetFanModeSequence_t *)request_data;
+ in_req = (ZigbeeZclFanControlGetFanModeSequence_t *)request_data;
if (in_req) {
/* Allocate memory */
- req = (ZigbeeFanControlGetFanModeSequence_t *)
- g_malloc0(sizeof(ZigbeeFanControlGetFanModeSequence_t));
+ req = (ZigbeeZclFanControlGetFanModeSequence_t *)
+ g_malloc0(sizeof(ZigbeeZclFanControlGetFanModeSequence_t));
/* Copy data */
memcpy(req->eui64,
return fan_control_request_data;
}
-static gpointer __zblib_request_create_level_control_request_data(guint request_type,
+static gpointer __zblib_request_create_zcl_level_control_request_data(guint request_type,
gpointer request_data, guint request_data_len)
{
gpointer level_control_request_data = NULL;
/* Fetch ops ID */
ops_id = __zblib_request_get_ops_id(request_type);
switch (ops_id) {
- case ZBLIB_LEVEL_CONTROL_OPS_MOVE_TO_LEVEL: {
- ZigbeeLevelControlMoveToLevel_t *in_req;
- ZigbeeLevelControlMoveToLevel_t *req = NULL;
+ case ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE_TO_LEVEL: {
+ ZigbeeZclLevelControlMoveToLevel_t *in_req;
+ ZigbeeZclLevelControlMoveToLevel_t *req = NULL;
- in_req = (ZigbeeLevelControlMoveToLevel_t *)request_data;
+ in_req = (ZigbeeZclLevelControlMoveToLevel_t *)request_data;
if (in_req) {
/* Allocate memory */
- req = (ZigbeeLevelControlMoveToLevel_t *)
- g_malloc0(sizeof(ZigbeeLevelControlMoveToLevel_t));
+ req = (ZigbeeZclLevelControlMoveToLevel_t *)
+ g_malloc0(sizeof(ZigbeeZclLevelControlMoveToLevel_t));
/* Copy data */
req->node_id = in_req->node_id;
}
break;
- case ZBLIB_LEVEL_CONTROL_OPS_MOVE: {
- ZigbeeLevelControlMove_t *in_req;
- ZigbeeLevelControlMove_t *req = NULL;
+ case ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE: {
+ ZigbeeZclLevelControlMove_t *in_req;
+ ZigbeeZclLevelControlMove_t *req = NULL;
- in_req = (ZigbeeLevelControlMove_t *)request_data;
+ in_req = (ZigbeeZclLevelControlMove_t *)request_data;
if (in_req) {
/* Allocate memory */
- req = (ZigbeeLevelControlMove_t *)
- g_malloc0(sizeof(ZigbeeLevelControlMove_t));
+ req = (ZigbeeZclLevelControlMove_t *)
+ g_malloc0(sizeof(ZigbeeZclLevelControlMove_t));
/* Copy data */
req->node_id = in_req->node_id;
}
break;
- case ZBLIB_LEVEL_CONTROL_OPS_STEP: {
- ZigbeeLevelControlStep_t *in_req;
- ZigbeeLevelControlStep_t *req = NULL;
+ case ZBLIB_ZCL_LEVEL_CONTROL_OPS_STEP: {
+ ZigbeeZclLevelControlStep_t *in_req;
+ ZigbeeZclLevelControlStep_t *req = NULL;
- in_req = (ZigbeeLevelControlStep_t *)request_data;
+ in_req = (ZigbeeZclLevelControlStep_t *)request_data;
if (in_req) {
/* Allocate memory */
- req = (ZigbeeLevelControlStep_t *)
- g_malloc0(sizeof(ZigbeeLevelControlStep_t));
+ req = (ZigbeeZclLevelControlStep_t *)
+ g_malloc0(sizeof(ZigbeeZclLevelControlStep_t));
/* Copy data */
req->node_id = in_req->node_id;
}
break;
- case ZBLIB_LEVEL_CONTROL_OPS_MOVE_TO_LEVEL_WITH_ON_OFF: {
- ZigbeeLevelControlMoveToLevelWithOnOff_t *in_req;
- ZigbeeLevelControlMoveToLevelWithOnOff_t *req = NULL;
+ case ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE_TO_LEVEL_WITH_ON_OFF: {
+ ZigbeeZclLevelControlMoveToLevelWithOnOff_t *in_req;
+ ZigbeeZclLevelControlMoveToLevelWithOnOff_t *req = NULL;
- in_req = (ZigbeeLevelControlMoveToLevelWithOnOff_t *)request_data;
+ in_req = (ZigbeeZclLevelControlMoveToLevelWithOnOff_t *)request_data;
if (in_req) {
/* Allocate memory */
- req = (ZigbeeLevelControlMoveToLevelWithOnOff_t *)
- g_malloc0(sizeof(ZigbeeLevelControlMoveToLevelWithOnOff_t));
+ req = (ZigbeeZclLevelControlMoveToLevelWithOnOff_t *)
+ g_malloc0(sizeof(ZigbeeZclLevelControlMoveToLevelWithOnOff_t));
/* Copy data */
req->node_id = in_req->node_id;
}
break;
- case ZBLIB_LEVEL_CONTROL_OPS_MOVE_WITH_ON_OFF: {
- ZigbeeLevelControlMoveWithOnOff_t *in_req;
- ZigbeeLevelControlMoveWithOnOff_t *req = NULL;
+ case ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE_WITH_ON_OFF: {
+ ZigbeeZclLevelControlMoveWithOnOff_t *in_req;
+ ZigbeeZclLevelControlMoveWithOnOff_t *req = NULL;
- in_req = (ZigbeeLevelControlMoveWithOnOff_t *)request_data;
+ in_req = (ZigbeeZclLevelControlMoveWithOnOff_t *)request_data;
if (in_req) {
/* Allocate memory */
- req = (ZigbeeLevelControlMoveWithOnOff_t *)
- g_malloc0(sizeof(ZigbeeLevelControlMoveWithOnOff_t));
+ req = (ZigbeeZclLevelControlMoveWithOnOff_t *)
+ g_malloc0(sizeof(ZigbeeZclLevelControlMoveWithOnOff_t));
/* Copy data */
req->node_id = in_req->node_id;
}
break;
- case ZBLIB_LEVEL_CONTROL_OPS_STEP_WITH_ON_OFF: {
- ZigbeeLevelControlStepWithOnOff_t *in_req;
- ZigbeeLevelControlStepWithOnOff_t *req = NULL;
+ case ZBLIB_ZCL_LEVEL_CONTROL_OPS_STEP_WITH_ON_OFF: {
+ ZigbeeZclLevelControlStepWithOnOff_t *in_req;
+ ZigbeeZclLevelControlStepWithOnOff_t *req = NULL;
- in_req = (ZigbeeLevelControlStepWithOnOff_t *)request_data;
+ in_req = (ZigbeeZclLevelControlStepWithOnOff_t *)request_data;
if (in_req) {
/* Allocate memory */
- req = (ZigbeeLevelControlStepWithOnOff_t *)
- g_malloc0(sizeof(ZigbeeLevelControlStepWithOnOff_t));
+ req = (ZigbeeZclLevelControlStepWithOnOff_t *)
+ g_malloc0(sizeof(ZigbeeZclLevelControlStepWithOnOff_t));
/* Copy data */
req->node_id = in_req->node_id;
}
break;
- case ZBLIB_LEVEL_CONTROL_OPS_STOP: {
- ZigbeeLevelControlStop_t *in_req;
- ZigbeeLevelControlStop_t *req = NULL;
+ case ZBLIB_ZCL_LEVEL_CONTROL_OPS_STOP: {
+ ZigbeeZclLevelControlStop_t *in_req;
+ ZigbeeZclLevelControlStop_t *req = NULL;
- in_req = (ZigbeeLevelControlStop_t *)request_data;
+ in_req = (ZigbeeZclLevelControlStop_t *)request_data;
if (in_req) {
/* Allocate memory */
- req = (ZigbeeLevelControlStop_t *)
- g_malloc0(sizeof(ZigbeeLevelControlStop_t));
+ req = (ZigbeeZclLevelControlStop_t *)
+ g_malloc0(sizeof(ZigbeeZclLevelControlStop_t));
/* Copy data */
req->node_id = in_req->node_id;
return mfglib_control_request_data;
}
-static gpointer __zblib_request_create_on_off_request_data(guint request_type,
+static gpointer __zblib_request_create_zcl_on_off_request_data(guint request_type,
gpointer request_data, guint request_data_len)
{
gpointer on_off_request_data = NULL;
/* Fetch ops ID */
ops_id = __zblib_request_get_ops_id(request_type);
switch (ops_id) {
- case ZBLIB_ON_OFF_OPS_SET_ON_OFF: {
- ZigbeeOnOffSetOnOff_t *in_req;
- ZigbeeOnOffSetOnOff_t *req = NULL;
+ case ZBLIB_ZCL_ON_OFF_OPS_SET_ON_OFF: {
+ ZigbeeZclOnOffSetOnOff_t *in_req;
+ ZigbeeZclOnOffSetOnOff_t *req = NULL;
- in_req = (ZigbeeOnOffSetOnOff_t *)request_data;
+ in_req = (ZigbeeZclOnOffSetOnOff_t *)request_data;
if (NULL != in_req) {
/* Allocate memory */
- req = (ZigbeeOnOffSetOnOff_t *)
- g_malloc0(sizeof(ZigbeeOnOffSetOnOff_t));
+ req = (ZigbeeZclOnOffSetOnOff_t *)
+ g_malloc0(sizeof(ZigbeeZclOnOffSetOnOff_t));
/* Copy data */
req->node_id = in_req->node_id;
}
break;
- case ZBLIB_ON_OFF_OPS_GET_ON_OFF_STATE: {
- ZigbeeOnOffGetOnOffState_t *in_req;
- ZigbeeOnOffGetOnOffState_t *req = NULL;
+ case ZBLIB_ZCL_ON_OFF_OPS_GET_ON_OFF_STATE: {
+ ZigbeeZclOnOffGetOnOffState_t *in_req;
+ ZigbeeZclOnOffGetOnOffState_t *req = NULL;
- in_req = (ZigbeeOnOffGetOnOffState_t *)request_data;
+ in_req = (ZigbeeZclOnOffGetOnOffState_t *)request_data;
if (NULL != in_req) {
/* Allocate memory */
- req = (ZigbeeOnOffGetOnOffState_t *)
- g_malloc0(sizeof(ZigbeeOnOffGetOnOffState_t));
+ req = (ZigbeeZclOnOffGetOnOffState_t *)
+ g_malloc0(sizeof(ZigbeeZclOnOffGetOnOffState_t));
/* Copy data */
req->node_id = in_req->node_id;
return service_request_data;
}
-static gpointer __zblib_request_create_thermostat_request_data(guint request_type,
+static gpointer __zblib_request_create_zcl_thermostat_request_data(guint request_type,
gpointer request_data, guint request_data_len)
{
gpointer thermostat_request_data = NULL;
/* Fetch ops ID */
ops_id = __zblib_request_get_ops_id(request_type);
switch (ops_id) {
- case ZBLIB_THERMOSTAT_OPS_GET_LOCAL_TEMP: {
- ZigbeeThermostatGetLocalTemp_t *in_req;
- ZigbeeThermostatGetLocalTemp_t *req = NULL;
+ case ZBLIB_ZCL_THERMOSTAT_OPS_GET_LOCAL_TEMP: {
+ ZigbeeZclThermostatGetLocalTemp_t *in_req;
+ ZigbeeZclThermostatGetLocalTemp_t *req = NULL;
- in_req = (ZigbeeThermostatGetLocalTemp_t *)request_data;
+ in_req = (ZigbeeZclThermostatGetLocalTemp_t *)request_data;
if (NULL != in_req) {
/* Allocate memory */
- req = (ZigbeeThermostatGetLocalTemp_t *)
- g_malloc0(sizeof(ZigbeeThermostatGetLocalTemp_t));
+ req = (ZigbeeZclThermostatGetLocalTemp_t *)
+ g_malloc0(sizeof(ZigbeeZclThermostatGetLocalTemp_t));
/* Copy data */
memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
}
break;
- case ZBLIB_THERMOSTAT_OPS_GET_WEEKLY_SCHEDULE: {
- ZigbeeThermostatGetWeeklySchedule_t *in_req;
- ZigbeeThermostatGetWeeklySchedule_t *req = NULL;
+ case ZBLIB_ZCL_THERMOSTAT_OPS_GET_WEEKLY_SCHEDULE: {
+ ZigbeeZclThermostatGetWeeklySchedule_t *in_req;
+ ZigbeeZclThermostatGetWeeklySchedule_t *req = NULL;
- in_req = (ZigbeeThermostatGetWeeklySchedule_t *)request_data;
+ in_req = (ZigbeeZclThermostatGetWeeklySchedule_t *)request_data;
if (NULL != in_req) {
/* Allocate memory */
- req = (ZigbeeThermostatGetWeeklySchedule_t *)
- g_malloc0(sizeof(ZigbeeThermostatGetWeeklySchedule_t));
+ req = (ZigbeeZclThermostatGetWeeklySchedule_t *)
+ g_malloc0(sizeof(ZigbeeZclThermostatGetWeeklySchedule_t));
/* Copy data */
memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
}
break;
- case ZBLIB_THERMOSTAT_OPS_SET_WEEKLY_SCHEDULE: {
- ZigbeeThermostatSetWeeklySchedule_t *in_req;
- ZigbeeThermostatSetWeeklySchedule_t *req = NULL;
+ case ZBLIB_ZCL_THERMOSTAT_OPS_SET_WEEKLY_SCHEDULE: {
+ ZigbeeZclThermostatSetWeeklySchedule_t *in_req;
+ ZigbeeZclThermostatSetWeeklySchedule_t *req = NULL;
- in_req = (ZigbeeThermostatSetWeeklySchedule_t *)request_data;
+ in_req = (ZigbeeZclThermostatSetWeeklySchedule_t *)request_data;
if (NULL != in_req) {
/* Allocate memory */
- req = (ZigbeeThermostatSetWeeklySchedule_t *)
- g_malloc0(sizeof(ZigbeeThermostatSetWeeklySchedule_t));
+ req = (ZigbeeZclThermostatSetWeeklySchedule_t *)
+ g_malloc0(sizeof(ZigbeeZclThermostatSetWeeklySchedule_t));
/* Copy data */
memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
}
break;
- case ZBLIB_THERMOSTAT_OPS_CLEAR_WEEKLY_SCHEDULE: {
- ZigbeeThermostatClearWeeklySchedule_t *in_req;
- ZigbeeThermostatClearWeeklySchedule_t *req = NULL;
+ case ZBLIB_ZCL_THERMOSTAT_OPS_CLEAR_WEEKLY_SCHEDULE: {
+ ZigbeeZclThermostatClearWeeklySchedule_t *in_req;
+ ZigbeeZclThermostatClearWeeklySchedule_t *req = NULL;
- in_req = (ZigbeeThermostatClearWeeklySchedule_t *)request_data;
+ in_req = (ZigbeeZclThermostatClearWeeklySchedule_t *)request_data;
if (NULL != in_req) {
/* Allocate memory */
- req = (ZigbeeThermostatClearWeeklySchedule_t *)
- g_malloc0(sizeof(ZigbeeThermostatClearWeeklySchedule_t));
+ req = (ZigbeeZclThermostatClearWeeklySchedule_t *)
+ g_malloc0(sizeof(ZigbeeZclThermostatClearWeeklySchedule_t));
/* Copy data */
memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
}
break;
- case ZBLIB_THERMOSTAT_OPS_SETPOINT_RAISE_LOWER: {
- ZigbeeThermostatSetpointRaiseLower_t *in_req;
- ZigbeeThermostatSetpointRaiseLower_t *req = NULL;
+ case ZBLIB_ZCL_THERMOSTAT_OPS_SETPOINT_RAISE_LOWER: {
+ ZigbeeZclThermostatSetpointRaiseLower_t *in_req;
+ ZigbeeZclThermostatSetpointRaiseLower_t *req = NULL;
- in_req = (ZigbeeThermostatSetpointRaiseLower_t *)request_data;
+ in_req = (ZigbeeZclThermostatSetpointRaiseLower_t *)request_data;
if (NULL != in_req) {
/* Allocate memory */
- req = (ZigbeeThermostatSetpointRaiseLower_t *)
- g_malloc0(sizeof(ZigbeeThermostatSetpointRaiseLower_t));
+ req = (ZigbeeZclThermostatSetpointRaiseLower_t *)
+ g_malloc0(sizeof(ZigbeeZclThermostatSetpointRaiseLower_t));
/* Copy data */
req->node_id = in_req->node_id;
return thermostat_request_data;
}
-static gpointer __zblib_request_create_zclbasic_control_request_data(guint request_type,
+static gpointer __zblib_request_create_zcl_basic_request_data(guint request_type,
gpointer request_data, guint request_data_len)
{
gpointer zclbasic_control_request_data = NULL;
/* Fetch ops ID */
ops_id = __zblib_request_get_ops_id(request_type);
switch (ops_id) {
- case ZBLIB_ZCLBASIC_CONTROL_OPS_RESET_FACTORY_DEFAULT: {
- ZigbeeZclbasicControlResetFactoryDefault_t *in_req;
- ZigbeeZclbasicControlResetFactoryDefault_t *req = NULL;
+ case ZBLIB_ZCL_BASIC_OPS_RESET_FACTORY_DEFAULT: {
+ ZigbeeZclBasicResetFactoryDefault_t *in_req;
+ ZigbeeZclBasicResetFactoryDefault_t *req = NULL;
- in_req = (ZigbeeZclbasicControlResetFactoryDefault_t *)request_data;
+ in_req = (ZigbeeZclBasicResetFactoryDefault_t *)request_data;
if (NULL != in_req) {
/* Allocate memory */
- req = (ZigbeeZclbasicControlResetFactoryDefault_t *)
- g_malloc0(sizeof(ZigbeeZclbasicControlResetFactoryDefault_t));
+ req = (ZigbeeZclBasicResetFactoryDefault_t *)
+ g_malloc0(sizeof(ZigbeeZclBasicResetFactoryDefault_t));
/* Copy data */
req->node_id = in_req->node_id;
return zclbasic_control_request_data;
}
-static gpointer __zblib_request_create_zclglobal_control_request_data(guint request_type,
+static gpointer __zblib_request_create_zcl_global_control_request_data(guint request_type,
gpointer request_data, guint request_data_len)
{
gpointer zclglobal_control_request_data = NULL;
/* Fetch ops ID */
ops_id = __zblib_request_get_ops_id(request_type);
switch (ops_id) {
- case ZBLIB_ZCLGLOBAL_CONTROL_OPS_READ_ATTRIBUTES_REQ: {
- ZigbeeZclglobalControlReadAttributesRequest_t *in_req;
- ZigbeeZclglobalControlReadAttributesRequest_t *req = NULL;
+ case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_READ_ATTRIBUTES_REQ: {
+ ZigbeeZclGlobalControlReadAttributesRequest_t *in_req;
+ ZigbeeZclGlobalControlReadAttributesRequest_t *req = NULL;
- in_req = (ZigbeeZclglobalControlReadAttributesRequest_t *)request_data;
+ in_req = (ZigbeeZclGlobalControlReadAttributesRequest_t *)request_data;
if (NULL != in_req) {
/* Allocate memory */
- req = (ZigbeeZclglobalControlReadAttributesRequest_t *)
- g_malloc0(sizeof(ZigbeeZclglobalControlReadAttributesRequest_t));
+ req = (ZigbeeZclGlobalControlReadAttributesRequest_t *)
+ g_malloc0(sizeof(ZigbeeZclGlobalControlReadAttributesRequest_t));
/* Copy data */
req->attribute_id = g_strdup(in_req->attribute_id);
}
break;
- case ZBLIB_ZCLGLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_REQ: {
- ZigbeeZclglobalControlWriteAttributesRequest_t *in_req;
- ZigbeeZclglobalControlWriteAttributesRequest_t *req = NULL;
+ case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_REQ: {
+ ZigbeeZclGlobalControlWriteAttributesRequest_t *in_req;
+ ZigbeeZclGlobalControlWriteAttributesRequest_t *req = NULL;
- in_req = (ZigbeeZclglobalControlWriteAttributesRequest_t *)request_data;
+ in_req = (ZigbeeZclGlobalControlWriteAttributesRequest_t *)request_data;
if (NULL != in_req) {
/* Allocate memory */
- req = (ZigbeeZclglobalControlWriteAttributesRequest_t *)
- g_malloc0(sizeof(ZigbeeZclglobalControlWriteAttributesRequest_t));
+ req = (ZigbeeZclGlobalControlWriteAttributesRequest_t *)
+ g_malloc0(sizeof(ZigbeeZclGlobalControlWriteAttributesRequest_t));
/* Copy data */
req->write_records = g_strdup(in_req->write_records);
}
break;
- case ZBLIB_ZCLGLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_UNDIVIDED_REQ: {
- ZigbeeZclglobalControlWriteAttributesUndividedRequest_t *in_req;
- ZigbeeZclglobalControlWriteAttributesUndividedRequest_t *req = NULL;
+ case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_UNDIVIDED_REQ: {
+ ZigbeeZclGlobalControlWriteAttributesUndividedRequest_t *in_req;
+ ZigbeeZclGlobalControlWriteAttributesUndividedRequest_t *req = NULL;
- in_req = (ZigbeeZclglobalControlWriteAttributesUndividedRequest_t *)request_data;
+ in_req = (ZigbeeZclGlobalControlWriteAttributesUndividedRequest_t *)request_data;
if (NULL != in_req) {
/* Allocate memory */
- req = (ZigbeeZclglobalControlWriteAttributesUndividedRequest_t *)
- g_malloc0(sizeof(ZigbeeZclglobalControlWriteAttributesUndividedRequest_t));
+ req = (ZigbeeZclGlobalControlWriteAttributesUndividedRequest_t *)
+ g_malloc0(sizeof(ZigbeeZclGlobalControlWriteAttributesUndividedRequest_t));
/* Copy data */
req->write_records = g_strdup(in_req->write_records);
}
break;
- case ZBLIB_ZCLGLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_NO_RESP: {
- ZigbeeZclglobalControlWriteAttributesNoResponse_t *in_req;
- ZigbeeZclglobalControlWriteAttributesNoResponse_t *req = NULL;
+ case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_NO_RESP: {
+ ZigbeeZclGlobalControlWriteAttributesNoResponse_t *in_req;
+ ZigbeeZclGlobalControlWriteAttributesNoResponse_t *req = NULL;
- in_req = (ZigbeeZclglobalControlWriteAttributesNoResponse_t *)request_data;
+ in_req = (ZigbeeZclGlobalControlWriteAttributesNoResponse_t *)request_data;
if (NULL != in_req) {
/* Allocate memory */
- req = (ZigbeeZclglobalControlWriteAttributesNoResponse_t *)
- g_malloc0(sizeof(ZigbeeZclglobalControlWriteAttributesNoResponse_t));
+ req = (ZigbeeZclGlobalControlWriteAttributesNoResponse_t *)
+ g_malloc0(sizeof(ZigbeeZclGlobalControlWriteAttributesNoResponse_t));
/* Copy data */
req->write_records = g_strdup(in_req->write_records);
}
break;
- case ZBLIB_ZCLGLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_STRUCTURED: {
- ZigbeeZclglobalControlWriteAttributesStructed_t *in_req;
- ZigbeeZclglobalControlWriteAttributesStructed_t *req = NULL;
+ case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_STRUCTURED: {
+ ZigbeeZclGlobalControlWriteAttributesStructed_t *in_req;
+ ZigbeeZclGlobalControlWriteAttributesStructed_t *req = NULL;
- in_req = (ZigbeeZclglobalControlWriteAttributesStructed_t *)request_data;
+ in_req = (ZigbeeZclGlobalControlWriteAttributesStructed_t *)request_data;
if (NULL != in_req) {
/* Allocate memory */
- req = (ZigbeeZclglobalControlWriteAttributesStructed_t *)
- g_malloc0(sizeof(ZigbeeZclglobalControlWriteAttributesStructed_t));
+ req = (ZigbeeZclGlobalControlWriteAttributesStructed_t *)
+ g_malloc0(sizeof(ZigbeeZclGlobalControlWriteAttributesStructed_t));
/* Copy data */
req->write_records = g_strdup(in_req->write_records);
}
break;
- case ZBLIB_ZCLGLOBAL_CONTROL_OPS_READ_ATTRIBUTES_STRUCTURED: {
- ZigbeeZclglobalControlReadAttributesStructed_t *in_req;
- ZigbeeZclglobalControlReadAttributesStructed_t *req = NULL;
+ case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_READ_ATTRIBUTES_STRUCTURED: {
+ ZigbeeZclGlobalControlReadAttributesStructed_t *in_req;
+ ZigbeeZclGlobalControlReadAttributesStructed_t *req = NULL;
- in_req = (ZigbeeZclglobalControlReadAttributesStructed_t *)request_data;
+ in_req = (ZigbeeZclGlobalControlReadAttributesStructed_t *)request_data;
if (NULL != in_req) {
/* Allocate memory */
- req = (ZigbeeZclglobalControlReadAttributesStructed_t *)
- g_malloc0(sizeof(ZigbeeZclglobalControlReadAttributesStructed_t));
+ req = (ZigbeeZclGlobalControlReadAttributesStructed_t *)
+ g_malloc0(sizeof(ZigbeeZclGlobalControlReadAttributesStructed_t));
/* Copy data */
req->read_records = g_strdup(in_req->read_records);
}
break;
- case ZBLIB_ZCLGLOBAL_CONTROL_OPS_CONFIGURE_REPORTING_REQ: {
- ZigbeeZclglobalControlConfigureReportingReq_t *in_req;
- ZigbeeZclglobalControlConfigureReportingReq_t *req = NULL;
+ case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_CONFIGURE_REPORTING_REQ: {
+ ZigbeeZclGlobalControlConfigureReportingReq_t *in_req;
+ ZigbeeZclGlobalControlConfigureReportingReq_t *req = NULL;
- in_req = (ZigbeeZclglobalControlConfigureReportingReq_t *)request_data;
+ in_req = (ZigbeeZclGlobalControlConfigureReportingReq_t *)request_data;
if (NULL != in_req) {
/* Allocate memory */
- req = (ZigbeeZclglobalControlConfigureReportingReq_t *)
- g_malloc0(sizeof(ZigbeeZclglobalControlConfigureReportingReq_t));
+ req = (ZigbeeZclGlobalControlConfigureReportingReq_t *)
+ g_malloc0(sizeof(ZigbeeZclGlobalControlConfigureReportingReq_t));
/* Copy data */
req->read_records = g_strdup(in_req->read_records);
}
break;
- case ZBLIB_ZCLGLOBAL_CONTROL_OPS_READ_CONFIGURE_REPORTING: {
- ZigbeeZclglobalControlReadConfigureReporting_t *in_req;
- ZigbeeZclglobalControlReadConfigureReporting_t *req = NULL;
+ case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_READ_CONFIGURE_REPORTING: {
+ ZigbeeZclGlobalControlReadConfigureReporting_t *in_req;
+ ZigbeeZclGlobalControlReadConfigureReporting_t *req = NULL;
- in_req = (ZigbeeZclglobalControlReadConfigureReporting_t *)request_data;
+ in_req = (ZigbeeZclGlobalControlReadConfigureReporting_t *)request_data;
if (NULL != in_req) {
/* Allocate memory */
- req = (ZigbeeZclglobalControlReadConfigureReporting_t *)
- g_malloc0(sizeof(ZigbeeZclglobalControlReadConfigureReporting_t));
+ req = (ZigbeeZclGlobalControlReadConfigureReporting_t *)
+ g_malloc0(sizeof(ZigbeeZclGlobalControlReadConfigureReporting_t));
/* Copy data */
req->read_records = g_strdup(in_req->read_records);
}
break;
- case ZBLIB_ZCLGLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES: {
- ZigbeeZclglobalControlDiscoverAttributes_t *in_req;
- ZigbeeZclglobalControlDiscoverAttributes_t *req = NULL;
+ case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES: {
+ ZigbeeZclGlobalControlDiscoverAttributes_t *in_req;
+ ZigbeeZclGlobalControlDiscoverAttributes_t *req = NULL;
- in_req = (ZigbeeZclglobalControlDiscoverAttributes_t *)request_data;
+ in_req = (ZigbeeZclGlobalControlDiscoverAttributes_t *)request_data;
if (NULL != in_req) {
/* Allocate memory */
- req = (ZigbeeZclglobalControlDiscoverAttributes_t *)
- g_malloc0(sizeof(ZigbeeZclglobalControlDiscoverAttributes_t));
+ req = (ZigbeeZclGlobalControlDiscoverAttributes_t *)
+ g_malloc0(sizeof(ZigbeeZclGlobalControlDiscoverAttributes_t));
/* Copy data */
req->node_id = in_req->node_id;
}
break;
- case ZBLIB_ZCLGLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES_EXTENDED: {
- ZigbeeZclglobalControlDiscoverAttributesExtended_t *in_req;
- ZigbeeZclglobalControlDiscoverAttributesExtended_t *req = NULL;
+ case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES_EXTENDED: {
+ ZigbeeZclGlobalControlDiscoverAttributesExtended_t *in_req;
+ ZigbeeZclGlobalControlDiscoverAttributesExtended_t *req = NULL;
- in_req = (ZigbeeZclglobalControlDiscoverAttributesExtended_t *)request_data;
+ in_req = (ZigbeeZclGlobalControlDiscoverAttributesExtended_t *)request_data;
if (NULL != in_req) {
/* Allocate memory */
- req = (ZigbeeZclglobalControlDiscoverAttributesExtended_t *)
- g_malloc0(sizeof(ZigbeeZclglobalControlDiscoverAttributesExtended_t));
+ req = (ZigbeeZclGlobalControlDiscoverAttributesExtended_t *)
+ g_malloc0(sizeof(ZigbeeZclGlobalControlDiscoverAttributesExtended_t));
/* Copy data */
req->node_id = in_req->node_id;
}
break;
- case ZBLIB_ZCLGLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_RECEIVED: {
- ZigbeeZclglobalControlDiscoverCommandsReceived_t *in_req;
- ZigbeeZclglobalControlDiscoverCommandsReceived_t *req = NULL;
+ case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_RECEIVED: {
+ ZigbeeZclGlobalControlDiscoverCommandsReceived_t *in_req;
+ ZigbeeZclGlobalControlDiscoverCommandsReceived_t *req = NULL;
- in_req = (ZigbeeZclglobalControlDiscoverCommandsReceived_t *)request_data;
+ in_req = (ZigbeeZclGlobalControlDiscoverCommandsReceived_t *)request_data;
if (NULL != in_req) {
/* Allocate memory */
- req = (ZigbeeZclglobalControlDiscoverCommandsReceived_t *)
- g_malloc0(sizeof(ZigbeeZclglobalControlDiscoverCommandsReceived_t));
+ req = (ZigbeeZclGlobalControlDiscoverCommandsReceived_t *)
+ g_malloc0(sizeof(ZigbeeZclGlobalControlDiscoverCommandsReceived_t));
/* Copy data */
req->node_id = in_req->node_id;
}
break;
- case ZBLIB_ZCLGLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_GENERATED: {
- ZigbeeZclglobalControlDiscoverCommandsGenerated_t *in_req;
- ZigbeeZclglobalControlDiscoverCommandsGenerated_t *req = NULL;
+ case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_GENERATED: {
+ ZigbeeZclGlobalControlDiscoverCommandsGenerated_t *in_req;
+ ZigbeeZclGlobalControlDiscoverCommandsGenerated_t *req = NULL;
- in_req = (ZigbeeZclglobalControlDiscoverCommandsGenerated_t *)request_data;
+ in_req = (ZigbeeZclGlobalControlDiscoverCommandsGenerated_t *)request_data;
if (NULL != in_req) {
/* Allocate memory */
- req = (ZigbeeZclglobalControlDiscoverCommandsGenerated_t *)
- g_malloc0(sizeof(ZigbeeZclglobalControlDiscoverCommandsGenerated_t));
+ req = (ZigbeeZclGlobalControlDiscoverCommandsGenerated_t *)
+ g_malloc0(sizeof(ZigbeeZclGlobalControlDiscoverCommandsGenerated_t));
/* Copy data */
req->node_id = in_req->node_id;
return zclglobal_control_request_data;
}
-static gpointer __zblib_request_create_zclias_control_request_data(guint request_type,
+static gpointer __zblib_request_create_zcl_ias_zone_request_data(guint request_type,
gpointer request_data, guint request_data_len)
{
gpointer zclias_control_request_data = NULL;
/* Fetch ops ID */
ops_id = __zblib_request_get_ops_id(request_type);
switch (ops_id) {
- case ZBLIB_ZCLIAS_CONTROL_OPS_ENROLL_RESPONSE: {
- ZigbeeZcliasControlEnrolResponse_t *in_req;
- ZigbeeZcliasControlEnrolResponse_t *req = NULL;
+ case ZBLIB_ZCL_IAS_ZONE_OPS_ENROLL_RESPONSE: {
+ ZigbeeZclIasZoneEnrollResponse_t *in_req;
+ ZigbeeZclIasZoneEnrollResponse_t *req = NULL;
- in_req = (ZigbeeZcliasControlEnrolResponse_t *)request_data;
+ in_req = (ZigbeeZclIasZoneEnrollResponse_t *)request_data;
if (NULL != in_req) {
/* Allocate memory */
- req = (ZigbeeZcliasControlEnrolResponse_t *)
- g_malloc0(sizeof(ZigbeeZcliasControlEnrolResponse_t));
+ req = (ZigbeeZclIasZoneEnrollResponse_t *)
+ g_malloc0(sizeof(ZigbeeZclIasZoneEnrollResponse_t));
/* Copy data */
req->node_id = in_req->node_id;
return zclias_control_request_data;
}
-static gpointer __zblib_request_create_zclidentify_control_request_data(guint request_type,
+static gpointer __zblib_request_create_zcl_identify_request_data(guint request_type,
gpointer request_data, guint request_data_len)
{
gpointer zclidentify_control_request_data = NULL;
/* Fetch ops ID */
ops_id = __zblib_request_get_ops_id(request_type);
switch (ops_id) {
- case ZBLIB_ZCLIDENTIFY_CONTROL_OPS_IDENTIFY: {
- ZigbeeZclidentifyControlIdentify_t *in_req;
- ZigbeeZclidentifyControlIdentify_t *req = NULL;
+ case ZBLIB_ZCL_IDENTIFY_OPS_IDENTIFY: {
+ ZigbeeZclIdentifyIdentify_t *in_req;
+ ZigbeeZclIdentifyIdentify_t *req = NULL;
- in_req = (ZigbeeZclidentifyControlIdentify_t *)request_data;
+ in_req = (ZigbeeZclIdentifyIdentify_t *)request_data;
if (NULL != in_req) {
/* Allocate memory */
- req = (ZigbeeZclidentifyControlIdentify_t *)
- g_malloc0(sizeof(ZigbeeZclidentifyControlIdentify_t));
+ req = (ZigbeeZclIdentifyIdentify_t *)
+ g_malloc0(sizeof(ZigbeeZclIdentifyIdentify_t));
/* Copy data */
req->node_id = in_req->node_id;
}
break;
- case ZBLIB_ZCLIDENTIFY_CONTROL_OPS_QUERY: {
- ZigbeeZclidentifyControlQuery_t *in_req;
- ZigbeeZclidentifyControlQuery_t *req = NULL;
+ case ZBLIB_ZCL_IDENTIFY_OPS_QUERY: {
+ ZigbeeZclIdentifyQuery_t *in_req;
+ ZigbeeZclIdentifyQuery_t *req = NULL;
- in_req = (ZigbeeZclidentifyControlQuery_t *)request_data;
+ in_req = (ZigbeeZclIdentifyQuery_t *)request_data;
if (NULL != in_req) {
/* Allocate memory */
- req = (ZigbeeZclidentifyControlQuery_t *)
- g_malloc0(sizeof(ZigbeeZclidentifyControlQuery_t));
+ req = (ZigbeeZclIdentifyQuery_t *)
+ g_malloc0(sizeof(ZigbeeZclIdentifyQuery_t));
/* Copy data */
req->node_id = in_req->node_id;
return zclidentify_control_request_data;
}
-static gpointer __zblib_request_create_zcl_color_request_data(guint request_type,
+static gpointer __zblib_request_create_zcl_color_control_request_data(guint request_type,
gpointer request_data, guint request_data_len)
{
gpointer zcl_color_request_data = NULL;
/* Fetch ops ID */
ops_id = __zblib_request_get_ops_id(request_type);
switch (ops_id) {
- case ZBLIB_ZCL_COLOR_OPS_MOVE_TO_HUE: {
- ZigbeeZclColorMoveToHue_t *in_req;
- ZigbeeZclColorMoveToHue_t *req = NULL;
+ case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_HUE: {
+ ZigbeeZclColorControlMoveToHue_t *in_req;
+ ZigbeeZclColorControlMoveToHue_t *req = NULL;
- in_req = (ZigbeeZclColorMoveToHue_t *)request_data;
+ in_req = (ZigbeeZclColorControlMoveToHue_t *)request_data;
if (NULL != in_req) {
/* Allocate memory */
- req = (ZigbeeZclColorMoveToHue_t *)
- g_malloc0(sizeof(ZigbeeZclColorMoveToHue_t));
+ req = (ZigbeeZclColorControlMoveToHue_t *)
+ g_malloc0(sizeof(ZigbeeZclColorControlMoveToHue_t));
/* Copy data */
req->node_id = in_req->node_id;
}
break;
- case ZBLIB_ZCL_COLOR_OPS_MOVE_HUE: {
- ZigbeeZclColorMoveHue_t *in_req;
- ZigbeeZclColorMoveHue_t *req = NULL;
+ case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_HUE: {
+ ZigbeeZclColorControlMoveHue_t *in_req;
+ ZigbeeZclColorControlMoveHue_t *req = NULL;
- in_req = (ZigbeeZclColorMoveHue_t *)request_data;
+ in_req = (ZigbeeZclColorControlMoveHue_t *)request_data;
if (NULL != in_req) {
/* Allocate memory */
- req = (ZigbeeZclColorMoveHue_t *)
- g_malloc0(sizeof(ZigbeeZclColorMoveHue_t));
+ req = (ZigbeeZclColorControlMoveHue_t *)
+ g_malloc0(sizeof(ZigbeeZclColorControlMoveHue_t));
/* Copy data */
req->node_id = in_req->node_id;
}
break;
- case ZBLIB_ZCL_COLOR_OPS_STEP_HUE: {
- ZigbeeZclColorStepHue_t *in_req;
- ZigbeeZclColorStepHue_t *req = NULL;
+ case ZBLIB_ZCL_COLOR_CONTROL_OPS_STEP_HUE: {
+ ZigbeeZclColorControlStepHue_t *in_req;
+ ZigbeeZclColorControlStepHue_t *req = NULL;
- in_req = (ZigbeeZclColorStepHue_t *)request_data;
+ in_req = (ZigbeeZclColorControlStepHue_t *)request_data;
if (NULL != in_req) {
/* Allocate memory */
- req = (ZigbeeZclColorStepHue_t *)
- g_malloc0(sizeof(ZigbeeZclColorStepHue_t));
+ req = (ZigbeeZclColorControlStepHue_t *)
+ g_malloc0(sizeof(ZigbeeZclColorControlStepHue_t));
/* Copy data */
req->node_id = in_req->node_id;
}
break;
- case ZBLIB_ZCL_COLOR_OPS_MOVE_TO_STAURATION: {
- ZigbeeZclColorMoveToSaturation_t *in_req;
- ZigbeeZclColorMoveToSaturation_t *req = NULL;
+ case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_STAURATION: {
+ ZigbeeZclColorControlMoveToSaturation_t *in_req;
+ ZigbeeZclColorControlMoveToSaturation_t *req = NULL;
- in_req = (ZigbeeZclColorMoveToSaturation_t *)request_data;
+ in_req = (ZigbeeZclColorControlMoveToSaturation_t *)request_data;
if (NULL != in_req) {
/* Allocate memory */
- req = (ZigbeeZclColorMoveToSaturation_t *)
- g_malloc0(sizeof(ZigbeeZclColorMoveToSaturation_t));
+ req = (ZigbeeZclColorControlMoveToSaturation_t *)
+ g_malloc0(sizeof(ZigbeeZclColorControlMoveToSaturation_t));
/* Copy data */
req->node_id = in_req->node_id;
}
break;
- case ZBLIB_ZCL_COLOR_OPS_MOVE_STAURATION: {
- ZigbeeZclColorMoveSaturation_t *in_req;
- ZigbeeZclColorMoveSaturation_t *req = NULL;
+ case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_STAURATION: {
+ ZigbeeZclColorControlMoveSaturation_t *in_req;
+ ZigbeeZclColorControlMoveSaturation_t *req = NULL;
- in_req = (ZigbeeZclColorMoveSaturation_t *)request_data;
+ in_req = (ZigbeeZclColorControlMoveSaturation_t *)request_data;
if (NULL != in_req) {
/* Allocate memory */
- req = (ZigbeeZclColorMoveSaturation_t *)
- g_malloc0(sizeof(ZigbeeZclColorMoveSaturation_t));
+ req = (ZigbeeZclColorControlMoveSaturation_t *)
+ g_malloc0(sizeof(ZigbeeZclColorControlMoveSaturation_t));
/* Copy data */
req->node_id = in_req->node_id;
}
break;
- case ZBLIB_ZCL_COLOR_OPS_STEP_STAURATION: {
- ZigbeeZclColorStepSaturation_t *in_req;
- ZigbeeZclColorStepSaturation_t *req = NULL;
+ case ZBLIB_ZCL_COLOR_CONTROL_OPS_STEP_STAURATION: {
+ ZigbeeZclColorControlStepSaturation_t *in_req;
+ ZigbeeZclColorControlStepSaturation_t *req = NULL;
- in_req = (ZigbeeZclColorStepSaturation_t *)request_data;
+ in_req = (ZigbeeZclColorControlStepSaturation_t *)request_data;
if (NULL != in_req) {
/* Allocate memory */
- req = (ZigbeeZclColorStepSaturation_t *)
- g_malloc0(sizeof(ZigbeeZclColorStepSaturation_t));
+ req = (ZigbeeZclColorControlStepSaturation_t *)
+ g_malloc0(sizeof(ZigbeeZclColorControlStepSaturation_t));
/* Copy data */
req->node_id = in_req->node_id;
}
break;
- case ZBLIB_ZCL_COLOR_OPS_MOVE_TO_HUE_AND_SATURATION: {
- ZigbeeZclColorMoveToHueAndSaturation_t *in_req;
- ZigbeeZclColorMoveToHueAndSaturation_t *req = NULL;
+ case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_HUE_AND_SATURATION: {
+ ZigbeeZclColorControlMoveToHueAndSaturation_t *in_req;
+ ZigbeeZclColorControlMoveToHueAndSaturation_t *req = NULL;
- in_req = (ZigbeeZclColorMoveToHueAndSaturation_t *)request_data;
+ in_req = (ZigbeeZclColorControlMoveToHueAndSaturation_t *)request_data;
if (NULL != in_req) {
/* Allocate memory */
- req = (ZigbeeZclColorMoveToHueAndSaturation_t *)
- g_malloc0(sizeof(ZigbeeZclColorMoveToHueAndSaturation_t));
+ req = (ZigbeeZclColorControlMoveToHueAndSaturation_t *)
+ g_malloc0(sizeof(ZigbeeZclColorControlMoveToHueAndSaturation_t));
/* Copy data */
req->node_id = in_req->node_id;
}
break;
- case ZBLIB_ZCL_COLOR_OPS_MOVE_TO_COLOR: {
- ZigbeeZclColorMoveToColor_t *in_req;
- ZigbeeZclColorMoveToColor_t *req = NULL;
+ case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_COLOR: {
+ ZigbeeZclColorControlMoveToColor_t *in_req;
+ ZigbeeZclColorControlMoveToColor_t *req = NULL;
- in_req = (ZigbeeZclColorMoveToColor_t *)request_data;
+ in_req = (ZigbeeZclColorControlMoveToColor_t *)request_data;
if (NULL != in_req) {
/* Allocate memory */
- req = (ZigbeeZclColorMoveToColor_t *)
- g_malloc0(sizeof(ZigbeeZclColorMoveToColor_t));
+ req = (ZigbeeZclColorControlMoveToColor_t *)
+ g_malloc0(sizeof(ZigbeeZclColorControlMoveToColor_t));
/* Copy data */
req->node_id = in_req->node_id;
}
break;
- case ZBLIB_ZCL_COLOR_OPS_MOVE_COLOR: {
- ZigbeeZclColorMoveColor_t *in_req;
- ZigbeeZclColorMoveColor_t *req = NULL;
+ case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_COLOR: {
+ ZigbeeZclColorControlMoveColor_t *in_req;
+ ZigbeeZclColorControlMoveColor_t *req = NULL;
- in_req = (ZigbeeZclColorMoveColor_t *)request_data;
+ in_req = (ZigbeeZclColorControlMoveColor_t *)request_data;
if (NULL != in_req) {
/* Allocate memory */
- req = (ZigbeeZclColorMoveColor_t *)
- g_malloc0(sizeof(ZigbeeZclColorMoveColor_t));
+ req = (ZigbeeZclColorControlMoveColor_t *)
+ g_malloc0(sizeof(ZigbeeZclColorControlMoveColor_t));
/* Copy data */
req->node_id = in_req->node_id;
}
break;
- case ZBLIB_ZCL_COLOR_OPS_STEP_COLOR: {
- ZigbeeZclColorStepColor_t *in_req;
- ZigbeeZclColorStepColor_t *req = NULL;
+ case ZBLIB_ZCL_COLOR_CONTROL_OPS_STEP_COLOR: {
+ ZigbeeZclColorControlStepColor_t *in_req;
+ ZigbeeZclColorControlStepColor_t *req = NULL;
- in_req = (ZigbeeZclColorStepColor_t *)request_data;
+ in_req = (ZigbeeZclColorControlStepColor_t *)request_data;
if (NULL != in_req) {
/* Allocate memory */
- req = (ZigbeeZclColorStepColor_t *)
- g_malloc0(sizeof(ZigbeeZclColorStepColor_t));
+ req = (ZigbeeZclColorControlStepColor_t *)
+ g_malloc0(sizeof(ZigbeeZclColorControlStepColor_t));
/* Copy data */
req->node_id = in_req->node_id;
}
break;
- case ZBLIB_ZCL_COLOR_OPS_MOVE_COLOR_TEMPERATURE: {
- ZigbeeZclColorMoveColorTemperature_t *in_req;
- ZigbeeZclColorMoveColorTemperature_t *req = NULL;
+ case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_COLOR_TEMPERATURE: {
+ ZigbeeZclColorControlMoveColorTemperature_t *in_req;
+ ZigbeeZclColorControlMoveColorTemperature_t *req = NULL;
- in_req = (ZigbeeZclColorMoveColorTemperature_t *)request_data;
+ in_req = (ZigbeeZclColorControlMoveColorTemperature_t *)request_data;
if (NULL != in_req) {
/* Allocate memory */
- req = (ZigbeeZclColorMoveColorTemperature_t *)
- g_malloc0(sizeof(ZigbeeZclColorMoveColorTemperature_t));
+ req = (ZigbeeZclColorControlMoveColorTemperature_t *)
+ g_malloc0(sizeof(ZigbeeZclColorControlMoveColorTemperature_t));
/* Copy data */
req->node_id = in_req->node_id;
return zcl_scene_request_data;
}
-static gpointer __zblib_request_create_zdodev_control_request_data(guint request_type,
+static gpointer __zblib_request_create_zdo_dev_control_request_data(guint request_type,
gpointer request_data, guint request_data_len)
{
gpointer zdodev_control_request_data = NULL;
/* Fetch ops ID */
ops_id = __zblib_request_get_ops_id(request_type);
switch (ops_id) {
- case ZBLIB_ZDODEV_CONTROL_OPS_NWK_ADDR_REQ: {
- ZigbeeZdodevControlNwkAddrReq_t *in_req;
- ZigbeeZdodevControlNwkAddrReq_t *req = NULL;
+ case ZBLIB_ZDO_DEV_CONTROL_OPS_NWK_ADDR_REQ: {
+ ZigbeeZdoDevControlNwkAddrReq_t *in_req;
+ ZigbeeZdoDevControlNwkAddrReq_t *req = NULL;
- in_req = (ZigbeeZdodevControlNwkAddrReq_t *)request_data;
+ in_req = (ZigbeeZdoDevControlNwkAddrReq_t *)request_data;
if (NULL != in_req) {
/* Allocate memory */
- req = (ZigbeeZdodevControlNwkAddrReq_t *)
- g_malloc0(sizeof(ZigbeeZdodevControlNwkAddrReq_t));
+ req = (ZigbeeZdoDevControlNwkAddrReq_t *)
+ g_malloc0(sizeof(ZigbeeZdoDevControlNwkAddrReq_t));
/* Copy data */
memcpy(req->eui64, in_req->eui64, ZIGBEE_EUI64_SIZE);
}
break;
- case ZBLIB_ZDODEV_CONTROL_OPS_MATCHED_DESCRIPTOR_REQ: {
- ZigbeeZdodevControlMatchedDescriptorReq_t *in_req;
- ZigbeeZdodevControlMatchedDescriptorReq_t *req = NULL;
+ case ZBLIB_ZDO_DEV_CONTROL_OPS_MATCHED_DESCRIPTOR_REQ: {
+ ZigbeeZdoDevControlMatchedDescriptorReq_t *in_req;
+ ZigbeeZdoDevControlMatchedDescriptorReq_t *req = NULL;
- in_req = (ZigbeeZdodevControlMatchedDescriptorReq_t *)request_data;
+ in_req = (ZigbeeZdoDevControlMatchedDescriptorReq_t *)request_data;
if (NULL != in_req) {
/* Allocate memory */
- req = (ZigbeeZdodevControlMatchedDescriptorReq_t *)
- g_malloc0(sizeof(ZigbeeZdodevControlMatchedDescriptorReq_t));
+ req = (ZigbeeZdoDevControlMatchedDescriptorReq_t *)
+ g_malloc0(sizeof(ZigbeeZdoDevControlMatchedDescriptorReq_t));
/* Copy data */
req->node_id = in_req->node_id;
}
break;
- case ZBLIB_ZDODEV_CONTROL_OPS_IEEE_ADDR_REQ: {
- ZigbeeZdodevControlIeeeAddrReq_t *in_req;
- ZigbeeZdodevControlIeeeAddrReq_t *req = NULL;
+ case ZBLIB_ZDO_DEV_CONTROL_OPS_IEEE_ADDR_REQ: {
+ ZigbeeZdoDevControlIeeeAddrReq_t *in_req;
+ ZigbeeZdoDevControlIeeeAddrReq_t *req = NULL;
- in_req = (ZigbeeZdodevControlIeeeAddrReq_t *)request_data;
+ in_req = (ZigbeeZdoDevControlIeeeAddrReq_t *)request_data;
if (NULL != in_req) {
/* Allocate memory */
- req = (ZigbeeZdodevControlIeeeAddrReq_t *)
- g_malloc0(sizeof(ZigbeeZdodevControlIeeeAddrReq_t));
+ req = (ZigbeeZdoDevControlIeeeAddrReq_t *)
+ g_malloc0(sizeof(ZigbeeZdoDevControlIeeeAddrReq_t));
/* Copy data */
req->node_id = in_req->node_id;
}
break;
- case ZBLIB_ZDODEV_CONTROL_OPS_ACTIVE_EP_REQ: {
- ZigbeeZdodevControlActiveEpReq_t *in_req;
- ZigbeeZdodevControlActiveEpReq_t *req = NULL;
+ case ZBLIB_ZDO_DEV_CONTROL_OPS_ACTIVE_EP_REQ: {
+ ZigbeeZdoDevControlActiveEpReq_t *in_req;
+ ZigbeeZdoDevControlActiveEpReq_t *req = NULL;
- in_req = (ZigbeeZdodevControlActiveEpReq_t *)request_data;
+ in_req = (ZigbeeZdoDevControlActiveEpReq_t *)request_data;
if (NULL != in_req) {
/* Allocate memory */
- req = (ZigbeeZdodevControlActiveEpReq_t *)
- g_malloc0(sizeof(ZigbeeZdodevControlActiveEpReq_t));
+ req = (ZigbeeZdoDevControlActiveEpReq_t *)
+ g_malloc0(sizeof(ZigbeeZdoDevControlActiveEpReq_t));
/* Copy data */
req->node_id = in_req->node_id;
}
break;
- case ZBLIB_ZDODEV_CONTROL_OPS_NODE_DESC_REQ: {
- ZigbeeZdodevControlNodeDescriptorReq_t *in_req;
- ZigbeeZdodevControlNodeDescriptorReq_t *req = NULL;
+ case ZBLIB_ZDO_DEV_CONTROL_OPS_NODE_DESC_REQ: {
+ ZigbeeZdoDevControlNodeDescriptorReq_t *in_req;
+ ZigbeeZdoDevControlNodeDescriptorReq_t *req = NULL;
- in_req = (ZigbeeZdodevControlNodeDescriptorReq_t *)request_data;
+ in_req = (ZigbeeZdoDevControlNodeDescriptorReq_t *)request_data;
if (NULL != in_req) {
/* Allocate memory */
- req = (ZigbeeZdodevControlNodeDescriptorReq_t *)
- g_malloc0(sizeof(ZigbeeZdodevControlNodeDescriptorReq_t));
+ req = (ZigbeeZdoDevControlNodeDescriptorReq_t *)
+ g_malloc0(sizeof(ZigbeeZdoDevControlNodeDescriptorReq_t));
/* Copy data */
req->node_id = in_req->node_id;
}
break;
- case ZBLIB_ZDODEV_CONTROL_OPS_POWER_DESC_REQ: {
- ZigbeeZdodevControlPowerDescriptorReq_t *in_req;
- ZigbeeZdodevControlPowerDescriptorReq_t *req = NULL;
+ case ZBLIB_ZDO_DEV_CONTROL_OPS_POWER_DESC_REQ: {
+ ZigbeeZdoDevControlPowerDescriptorReq_t *in_req;
+ ZigbeeZdoDevControlPowerDescriptorReq_t *req = NULL;
- in_req = (ZigbeeZdodevControlPowerDescriptorReq_t *)request_data;
+ in_req = (ZigbeeZdoDevControlPowerDescriptorReq_t *)request_data;
if (NULL != in_req) {
/* Allocate memory */
- req = (ZigbeeZdodevControlPowerDescriptorReq_t *)
- g_malloc0(sizeof(ZigbeeZdodevControlPowerDescriptorReq_t));
+ req = (ZigbeeZdoDevControlPowerDescriptorReq_t *)
+ g_malloc0(sizeof(ZigbeeZdoDevControlPowerDescriptorReq_t));
/* Copy data */
req->node_id = in_req->node_id;
}
break;
- case ZBLIB_ZDODEV_CONTROL_OPS_COMPLEX_DESC_REQ: {
- ZigbeeZdodevControlComplexDescriptorReq_t *in_req;
- ZigbeeZdodevControlComplexDescriptorReq_t *req = NULL;
+ case ZBLIB_ZDO_DEV_CONTROL_OPS_COMPLEX_DESC_REQ: {
+ ZigbeeZdoDevControlComplexDescriptorReq_t *in_req;
+ ZigbeeZdoDevControlComplexDescriptorReq_t *req = NULL;
- in_req = (ZigbeeZdodevControlComplexDescriptorReq_t *)request_data;
+ in_req = (ZigbeeZdoDevControlComplexDescriptorReq_t *)request_data;
if (NULL != in_req) {
/* Allocate memory */
- req = (ZigbeeZdodevControlComplexDescriptorReq_t *)
- g_malloc0(sizeof(ZigbeeZdodevControlComplexDescriptorReq_t));
+ req = (ZigbeeZdoDevControlComplexDescriptorReq_t *)
+ g_malloc0(sizeof(ZigbeeZdoDevControlComplexDescriptorReq_t));
/* Copy data */
req->node_id = in_req->node_id;
}
break;
- case ZBLIB_ZDODEV_CONTROL_OPS_USER_DESC_REQ: {
- ZigbeeZdodevControlUserDescriptorReq_t *in_req;
- ZigbeeZdodevControlUserDescriptorReq_t *req = NULL;
+ case ZBLIB_ZDO_DEV_CONTROL_OPS_USER_DESC_REQ: {
+ ZigbeeZdoDevControlUserDescriptorReq_t *in_req;
+ ZigbeeZdoDevControlUserDescriptorReq_t *req = NULL;
- in_req = (ZigbeeZdodevControlUserDescriptorReq_t *)request_data;
+ in_req = (ZigbeeZdoDevControlUserDescriptorReq_t *)request_data;
if (NULL != in_req) {
/* Allocate memory */
- req = (ZigbeeZdodevControlUserDescriptorReq_t *)
- g_malloc0(sizeof(ZigbeeZdodevControlUserDescriptorReq_t));
+ req = (ZigbeeZdoDevControlUserDescriptorReq_t *)
+ g_malloc0(sizeof(ZigbeeZdoDevControlUserDescriptorReq_t));
/* Copy data */
req->node_id = in_req->node_id;
}
break;
- case ZBLIB_ZDODEV_CONTROL_OPS_USER_DESC_SET_REQ: {
- ZigbeeZdodevControlUserDescriptorSetReq_t *in_req;
- ZigbeeZdodevControlUserDescriptorSetReq_t *req = NULL;
+ case ZBLIB_ZDO_DEV_CONTROL_OPS_USER_DESC_SET_REQ: {
+ ZigbeeZdoDevControlUserDescriptorSetReq_t *in_req;
+ ZigbeeZdoDevControlUserDescriptorSetReq_t *req = NULL;
- in_req = (ZigbeeZdodevControlUserDescriptorSetReq_t *)request_data;
+ in_req = (ZigbeeZdoDevControlUserDescriptorSetReq_t *)request_data;
if (NULL != in_req) {
/* Allocate memory */
- req = (ZigbeeZdodevControlUserDescriptorSetReq_t *)
- g_malloc0(sizeof(ZigbeeZdodevControlUserDescriptorSetReq_t));
+ req = (ZigbeeZdoDevControlUserDescriptorSetReq_t *)
+ g_malloc0(sizeof(ZigbeeZdoDevControlUserDescriptorSetReq_t));
/* Copy data */
req->node_id = in_req->node_id;
}
break;
- case ZBLIB_ZDODEV_CONTROL_OPS_DEVICE_ANNOUNCE: {
- ZigbeeZdodevControlDeviceAnnounce_t *in_req;
- ZigbeeZdodevControlDeviceAnnounce_t *req = NULL;
+ case ZBLIB_ZDO_DEV_CONTROL_OPS_DEVICE_ANNOUNCE: {
+ ZigbeeZdoDevControlDeviceAnnounce_t *in_req;
+ ZigbeeZdoDevControlDeviceAnnounce_t *req = NULL;
- in_req = (ZigbeeZdodevControlDeviceAnnounce_t *)request_data;
+ in_req = (ZigbeeZdoDevControlDeviceAnnounce_t *)request_data;
if (NULL != in_req) {
/* Allocate memory */
- req = (ZigbeeZdodevControlDeviceAnnounce_t *)
- g_malloc0(sizeof(ZigbeeZdodevControlDeviceAnnounce_t));
+ req = (ZigbeeZdoDevControlDeviceAnnounce_t *)
+ g_malloc0(sizeof(ZigbeeZdoDevControlDeviceAnnounce_t));
/* Copy data */
req->node_id = in_req->node_id;
}
break;
- case ZBLIB_ZDODEV_CONTROL_OPS_SIMPLE_DESC_REQ: {
- ZigbeeZdodevControlSimpleDescriptorReq_t *in_req;
- ZigbeeZdodevControlSimpleDescriptorReq_t *req = NULL;
+ case ZBLIB_ZDO_DEV_CONTROL_OPS_SIMPLE_DESC_REQ: {
+ ZigbeeZdoDevControlSimpleDescriptorReq_t *in_req;
+ ZigbeeZdoDevControlSimpleDescriptorReq_t *req = NULL;
- in_req = (ZigbeeZdodevControlSimpleDescriptorReq_t *)request_data;
+ in_req = (ZigbeeZdoDevControlSimpleDescriptorReq_t *)request_data;
if (NULL != in_req) {
/* Allocate memory */
- req = (ZigbeeZdodevControlSimpleDescriptorReq_t *)
- g_malloc0(sizeof(ZigbeeZdodevControlSimpleDescriptorReq_t));
+ req = (ZigbeeZdoDevControlSimpleDescriptorReq_t *)
+ g_malloc0(sizeof(ZigbeeZdoDevControlSimpleDescriptorReq_t));
/* Copy data */
req->node_id = in_req->node_id;
}
break;
- case ZBLIB_ZDODEV_CONTROL_OPS_MGMT_LQI_REQ: {
- ZigbeeZdodevControlMgmtLqiReq_t *in_req;
- ZigbeeZdodevControlMgmtLqiReq_t *req = NULL;
+ case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_LQI_REQ: {
+ ZigbeeZdoDevControlMgmtLqiReq_t *in_req;
+ ZigbeeZdoDevControlMgmtLqiReq_t *req = NULL;
- in_req = (ZigbeeZdodevControlMgmtLqiReq_t *)request_data;
+ in_req = (ZigbeeZdoDevControlMgmtLqiReq_t *)request_data;
if (NULL != in_req) {
/* Allocate memory */
- req = (ZigbeeZdodevControlMgmtLqiReq_t *)
- g_malloc0(sizeof(ZigbeeZdodevControlMgmtLqiReq_t));
+ req = (ZigbeeZdoDevControlMgmtLqiReq_t *)
+ g_malloc0(sizeof(ZigbeeZdoDevControlMgmtLqiReq_t));
/* Copy data */
req->node_id = in_req->node_id;
}
break;
- case ZBLIB_ZDODEV_CONTROL_OPS_MGMT_RTG_REQ: {
- ZigbeeZdodevControlMgmtRtgReq_t *in_req;
- ZigbeeZdodevControlMgmtRtgReq_t *req = NULL;
+ case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_RTG_REQ: {
+ ZigbeeZdoDevControlMgmtRtgReq_t *in_req;
+ ZigbeeZdoDevControlMgmtRtgReq_t *req = NULL;
- in_req = (ZigbeeZdodevControlMgmtRtgReq_t *)request_data;
+ in_req = (ZigbeeZdoDevControlMgmtRtgReq_t *)request_data;
if (NULL != in_req) {
/* Allocate memory */
- req = (ZigbeeZdodevControlMgmtRtgReq_t *)
- g_malloc0(sizeof(ZigbeeZdodevControlMgmtRtgReq_t));
+ req = (ZigbeeZdoDevControlMgmtRtgReq_t *)
+ g_malloc0(sizeof(ZigbeeZdoDevControlMgmtRtgReq_t));
/* Copy data */
req->node_id = in_req->node_id;
}
break;
- case ZBLIB_ZDODEV_CONTROL_OPS_MGMT_BIND_REQ: {
- ZigbeeZdodevControlMgmtBindReq_t *in_req;
- ZigbeeZdodevControlMgmtBindReq_t *req = NULL;
+ case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_BIND_REQ: {
+ ZigbeeZdoDevControlMgmtBindReq_t *in_req;
+ ZigbeeZdoDevControlMgmtBindReq_t *req = NULL;
- in_req = (ZigbeeZdodevControlMgmtBindReq_t *)request_data;
+ in_req = (ZigbeeZdoDevControlMgmtBindReq_t *)request_data;
if (NULL != in_req) {
/* Allocate memory */
- req = (ZigbeeZdodevControlMgmtBindReq_t *)
- g_malloc0(sizeof(ZigbeeZdodevControlMgmtBindReq_t));
+ req = (ZigbeeZdoDevControlMgmtBindReq_t *)
+ g_malloc0(sizeof(ZigbeeZdoDevControlMgmtBindReq_t));
/* Copy data */
req->node_id = in_req->node_id;
}
break;
- case ZBLIB_ZDODEV_CONTROL_OPS_MGMT_PERMIT_JOIN_REQ: {
- ZigbeeZdodevControlMgmtPermitJoinReq_t *in_req;
- ZigbeeZdodevControlMgmtPermitJoinReq_t *req = NULL;
+ case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_PERMIT_JOIN_REQ: {
+ ZigbeeZdoDevControlMgmtPermitJoinReq_t *in_req;
+ ZigbeeZdoDevControlMgmtPermitJoinReq_t *req = NULL;
- in_req = (ZigbeeZdodevControlMgmtPermitJoinReq_t *)request_data;
+ in_req = (ZigbeeZdoDevControlMgmtPermitJoinReq_t *)request_data;
if (NULL != in_req) {
/* Allocate memory */
- req = (ZigbeeZdodevControlMgmtPermitJoinReq_t *)
- g_malloc0(sizeof(ZigbeeZdodevControlMgmtPermitJoinReq_t));
+ req = (ZigbeeZdoDevControlMgmtPermitJoinReq_t *)
+ g_malloc0(sizeof(ZigbeeZdoDevControlMgmtPermitJoinReq_t));
/* Copy data */
req->addr = in_req->addr;
}
break;
- case ZBLIB_ZDODEV_CONTROL_OPS_NWK_UPDATE_REQ: {
- ZigbeeZdodevControlNwkUpdateReq_t *in_req;
- ZigbeeZdodevControlNwkUpdateReq_t *req = NULL;
+ case ZBLIB_ZDO_DEV_CONTROL_OPS_NWK_UPDATE_REQ: {
+ ZigbeeZdoDevControlNwkUpdateReq_t *in_req;
+ ZigbeeZdoDevControlNwkUpdateReq_t *req = NULL;
- in_req = (ZigbeeZdodevControlNwkUpdateReq_t *)request_data;
+ in_req = (ZigbeeZdoDevControlNwkUpdateReq_t *)request_data;
if (NULL != in_req) {
/* Allocate memory */
- req = (ZigbeeZdodevControlNwkUpdateReq_t *)
- g_malloc0(sizeof(ZigbeeZdodevControlNwkUpdateReq_t));
+ req = (ZigbeeZdoDevControlNwkUpdateReq_t *)
+ g_malloc0(sizeof(ZigbeeZdoDevControlNwkUpdateReq_t));
/* Copy data */
req->node_id = in_req->node_id;
}
break;
- case ZBLIB_ZDODEV_CONTROL_OPS_NWK_DISC_REQ: {
- ZigbeeZdodevControlNwkDescriptorReq_t *in_req;
- ZigbeeZdodevControlNwkDescriptorReq_t *req = NULL;
+ case ZBLIB_ZDO_DEV_CONTROL_OPS_NWK_DISC_REQ: {
+ ZigbeeZdoDevControlNwkDescriptorReq_t *in_req;
+ ZigbeeZdoDevControlNwkDescriptorReq_t *req = NULL;
- in_req = (ZigbeeZdodevControlNwkDescriptorReq_t *)request_data;
+ in_req = (ZigbeeZdoDevControlNwkDescriptorReq_t *)request_data;
if (NULL != in_req) {
/* Allocate memory */
- req = (ZigbeeZdodevControlNwkDescriptorReq_t *)
- g_malloc0(sizeof(ZigbeeZdodevControlNwkDescriptorReq_t));
+ req = (ZigbeeZdoDevControlNwkDescriptorReq_t *)
+ g_malloc0(sizeof(ZigbeeZdoDevControlNwkDescriptorReq_t));
/* Copy data */
req->node_id = in_req->node_id;
/* Fetch driver type */
driver_type = __zblib_request_get_driver_type(request_type);
switch (driver_type) {
- case ZBLIB_DRIVER_TYPE_ALARM: {
- _request_data = __zblib_request_create_alarm_request_data(request_type,
+ case ZBLIB_DRIVER_TYPE_ZCL_ALARM: {
+ _request_data = __zblib_request_create_zcl_alarm_request_data(request_type,
request_data, request_data_len);
}
break;
}
break;
- case ZBLIB_DRIVER_TYPE_DOOR_LOCK: {
- _request_data = __zblib_request_create_door_lock_request_data(request_type,
+ case ZBLIB_DRIVER_TYPE_ZCL_DOOR_LOCK: {
+ _request_data = __zblib_request_create_zcl_door_lock_request_data(request_type,
request_data, request_data_len);
}
break;
- case ZBLIB_DRIVER_TYPE_FAN_CONTROL: {
- _request_data = __zblib_request_create_fan_control_request_data(request_type,
+ case ZBLIB_DRIVER_TYPE_ZCL_FAN_CONTROL: {
+ _request_data = __zblib_request_create_zcl_fan_control_request_data(request_type,
request_data, request_data_len);
}
break;
- case ZBLIB_DRIVER_TYPE_LEVEL_CONTROL: {
- _request_data = __zblib_request_create_level_control_request_data(request_type,
+ case ZBLIB_DRIVER_TYPE_ZCL_LEVEL_CONTROL: {
+ _request_data = __zblib_request_create_zcl_level_control_request_data(request_type,
request_data, request_data_len);
}
break;
}
break;
- case ZBLIB_DRIVER_TYPE_ON_OFF: {
- _request_data = __zblib_request_create_on_off_request_data(request_type,
+ case ZBLIB_DRIVER_TYPE_ZCL_ON_OFF: {
+ _request_data = __zblib_request_create_zcl_on_off_request_data(request_type,
request_data, request_data_len);
}
break;
}
break;
- case ZBLIB_DRIVER_TYPE_THERMOSTAT: {
- _request_data = __zblib_request_create_thermostat_request_data(request_type,
+ case ZBLIB_DRIVER_TYPE_ZCL_THERMOSTAT: {
+ _request_data = __zblib_request_create_zcl_thermostat_request_data(request_type,
request_data, request_data_len);
}
break;
- case ZBLIB_DRIVER_TYPE_ZCLBASIC_CONTROL: {
- _request_data = __zblib_request_create_zclbasic_control_request_data(request_type,
+ case ZBLIB_DRIVER_TYPE_ZCL_BASIC: {
+ _request_data = __zblib_request_create_zcl_basic_request_data(request_type,
request_data, request_data_len);
}
break;
- case ZBLIB_DRIVER_TYPE_ZCLGLOBAL_CONTROL: {
- _request_data = __zblib_request_create_zclglobal_control_request_data(request_type,
+ case ZBLIB_DRIVER_TYPE_ZCL_GLOBAL_CONTROL: {
+ _request_data = __zblib_request_create_zcl_global_control_request_data(request_type,
request_data, request_data_len);
}
break;
- case ZBLIB_DRIVER_TYPE_ZCLIAS_CONTROL: {
- _request_data = __zblib_request_create_zclias_control_request_data(request_type,
+ case ZBLIB_DRIVER_TYPE_ZCL_IAS_ZONE: {
+ _request_data = __zblib_request_create_zcl_ias_zone_request_data(request_type,
request_data, request_data_len);
}
break;
- case ZBLIB_DRIVER_TYPE_ZCLIDENTIFY_CONTROL: {
- _request_data = __zblib_request_create_zclidentify_control_request_data(request_type,
+ case ZBLIB_DRIVER_TYPE_ZCL_IDENTIFY: {
+ _request_data = __zblib_request_create_zcl_identify_request_data(request_type,
request_data, request_data_len);
}
break;
- case ZBLIB_DRIVER_TYPE_ZCL_COLOR: {
- _request_data = __zblib_request_create_zcl_color_request_data(request_type,
+ case ZBLIB_DRIVER_TYPE_ZCL_COLOR_CONTROL: {
+ _request_data = __zblib_request_create_zcl_color_control_request_data(request_type,
request_data, request_data_len);
}
break;
}
break;
- case ZBLIB_DRIVER_TYPE_ZDODEV_CONTROL: {
- _request_data = __zblib_request_create_zdodev_control_request_data(request_type,
+ case ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL: {
+ _request_data = __zblib_request_create_zdo_dev_control_request_data(request_type,
request_data, request_data_len);
}
break;
}
break;
- case ZBLIB_DRIVER_TYPE_NONE: /* Fallthrough */
+ case ZBLIB_DRIVER_TYPE_NONE: /* Fall through */
default: {
Z_LOGE("Unhandled driver type: [%d]", driver_type);
}
return _request_data;
}
-static void __zblib_request_free_alarm_request_data(ZigBeeRequest *request,
+static void __zblib_request_free_zcl_alarm_request_data(ZigBeeRequest *request,
guint request_type)
{
guint ops_id;
/* Fetch ops ID */
ops_id = __zblib_request_get_ops_id(request_type);
switch (ops_id) {
- case ZBLIB_ALARM_OPS_GET_ALARM_COUNT: {
- ZigbeeAlarmGetAlarmCount_t *req = NULL;
+ case ZBLIB_ZCL_ALARM_OPS_GET_ALARM_COUNT: {
+ ZigbeeZclAlarmGetAlarmCount_t *req = NULL;
- req = (ZigbeeAlarmGetAlarmCount_t *)request->request_data;
+ req = (ZigbeeZclAlarmGetAlarmCount_t *)request->request_data;
if (NULL != req) {
g_free(req);
}
}
break;
- case ZBLIB_ALARM_OPS_RESET_ALARM: {
- ZigbeeAlarmResetAlarm_t *req = NULL;
+ case ZBLIB_ZCL_ALARM_OPS_RESET_ALARM: {
+ ZigbeeZclAlarmResetAlarm_t *req = NULL;
- req = (ZigbeeAlarmResetAlarm_t *)request->request_data;
+ req = (ZigbeeZclAlarmResetAlarm_t *)request->request_data;
if (NULL != req) {
g_free(req);
}
}
break;
- case ZBLIB_ALARM_OPS_RESET_ALL_ALARM: {
- ZigbeeAlarmResetAllAlarm_t *req = NULL;
+ case ZBLIB_ZCL_ALARM_OPS_RESET_ALL_ALARM: {
+ ZigbeeZclAlarmResetAllAlarm_t *req = NULL;
- req = (ZigbeeAlarmResetAllAlarm_t *)request->request_data;
+ req = (ZigbeeZclAlarmResetAllAlarm_t *)request->request_data;
if (NULL != req) {
g_free(req);
}
}
break;
- case ZBLIB_ALARM_OPS_ALARM: {
- ZigbeeAlarmAlarm_t *req = NULL;
+ case ZBLIB_ZCL_ALARM_OPS_ALARM: {
+ ZigbeeZclAlarmAlarm_t *req = NULL;
- req = (ZigbeeAlarmAlarm_t *)request->request_data;
+ req = (ZigbeeZclAlarmAlarm_t *)request->request_data;
if (NULL != req) {
g_free(req);
}
}
break;
- case ZBLIB_ALARM_OPS_RESET_ALARM_LOG: {
- ZigbeeAlarmResetAlarmLogs_t *req = NULL;
+ case ZBLIB_ZCL_ALARM_OPS_RESET_ALARM_LOG: {
+ ZigbeeZclAlarmResetAlarmLogs_t *req = NULL;
- req = (ZigbeeAlarmResetAlarmLogs_t *)request->request_data;
+ req = (ZigbeeZclAlarmResetAlarmLogs_t *)request->request_data;
if (NULL != req) {
g_free(req);
}
}
break;
- case ZBLIB_ALARM_OPS_GET_ALARM: {
+ case ZBLIB_ZCL_ALARM_OPS_GET_ALARM: {
}
break;
}
}
-static void __zblib_request_free_door_lock_request_data(ZigBeeRequest *request,
+static void __zblib_request_free_zcl_door_lock_request_data(ZigBeeRequest *request,
guint request_type)
{
guint ops_id;
/* Fetch ops ID */
ops_id = __zblib_request_get_ops_id(request_type);
switch (ops_id) {
- case ZBLIB_DOOR_LOCK_OPS_SUBSCRIBE_LOCK_EVENT: {
- ZigbeeDoorLockSubscriberLockEvent_t *req = NULL;
+ case ZBLIB_ZCL_DOOR_LOCK_OPS_SUBSCRIBE_LOCK_EVENT: {
+ ZigbeeZclDoorLockSubscriberLockEvent_t *req = NULL;
- req = (ZigbeeDoorLockSubscriberLockEvent_t *)request->request_data;
+ req = (ZigbeeZclDoorLockSubscriberLockEvent_t *)request->request_data;
if (NULL != req) {
g_free(req);
}
}
break;
- case ZBLIB_DOOR_LOCK_OPS_SET_DOOR_LOCK_PIN: {
- ZigbeeDoorLockSetDoorLockPin_t *req = NULL;
+ case ZBLIB_ZCL_DOOR_LOCK_OPS_SET_DOOR_LOCK_PIN: {
+ ZigbeeZclDoorLockSetDoorLockPin_t *req = NULL;
- req = (ZigbeeDoorLockSetDoorLockPin_t *)request->request_data;
+ req = (ZigbeeZclDoorLockSetDoorLockPin_t *)request->request_data;
if (NULL != req) {
g_free(req);
}
}
break;
- case ZBLIB_DOOR_LOCK_OPS_SET_DOOR_LOCK: {
- ZigbeeDoorLockSetDoorLock_t *req = NULL;
+ case ZBLIB_ZCL_DOOR_LOCK_OPS_SET_DOOR_LOCK: {
+ ZigbeeZclDoorLockSetDoorLock_t *req = NULL;
- req = (ZigbeeDoorLockSetDoorLock_t *)request->request_data;
+ req = (ZigbeeZclDoorLockSetDoorLock_t *)request->request_data;
if (NULL != req) {
g_free(req);
}
}
break;
- case ZBLIB_DOOR_LOCK_OPS_GET_LOCK_STATE: {
- ZigbeeDoorLockGetDoorLock_t *req = NULL;
+ case ZBLIB_ZCL_DOOR_LOCK_OPS_GET_LOCK_STATE: {
+ ZigbeeZclDoorLockGetDoorLock_t *req = NULL;
- req = (ZigbeeDoorLockGetDoorLock_t *)request->request_data;
+ req = (ZigbeeZclDoorLockGetDoorLock_t *)request->request_data;
if (NULL != req) {
g_free(req);
}
}
}
-static void __zblib_request_free_fan_control_request_data(ZigBeeRequest *request,
+static void __zblib_request_free_zcl_fan_control_request_data(ZigBeeRequest *request,
guint request_type)
{
guint ops_id;
/* Fetch ops ID */
ops_id = __zblib_request_get_ops_id(request_type);
switch (ops_id) {
- case ZBLIB_FAN_CONTROL_OPS_SET_FAN_MODE: {
- ZigbeeFanControlSetFanMode_t *req = NULL;
+ case ZBLIB_ZCL_FAN_CONTROL_OPS_SET_FAN_MODE: {
+ ZigbeeZclFanControlSetFanMode_t *req = NULL;
- req = (ZigbeeFanControlSetFanMode_t *)request->request_data;
+ req = (ZigbeeZclFanControlSetFanMode_t *)request->request_data;
if (NULL != req) {
g_free(req);
}
}
break;
- case ZBLIB_FAN_CONTROL_OPS_GET_FAN_MODE: {
- ZigbeeFanControlGetFanMode_t *req = NULL;
+ case ZBLIB_ZCL_FAN_CONTROL_OPS_GET_FAN_MODE: {
+ ZigbeeZclFanControlGetFanMode_t *req = NULL;
- req = (ZigbeeFanControlGetFanMode_t *)request->request_data;
+ req = (ZigbeeZclFanControlGetFanMode_t *)request->request_data;
if (NULL != req) {
g_free(req);
}
}
break;
- case ZBLIB_FAN_CONTROL_OPS_SET_FAN_MODE_SEQUENCE: {
- ZigbeeFanControlSetFanModeSequence_t *req = NULL;
+ case ZBLIB_ZCL_FAN_CONTROL_OPS_SET_FAN_MODE_SEQUENCE: {
+ ZigbeeZclFanControlSetFanModeSequence_t *req = NULL;
- req = (ZigbeeFanControlSetFanModeSequence_t *)request->request_data;
+ req = (ZigbeeZclFanControlSetFanModeSequence_t *)request->request_data;
if (NULL != req) {
g_free(req);
}
}
break;
- case ZBLIB_FAN_CONTROL_OPS_GET_FAN_MODE_SEQUENCE: {
- ZigbeeFanControlGetFanModeSequence_t *req = NULL;
+ case ZBLIB_ZCL_FAN_CONTROL_OPS_GET_FAN_MODE_SEQUENCE: {
+ ZigbeeZclFanControlGetFanModeSequence_t *req = NULL;
- req = (ZigbeeFanControlGetFanModeSequence_t *)request->request_data;
+ req = (ZigbeeZclFanControlGetFanModeSequence_t *)request->request_data;
if (NULL != req) {
g_free(req);
}
}
}
-static void __zblib_request_free_level_control_request_data(ZigBeeRequest *request,
+static void __zblib_request_free_zcl_level_control_request_data(ZigBeeRequest *request,
guint request_type)
{
guint ops_id;
/* Fetch ops ID */
ops_id = __zblib_request_get_ops_id(request_type);
switch (ops_id) {
- case ZBLIB_LEVEL_CONTROL_OPS_MOVE_TO_LEVEL: {
- ZigbeeLevelControlMoveToLevel_t *req = NULL;
+ case ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE_TO_LEVEL: {
+ ZigbeeZclLevelControlMoveToLevel_t *req = NULL;
- req = (ZigbeeLevelControlMoveToLevel_t *)request->request_data;
+ req = (ZigbeeZclLevelControlMoveToLevel_t *)request->request_data;
if (NULL != req) {
g_free(req);
}
}
break;
- case ZBLIB_LEVEL_CONTROL_OPS_MOVE: {
- ZigbeeLevelControlMove_t *req = NULL;
+ case ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE: {
+ ZigbeeZclLevelControlMove_t *req = NULL;
- req = (ZigbeeLevelControlMove_t *)request->request_data;
+ req = (ZigbeeZclLevelControlMove_t *)request->request_data;
if (NULL != req) {
g_free(req);
}
}
break;
- case ZBLIB_LEVEL_CONTROL_OPS_STEP: {
- ZigbeeLevelControlStep_t *req = NULL;
+ case ZBLIB_ZCL_LEVEL_CONTROL_OPS_STEP: {
+ ZigbeeZclLevelControlStep_t *req = NULL;
- req = (ZigbeeLevelControlStep_t *)request->request_data;
+ req = (ZigbeeZclLevelControlStep_t *)request->request_data;
if (NULL != req) {
g_free(req);
}
}
break;
- case ZBLIB_LEVEL_CONTROL_OPS_MOVE_TO_LEVEL_WITH_ON_OFF: {
- ZigbeeLevelControlMoveToLevelWithOnOff_t *req = NULL;
+ case ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE_TO_LEVEL_WITH_ON_OFF: {
+ ZigbeeZclLevelControlMoveToLevelWithOnOff_t *req = NULL;
- req = (ZigbeeLevelControlMoveToLevelWithOnOff_t *)request->request_data;
+ req = (ZigbeeZclLevelControlMoveToLevelWithOnOff_t *)request->request_data;
if (NULL != req) {
g_free(req);
}
}
break;
- case ZBLIB_LEVEL_CONTROL_OPS_MOVE_WITH_ON_OFF: {
- ZigbeeLevelControlMoveWithOnOff_t *req = NULL;
+ case ZBLIB_ZCL_LEVEL_CONTROL_OPS_MOVE_WITH_ON_OFF: {
+ ZigbeeZclLevelControlMoveWithOnOff_t *req = NULL;
- req = (ZigbeeLevelControlMoveWithOnOff_t *)request->request_data;
+ req = (ZigbeeZclLevelControlMoveWithOnOff_t *)request->request_data;
if (NULL != req) {
g_free(req);
}
}
break;
- case ZBLIB_LEVEL_CONTROL_OPS_STEP_WITH_ON_OFF: {
- ZigbeeLevelControlStepWithOnOff_t *req = NULL;
+ case ZBLIB_ZCL_LEVEL_CONTROL_OPS_STEP_WITH_ON_OFF: {
+ ZigbeeZclLevelControlStepWithOnOff_t *req = NULL;
- req = (ZigbeeLevelControlStepWithOnOff_t *)request->request_data;
+ req = (ZigbeeZclLevelControlStepWithOnOff_t *)request->request_data;
if (NULL != req) {
g_free(req);
}
}
break;
- case ZBLIB_LEVEL_CONTROL_OPS_STOP: {
- ZigbeeLevelControlStop_t *req = NULL;
+ case ZBLIB_ZCL_LEVEL_CONTROL_OPS_STOP: {
+ ZigbeeZclLevelControlStop_t *req = NULL;
- req = (ZigbeeLevelControlStop_t *)request->request_data;
+ req = (ZigbeeZclLevelControlStop_t *)request->request_data;
if (NULL != req) {
g_free(req);
}
}
}
-static void __zblib_request_free_on_off_request_data(ZigBeeRequest *request,
+static void __zblib_request_free_zcl_on_off_request_data(ZigBeeRequest *request,
guint request_type)
{
guint ops_id;
/* Fetch ops ID */
ops_id = __zblib_request_get_ops_id(request_type);
switch (ops_id) {
- case ZBLIB_ON_OFF_OPS_SET_ON_OFF: {
- ZigbeeOnOffSetOnOff_t *req = NULL;
+ case ZBLIB_ZCL_ON_OFF_OPS_SET_ON_OFF: {
+ ZigbeeZclOnOffSetOnOff_t *req = NULL;
- req = (ZigbeeOnOffSetOnOff_t *)request->request_data;
+ req = (ZigbeeZclOnOffSetOnOff_t *)request->request_data;
if (NULL != req) {
g_free(req);
}
}
break;
- case ZBLIB_ON_OFF_OPS_GET_ON_OFF_STATE: {
- ZigbeeOnOffGetOnOffState_t *req = NULL;
+ case ZBLIB_ZCL_ON_OFF_OPS_GET_ON_OFF_STATE: {
+ ZigbeeZclOnOffGetOnOffState_t *req = NULL;
- req = (ZigbeeOnOffGetOnOffState_t *)request->request_data;
+ req = (ZigbeeZclOnOffGetOnOffState_t *)request->request_data;
if (NULL != req) {
g_free(req);
}
}
}
-static void __zblib_request_free_thermostat_request_data(ZigBeeRequest *request,
+static void __zblib_request_free_zcl_thermostat_request_data(ZigBeeRequest *request,
guint request_type)
{
guint ops_id;
/* Fetch ops ID */
ops_id = __zblib_request_get_ops_id(request_type);
switch (ops_id) {
- case ZBLIB_THERMOSTAT_OPS_GET_LOCAL_TEMP: {
- ZigbeeThermostatGetLocalTemp_t *req = NULL;
+ case ZBLIB_ZCL_THERMOSTAT_OPS_GET_LOCAL_TEMP: {
+ ZigbeeZclThermostatGetLocalTemp_t *req = NULL;
- req = (ZigbeeThermostatGetLocalTemp_t *)request->request_data;
+ req = (ZigbeeZclThermostatGetLocalTemp_t *)request->request_data;
if (NULL != req) {
g_free(req);
}
}
break;
- case ZBLIB_THERMOSTAT_OPS_GET_WEEKLY_SCHEDULE: {
- ZigbeeThermostatGetWeeklySchedule_t *req = NULL;
+ case ZBLIB_ZCL_THERMOSTAT_OPS_GET_WEEKLY_SCHEDULE: {
+ ZigbeeZclThermostatGetWeeklySchedule_t *req = NULL;
- req = (ZigbeeThermostatGetWeeklySchedule_t *)request->request_data;
+ req = (ZigbeeZclThermostatGetWeeklySchedule_t *)request->request_data;
if (NULL != req) {
g_free(req);
}
}
break;
- case ZBLIB_THERMOSTAT_OPS_SET_WEEKLY_SCHEDULE: {
- ZigbeeThermostatSetWeeklySchedule_t *req = NULL;
+ case ZBLIB_ZCL_THERMOSTAT_OPS_SET_WEEKLY_SCHEDULE: {
+ ZigbeeZclThermostatSetWeeklySchedule_t *req = NULL;
- req = (ZigbeeThermostatSetWeeklySchedule_t *)request->request_data;
+ req = (ZigbeeZclThermostatSetWeeklySchedule_t *)request->request_data;
if (NULL != req) {
g_free(req);
}
}
break;
- case ZBLIB_THERMOSTAT_OPS_CLEAR_WEEKLY_SCHEDULE: {
- ZigbeeThermostatClearWeeklySchedule_t *req = NULL;
+ case ZBLIB_ZCL_THERMOSTAT_OPS_CLEAR_WEEKLY_SCHEDULE: {
+ ZigbeeZclThermostatClearWeeklySchedule_t *req = NULL;
- req = (ZigbeeThermostatClearWeeklySchedule_t *)request->request_data;
+ req = (ZigbeeZclThermostatClearWeeklySchedule_t *)request->request_data;
if (NULL != req) {
g_free(req);
}
}
break;
- case ZBLIB_THERMOSTAT_OPS_SETPOINT_RAISE_LOWER: {
- ZigbeeThermostatSetpointRaiseLower_t *req = NULL;
+ case ZBLIB_ZCL_THERMOSTAT_OPS_SETPOINT_RAISE_LOWER: {
+ ZigbeeZclThermostatSetpointRaiseLower_t *req = NULL;
- req = (ZigbeeThermostatSetpointRaiseLower_t *)request->request_data;
+ req = (ZigbeeZclThermostatSetpointRaiseLower_t *)request->request_data;
if (NULL != req) {
g_free(req);
}
}
}
-static void __zblib_request_free_zclbasic_control_request_data(ZigBeeRequest *request,
+static void __zblib_request_free_zcl_basic_request_data(ZigBeeRequest *request,
guint request_type)
{
guint ops_id;
/* Fetch ops ID */
ops_id = __zblib_request_get_ops_id(request_type);
switch (ops_id) {
- case ZBLIB_ZCLBASIC_CONTROL_OPS_RESET_FACTORY_DEFAULT: {
- ZigbeeZclbasicControlResetFactoryDefault_t *req = NULL;
+ case ZBLIB_ZCL_BASIC_OPS_RESET_FACTORY_DEFAULT: {
+ ZigbeeZclBasicResetFactoryDefault_t *req = NULL;
- req = (ZigbeeZclbasicControlResetFactoryDefault_t *)request->request_data;
+ req = (ZigbeeZclBasicResetFactoryDefault_t *)request->request_data;
if (NULL != req) {
g_free(req);
}
}
}
-static void __zblib_request_free_zclglobal_control_request_data(ZigBeeRequest *request,
+static void __zblib_request_free_zcl_global_control_request_data(ZigBeeRequest *request,
guint request_type)
{
guint ops_id;
/* Fetch ops ID */
ops_id = __zblib_request_get_ops_id(request_type);
switch (ops_id) {
- case ZBLIB_ZCLGLOBAL_CONTROL_OPS_READ_ATTRIBUTES_REQ: {
- ZigbeeZclglobalControlReadAttributesRequest_t *req = NULL;
+ case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_READ_ATTRIBUTES_REQ: {
+ ZigbeeZclGlobalControlReadAttributesRequest_t *req = NULL;
- req = (ZigbeeZclglobalControlReadAttributesRequest_t *)request->request_data;
+ req = (ZigbeeZclGlobalControlReadAttributesRequest_t *)request->request_data;
if (NULL != req) {
g_free(req->attribute_id);
g_free(req);
}
break;
- case ZBLIB_ZCLGLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_REQ: {
- ZigbeeZclglobalControlWriteAttributesRequest_t *req = NULL;
+ case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_REQ: {
+ ZigbeeZclGlobalControlWriteAttributesRequest_t *req = NULL;
- req = (ZigbeeZclglobalControlWriteAttributesRequest_t *)request->request_data;
+ req = (ZigbeeZclGlobalControlWriteAttributesRequest_t *)request->request_data;
if (NULL != req) {
g_free(req->write_records);
g_free(req);
}
break;
- case ZBLIB_ZCLGLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_UNDIVIDED_REQ: {
- ZigbeeZclglobalControlWriteAttributesUndividedRequest_t *req = NULL;
+ case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_UNDIVIDED_REQ: {
+ ZigbeeZclGlobalControlWriteAttributesUndividedRequest_t *req = NULL;
- req = (ZigbeeZclglobalControlWriteAttributesUndividedRequest_t *)request->request_data;
+ req = (ZigbeeZclGlobalControlWriteAttributesUndividedRequest_t *)request->request_data;
if (NULL != req) {
g_free(req->write_records);
g_free(req);
}
break;
- case ZBLIB_ZCLGLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_NO_RESP: {
- ZigbeeZclglobalControlWriteAttributesNoResponse_t *req = NULL;
+ case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_NO_RESP: {
+ ZigbeeZclGlobalControlWriteAttributesNoResponse_t *req = NULL;
- req = (ZigbeeZclglobalControlWriteAttributesNoResponse_t *)request->request_data;
+ req = (ZigbeeZclGlobalControlWriteAttributesNoResponse_t *)request->request_data;
if (NULL != req) {
g_free(req->write_records);
g_free(req);
}
break;
- case ZBLIB_ZCLGLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_STRUCTURED: {
- ZigbeeZclglobalControlWriteAttributesStructed_t *req = NULL;
+ case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_WRITE_ATTRIBUTES_STRUCTURED: {
+ ZigbeeZclGlobalControlWriteAttributesStructed_t *req = NULL;
- req = (ZigbeeZclglobalControlWriteAttributesStructed_t *)request->request_data;
+ req = (ZigbeeZclGlobalControlWriteAttributesStructed_t *)request->request_data;
if (NULL != req) {
g_free(req->write_records);
g_free(req);
}
break;
- case ZBLIB_ZCLGLOBAL_CONTROL_OPS_READ_ATTRIBUTES_STRUCTURED: {
- ZigbeeZclglobalControlReadAttributesStructed_t *req = NULL;
+ case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_READ_ATTRIBUTES_STRUCTURED: {
+ ZigbeeZclGlobalControlReadAttributesStructed_t *req = NULL;
- req = (ZigbeeZclglobalControlReadAttributesStructed_t *)request->request_data;
+ req = (ZigbeeZclGlobalControlReadAttributesStructed_t *)request->request_data;
if (NULL != req) {
g_free(req->read_records);
g_free(req);
}
break;
- case ZBLIB_ZCLGLOBAL_CONTROL_OPS_CONFIGURE_REPORTING_REQ: {
- ZigbeeZclglobalControlConfigureReportingReq_t *req = NULL;
+ case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_CONFIGURE_REPORTING_REQ: {
+ ZigbeeZclGlobalControlConfigureReportingReq_t *req = NULL;
- req = (ZigbeeZclglobalControlConfigureReportingReq_t *)request->request_data;
+ req = (ZigbeeZclGlobalControlConfigureReportingReq_t *)request->request_data;
if (NULL != req) {
g_free(req->read_records);
g_free(req);
}
break;
- case ZBLIB_ZCLGLOBAL_CONTROL_OPS_READ_CONFIGURE_REPORTING: {
- ZigbeeZclglobalControlReadConfigureReporting_t *req = NULL;
+ case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_READ_CONFIGURE_REPORTING: {
+ ZigbeeZclGlobalControlReadConfigureReporting_t *req = NULL;
- req = (ZigbeeZclglobalControlReadConfigureReporting_t *)request->request_data;
+ req = (ZigbeeZclGlobalControlReadConfigureReporting_t *)request->request_data;
if (NULL != req) {
g_free(req->read_records);
g_free(req);
}
break;
- case ZBLIB_ZCLGLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES: {
- ZigbeeZclglobalControlDiscoverAttributes_t *req = NULL;
+ case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES: {
+ ZigbeeZclGlobalControlDiscoverAttributes_t *req = NULL;
- req = (ZigbeeZclglobalControlDiscoverAttributes_t *)request->request_data;
+ req = (ZigbeeZclGlobalControlDiscoverAttributes_t *)request->request_data;
if (NULL != req) {
g_free(req);
}
}
break;
- case ZBLIB_ZCLGLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES_EXTENDED: {
- ZigbeeZclglobalControlDiscoverAttributesExtended_t *req = NULL;
+ case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_ATTRIBUTES_EXTENDED: {
+ ZigbeeZclGlobalControlDiscoverAttributesExtended_t *req = NULL;
- req = (ZigbeeZclglobalControlDiscoverAttributesExtended_t *)request->request_data;
+ req = (ZigbeeZclGlobalControlDiscoverAttributesExtended_t *)request->request_data;
if (NULL != req) {
g_free(req);
}
}
break;
- case ZBLIB_ZCLGLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_RECEIVED: {
- ZigbeeZclglobalControlDiscoverCommandsReceived_t *req = NULL;
+ case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_RECEIVED: {
+ ZigbeeZclGlobalControlDiscoverCommandsReceived_t *req = NULL;
- req = (ZigbeeZclglobalControlDiscoverCommandsReceived_t *)request->request_data;
+ req = (ZigbeeZclGlobalControlDiscoverCommandsReceived_t *)request->request_data;
if (NULL != req) {
g_free(req);
}
}
break;
- case ZBLIB_ZCLGLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_GENERATED: {
- ZigbeeZclglobalControlDiscoverCommandsGenerated_t *req = NULL;
+ case ZBLIB_ZCL_GLOBAL_CONTROL_OPS_DISCOVER_COMMANDS_GENERATED: {
+ ZigbeeZclGlobalControlDiscoverCommandsGenerated_t *req = NULL;
- req = (ZigbeeZclglobalControlDiscoverCommandsGenerated_t *)request->request_data;
+ req = (ZigbeeZclGlobalControlDiscoverCommandsGenerated_t *)request->request_data;
if (NULL != req) {
g_free(req);
}
}
}
-static void __zblib_request_free_zclias_control_request_data(ZigBeeRequest *request,
+static void __zblib_request_free_zcl_ias_zone_request_data(ZigBeeRequest *request,
guint request_type)
{
guint ops_id;
/* Fetch ops ID */
ops_id = __zblib_request_get_ops_id(request_type);
switch (ops_id) {
- case ZBLIB_ZCLIAS_CONTROL_OPS_ENROLL_RESPONSE: {
- ZigbeeZcliasControlEnrolResponse_t *req = NULL;
+ case ZBLIB_ZCL_IAS_ZONE_OPS_ENROLL_RESPONSE: {
+ ZigbeeZclIasZoneEnrollResponse_t *req = NULL;
- req = (ZigbeeZcliasControlEnrolResponse_t *)request->request_data;
+ req = (ZigbeeZclIasZoneEnrollResponse_t *)request->request_data;
if (NULL != req) {
g_free(req);
}
}
}
-static void __zblib_request_free_zclidentify_control_request_data(ZigBeeRequest *request,
+static void __zblib_request_free_zcl_identify_request_data(ZigBeeRequest *request,
guint request_type)
{
guint ops_id;
/* Fetch ops ID */
ops_id = __zblib_request_get_ops_id(request_type);
switch (ops_id) {
- case ZBLIB_ZCLIDENTIFY_CONTROL_OPS_IDENTIFY: {
- ZigbeeZclidentifyControlIdentify_t *req = NULL;
+ case ZBLIB_ZCL_IDENTIFY_OPS_IDENTIFY: {
+ ZigbeeZclIdentifyIdentify_t *req = NULL;
- req = (ZigbeeZclidentifyControlIdentify_t *)request->request_data;
+ req = (ZigbeeZclIdentifyIdentify_t *)request->request_data;
if (NULL != req) {
g_free(req);
}
}
break;
- case ZBLIB_ZCLIDENTIFY_CONTROL_OPS_QUERY: {
- ZigbeeZclidentifyControlQuery_t *req = NULL;
+ case ZBLIB_ZCL_IDENTIFY_OPS_QUERY: {
+ ZigbeeZclIdentifyQuery_t *req = NULL;
- req = (ZigbeeZclidentifyControlQuery_t *)request->request_data;
+ req = (ZigbeeZclIdentifyQuery_t *)request->request_data;
if (NULL != req) {
g_free(req);
}
}
}
-static void __zblib_request_free_zcl_color_request_data(ZigBeeRequest *request,
+static void __zblib_request_free_zcl_color_control_request_data(ZigBeeRequest *request,
guint request_type)
{
guint ops_id;
/* Fetch ops ID */
ops_id = __zblib_request_get_ops_id(request_type);
switch (ops_id) {
- case ZBLIB_ZCL_COLOR_OPS_MOVE_TO_HUE: {
- ZigbeeZclColorMoveToHue_t *req = NULL;
+ case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_HUE: {
+ ZigbeeZclColorControlMoveToHue_t *req = NULL;
- req = (ZigbeeZclColorMoveToHue_t *)request->request_data;
+ req = (ZigbeeZclColorControlMoveToHue_t *)request->request_data;
if (NULL != req) {
g_free(req);
}
}
break;
- case ZBLIB_ZCL_COLOR_OPS_MOVE_HUE: {
- ZigbeeZclColorMoveHue_t *req = NULL;
+ case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_HUE: {
+ ZigbeeZclColorControlMoveHue_t *req = NULL;
- req = (ZigbeeZclColorMoveHue_t *)request->request_data;
+ req = (ZigbeeZclColorControlMoveHue_t *)request->request_data;
if (NULL != req) {
g_free(req);
}
}
break;
- case ZBLIB_ZCL_COLOR_OPS_STEP_HUE: {
- ZigbeeZclColorStepHue_t *req = NULL;
+ case ZBLIB_ZCL_COLOR_CONTROL_OPS_STEP_HUE: {
+ ZigbeeZclColorControlStepHue_t *req = NULL;
- req = (ZigbeeZclColorStepHue_t *)request->request_data;
+ req = (ZigbeeZclColorControlStepHue_t *)request->request_data;
if (NULL != req) {
g_free(req);
}
}
break;
- case ZBLIB_ZCL_COLOR_OPS_MOVE_TO_STAURATION: {
- ZigbeeZclColorMoveToSaturation_t *req = NULL;
+ case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_STAURATION: {
+ ZigbeeZclColorControlMoveToSaturation_t *req = NULL;
- req = (ZigbeeZclColorMoveToSaturation_t *)request->request_data;
+ req = (ZigbeeZclColorControlMoveToSaturation_t *)request->request_data;
if (NULL != req) {
g_free(req);
}
}
break;
- case ZBLIB_ZCL_COLOR_OPS_MOVE_STAURATION: {
- ZigbeeZclColorMoveSaturation_t *req = NULL;
+ case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_STAURATION: {
+ ZigbeeZclColorControlMoveSaturation_t *req = NULL;
- req = (ZigbeeZclColorMoveSaturation_t *)request->request_data;
+ req = (ZigbeeZclColorControlMoveSaturation_t *)request->request_data;
if (NULL != req) {
g_free(req);
}
}
break;
- case ZBLIB_ZCL_COLOR_OPS_STEP_STAURATION: {
- ZigbeeZclColorStepSaturation_t *req = NULL;
+ case ZBLIB_ZCL_COLOR_CONTROL_OPS_STEP_STAURATION: {
+ ZigbeeZclColorControlStepSaturation_t *req = NULL;
- req = (ZigbeeZclColorStepSaturation_t *)request->request_data;
+ req = (ZigbeeZclColorControlStepSaturation_t *)request->request_data;
if (NULL != req) {
g_free(req);
}
}
break;
- case ZBLIB_ZCL_COLOR_OPS_MOVE_TO_HUE_AND_SATURATION: {
- ZigbeeZclColorMoveToHueAndSaturation_t *req = NULL;
+ case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_HUE_AND_SATURATION: {
+ ZigbeeZclColorControlMoveToHueAndSaturation_t *req = NULL;
- req = (ZigbeeZclColorMoveToHueAndSaturation_t *)request->request_data;
+ req = (ZigbeeZclColorControlMoveToHueAndSaturation_t *)request->request_data;
if (NULL != req) {
g_free(req);
}
}
break;
- case ZBLIB_ZCL_COLOR_OPS_MOVE_TO_COLOR: {
- ZigbeeZclColorMoveToColor_t *req = NULL;
+ case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_TO_COLOR: {
+ ZigbeeZclColorControlMoveToColor_t *req = NULL;
- req = (ZigbeeZclColorMoveToColor_t *)request->request_data;
+ req = (ZigbeeZclColorControlMoveToColor_t *)request->request_data;
if (NULL != req) {
g_free(req);
}
}
break;
- case ZBLIB_ZCL_COLOR_OPS_MOVE_COLOR: {
- ZigbeeZclColorMoveColor_t *req = NULL;
+ case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_COLOR: {
+ ZigbeeZclColorControlMoveColor_t *req = NULL;
- req = (ZigbeeZclColorMoveColor_t *)request->request_data;
+ req = (ZigbeeZclColorControlMoveColor_t *)request->request_data;
if (NULL != req) {
g_free(req);
}
}
break;
- case ZBLIB_ZCL_COLOR_OPS_STEP_COLOR: {
- ZigbeeZclColorStepColor_t *req = NULL;
+ case ZBLIB_ZCL_COLOR_CONTROL_OPS_STEP_COLOR: {
+ ZigbeeZclColorControlStepColor_t *req = NULL;
- req = (ZigbeeZclColorStepColor_t *)request->request_data;
+ req = (ZigbeeZclColorControlStepColor_t *)request->request_data;
if (NULL != req) {
g_free(req);
}
}
break;
- case ZBLIB_ZCL_COLOR_OPS_MOVE_COLOR_TEMPERATURE: {
- ZigbeeZclColorMoveColorTemperature_t *req = NULL;
+ case ZBLIB_ZCL_COLOR_CONTROL_OPS_MOVE_COLOR_TEMPERATURE: {
+ ZigbeeZclColorControlMoveColorTemperature_t *req = NULL;
- req = (ZigbeeZclColorMoveColorTemperature_t *)request->request_data;
+ req = (ZigbeeZclColorControlMoveColorTemperature_t *)request->request_data;
if (NULL != req) {
g_free(req);
}
}
}
-static void __zblib_request_free_zdodev_control_request_data(ZigBeeRequest *request,
+static void __zblib_request_free_zdo_dev_control_request_data(ZigBeeRequest *request,
guint request_type)
{
guint ops_id;
/* Fetch ops ID */
ops_id = __zblib_request_get_ops_id(request_type);
switch (ops_id) {
- case ZBLIB_ZDODEV_CONTROL_OPS_NWK_ADDR_REQ: {
- ZigbeeZdodevControlNwkAddrReq_t *req = NULL;
+ case ZBLIB_ZDO_DEV_CONTROL_OPS_NWK_ADDR_REQ: {
+ ZigbeeZdoDevControlNwkAddrReq_t *req = NULL;
- req = (ZigbeeZdodevControlNwkAddrReq_t *)request->request_data;
+ req = (ZigbeeZdoDevControlNwkAddrReq_t *)request->request_data;
if (NULL != req) {
g_free(req);
}
}
break;
- case ZBLIB_ZDODEV_CONTROL_OPS_MATCHED_DESCRIPTOR_REQ: {
- ZigbeeZdodevControlMatchedDescriptorReq_t *req = NULL;
+ case ZBLIB_ZDO_DEV_CONTROL_OPS_MATCHED_DESCRIPTOR_REQ: {
+ ZigbeeZdoDevControlMatchedDescriptorReq_t *req = NULL;
- req = (ZigbeeZdodevControlMatchedDescriptorReq_t *)request->request_data;
+ req = (ZigbeeZdoDevControlMatchedDescriptorReq_t *)request->request_data;
if (NULL != req) {
g_free(req->in_cl);
g_free(req->out_cl);
}
break;
- case ZBLIB_ZDODEV_CONTROL_OPS_IEEE_ADDR_REQ: {
- ZigbeeZdodevControlIeeeAddrReq_t *req = NULL;
+ case ZBLIB_ZDO_DEV_CONTROL_OPS_IEEE_ADDR_REQ: {
+ ZigbeeZdoDevControlIeeeAddrReq_t *req = NULL;
- req = (ZigbeeZdodevControlIeeeAddrReq_t *)request->request_data;
+ req = (ZigbeeZdoDevControlIeeeAddrReq_t *)request->request_data;
if (NULL != req) {
g_free(req);
}
}
break;
- case ZBLIB_ZDODEV_CONTROL_OPS_ACTIVE_EP_REQ: {
- ZigbeeZdodevControlActiveEpReq_t *req = NULL;
+ case ZBLIB_ZDO_DEV_CONTROL_OPS_ACTIVE_EP_REQ: {
+ ZigbeeZdoDevControlActiveEpReq_t *req = NULL;
- req = (ZigbeeZdodevControlActiveEpReq_t *)request->request_data;
+ req = (ZigbeeZdoDevControlActiveEpReq_t *)request->request_data;
if (NULL != req) {
g_free(req);
}
}
break;
- case ZBLIB_ZDODEV_CONTROL_OPS_NODE_DESC_REQ: {
- ZigbeeZdodevControlNodeDescriptorReq_t *req = NULL;
+ case ZBLIB_ZDO_DEV_CONTROL_OPS_NODE_DESC_REQ: {
+ ZigbeeZdoDevControlNodeDescriptorReq_t *req = NULL;
- req = (ZigbeeZdodevControlNodeDescriptorReq_t *)request->request_data;
+ req = (ZigbeeZdoDevControlNodeDescriptorReq_t *)request->request_data;
if (NULL != req) {
g_free(req);
}
}
break;
- case ZBLIB_ZDODEV_CONTROL_OPS_POWER_DESC_REQ: {
- ZigbeeZdodevControlPowerDescriptorReq_t *req = NULL;
+ case ZBLIB_ZDO_DEV_CONTROL_OPS_POWER_DESC_REQ: {
+ ZigbeeZdoDevControlPowerDescriptorReq_t *req = NULL;
- req = (ZigbeeZdodevControlPowerDescriptorReq_t *)request->request_data;
+ req = (ZigbeeZdoDevControlPowerDescriptorReq_t *)request->request_data;
if (NULL != req) {
g_free(req);
}
}
break;
- case ZBLIB_ZDODEV_CONTROL_OPS_COMPLEX_DESC_REQ: {
- ZigbeeZdodevControlComplexDescriptorReq_t *req = NULL;
+ case ZBLIB_ZDO_DEV_CONTROL_OPS_COMPLEX_DESC_REQ: {
+ ZigbeeZdoDevControlComplexDescriptorReq_t *req = NULL;
- req = (ZigbeeZdodevControlComplexDescriptorReq_t *)request->request_data;
+ req = (ZigbeeZdoDevControlComplexDescriptorReq_t *)request->request_data;
if (NULL != req) {
g_free(req);
}
}
break;
- case ZBLIB_ZDODEV_CONTROL_OPS_USER_DESC_REQ: {
- ZigbeeZdodevControlUserDescriptorReq_t *req = NULL;
+ case ZBLIB_ZDO_DEV_CONTROL_OPS_USER_DESC_REQ: {
+ ZigbeeZdoDevControlUserDescriptorReq_t *req = NULL;
- req = (ZigbeeZdodevControlUserDescriptorReq_t *)request->request_data;
+ req = (ZigbeeZdoDevControlUserDescriptorReq_t *)request->request_data;
if (NULL != req) {
g_free(req);
}
}
break;
- case ZBLIB_ZDODEV_CONTROL_OPS_USER_DESC_SET_REQ: {
- ZigbeeZdodevControlUserDescriptorSetReq_t *req = NULL;
+ case ZBLIB_ZDO_DEV_CONTROL_OPS_USER_DESC_SET_REQ: {
+ ZigbeeZdoDevControlUserDescriptorSetReq_t *req = NULL;
- req = (ZigbeeZdodevControlUserDescriptorSetReq_t *)request->request_data;
+ req = (ZigbeeZdoDevControlUserDescriptorSetReq_t *)request->request_data;
if (NULL != req) {
g_free(req);
}
}
break;
- case ZBLIB_ZDODEV_CONTROL_OPS_DEVICE_ANNOUNCE: {
- ZigbeeZdodevControlDeviceAnnounce_t *req = NULL;
+ case ZBLIB_ZDO_DEV_CONTROL_OPS_DEVICE_ANNOUNCE: {
+ ZigbeeZdoDevControlDeviceAnnounce_t *req = NULL;
- req = (ZigbeeZdodevControlDeviceAnnounce_t *)request->request_data;
+ req = (ZigbeeZdoDevControlDeviceAnnounce_t *)request->request_data;
if (NULL != req) {
g_free(req);
}
}
break;
- case ZBLIB_ZDODEV_CONTROL_OPS_SIMPLE_DESC_REQ: {
- ZigbeeZdodevControlSimpleDescriptorReq_t *req = NULL;
+ case ZBLIB_ZDO_DEV_CONTROL_OPS_SIMPLE_DESC_REQ: {
+ ZigbeeZdoDevControlSimpleDescriptorReq_t *req = NULL;
- req = (ZigbeeZdodevControlSimpleDescriptorReq_t *)request->request_data;
+ req = (ZigbeeZdoDevControlSimpleDescriptorReq_t *)request->request_data;
if (NULL != req) {
g_free(req);
}
}
break;
- case ZBLIB_ZDODEV_CONTROL_OPS_MGMT_LQI_REQ: {
- ZigbeeZdodevControlMgmtLqiReq_t *req = NULL;
+ case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_LQI_REQ: {
+ ZigbeeZdoDevControlMgmtLqiReq_t *req = NULL;
- req = (ZigbeeZdodevControlMgmtLqiReq_t *)request->request_data;
+ req = (ZigbeeZdoDevControlMgmtLqiReq_t *)request->request_data;
if (NULL != req) {
g_free(req);
}
}
break;
- case ZBLIB_ZDODEV_CONTROL_OPS_MGMT_RTG_REQ: {
- ZigbeeZdodevControlMgmtRtgReq_t *req = NULL;
+ case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_RTG_REQ: {
+ ZigbeeZdoDevControlMgmtRtgReq_t *req = NULL;
- req = (ZigbeeZdodevControlMgmtRtgReq_t *)request->request_data;
+ req = (ZigbeeZdoDevControlMgmtRtgReq_t *)request->request_data;
if (NULL != req) {
g_free(req);
}
}
break;
- case ZBLIB_ZDODEV_CONTROL_OPS_MGMT_BIND_REQ: {
- ZigbeeZdodevControlMgmtBindReq_t *req = NULL;
+ case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_BIND_REQ: {
+ ZigbeeZdoDevControlMgmtBindReq_t *req = NULL;
- req = (ZigbeeZdodevControlMgmtBindReq_t *)request->request_data;
+ req = (ZigbeeZdoDevControlMgmtBindReq_t *)request->request_data;
if (NULL != req) {
g_free(req);
}
}
break;
- case ZBLIB_ZDODEV_CONTROL_OPS_MGMT_PERMIT_JOIN_REQ: {
- ZigbeeZdodevControlMgmtPermitJoinReq_t *req = NULL;
+ case ZBLIB_ZDO_DEV_CONTROL_OPS_MGMT_PERMIT_JOIN_REQ: {
+ ZigbeeZdoDevControlMgmtPermitJoinReq_t *req = NULL;
- req = (ZigbeeZdodevControlMgmtPermitJoinReq_t *)request->request_data;
+ req = (ZigbeeZdoDevControlMgmtPermitJoinReq_t *)request->request_data;
if (NULL != req) {
g_free(req);
}
}
break;
- case ZBLIB_ZDODEV_CONTROL_OPS_NWK_UPDATE_REQ: {
- ZigbeeZdodevControlNwkUpdateReq_t *req = NULL;
+ case ZBLIB_ZDO_DEV_CONTROL_OPS_NWK_UPDATE_REQ: {
+ ZigbeeZdoDevControlNwkUpdateReq_t *req = NULL;
- req = (ZigbeeZdodevControlNwkUpdateReq_t *)request->request_data;
+ req = (ZigbeeZdoDevControlNwkUpdateReq_t *)request->request_data;
if (NULL != req) {
g_free(req);
}
}
break;
- case ZBLIB_ZDODEV_CONTROL_OPS_NWK_DISC_REQ: {
- ZigbeeZdodevControlNwkDescriptorReq_t *req = NULL;
+ case ZBLIB_ZDO_DEV_CONTROL_OPS_NWK_DISC_REQ: {
+ ZigbeeZdoDevControlNwkDescriptorReq_t *req = NULL;
- req = (ZigbeeZdodevControlNwkDescriptorReq_t *)request->request_data;
+ req = (ZigbeeZdoDevControlNwkDescriptorReq_t *)request->request_data;
if (NULL != req) {
g_free(req);
}
/* Fetch driver type */
driver_type = __zblib_request_get_driver_type(request_type);
switch (driver_type) {
- case ZBLIB_DRIVER_TYPE_ALARM: {
- __zblib_request_free_alarm_request_data(request, request_type);
+ case ZBLIB_DRIVER_TYPE_ZCL_ALARM: {
+ __zblib_request_free_zcl_alarm_request_data(request, request_type);
}
break;
}
break;
- case ZBLIB_DRIVER_TYPE_DOOR_LOCK: {
- __zblib_request_free_door_lock_request_data(request, request_type);
+ case ZBLIB_DRIVER_TYPE_ZCL_DOOR_LOCK: {
+ __zblib_request_free_zcl_door_lock_request_data(request, request_type);
}
break;
- case ZBLIB_DRIVER_TYPE_FAN_CONTROL: {
- __zblib_request_free_fan_control_request_data(request, request_type);
+ case ZBLIB_DRIVER_TYPE_ZCL_FAN_CONTROL: {
+ __zblib_request_free_zcl_fan_control_request_data(request, request_type);
}
break;
- case ZBLIB_DRIVER_TYPE_LEVEL_CONTROL: {
- __zblib_request_free_level_control_request_data(request, request_type);
+ case ZBLIB_DRIVER_TYPE_ZCL_LEVEL_CONTROL: {
+ __zblib_request_free_zcl_level_control_request_data(request, request_type);
}
break;
}
break;
- case ZBLIB_DRIVER_TYPE_ON_OFF: {
- __zblib_request_free_on_off_request_data(request, request_type);
+ case ZBLIB_DRIVER_TYPE_ZCL_ON_OFF: {
+ __zblib_request_free_zcl_on_off_request_data(request, request_type);
}
break;
}
break;
- case ZBLIB_DRIVER_TYPE_THERMOSTAT: {
- __zblib_request_free_thermostat_request_data(request, request_type);
+ case ZBLIB_DRIVER_TYPE_ZCL_THERMOSTAT: {
+ __zblib_request_free_zcl_thermostat_request_data(request, request_type);
}
break;
- case ZBLIB_DRIVER_TYPE_ZCLBASIC_CONTROL: {
- __zblib_request_free_zclbasic_control_request_data(request, request_type);
+ case ZBLIB_DRIVER_TYPE_ZCL_BASIC: {
+ __zblib_request_free_zcl_basic_request_data(request, request_type);
}
break;
- case ZBLIB_DRIVER_TYPE_ZCLGLOBAL_CONTROL: {
- __zblib_request_free_zclglobal_control_request_data(request, request_type);
+ case ZBLIB_DRIVER_TYPE_ZCL_GLOBAL_CONTROL: {
+ __zblib_request_free_zcl_global_control_request_data(request, request_type);
}
break;
- case ZBLIB_DRIVER_TYPE_ZCLIAS_CONTROL: {
- __zblib_request_free_zclias_control_request_data(request, request_type);
+ case ZBLIB_DRIVER_TYPE_ZCL_IAS_ZONE: {
+ __zblib_request_free_zcl_ias_zone_request_data(request, request_type);
}
break;
- case ZBLIB_DRIVER_TYPE_ZCLIDENTIFY_CONTROL: {
- __zblib_request_free_zclidentify_control_request_data(request, request_type);
+ case ZBLIB_DRIVER_TYPE_ZCL_IDENTIFY: {
+ __zblib_request_free_zcl_identify_request_data(request, request_type);
}
break;
- case ZBLIB_DRIVER_TYPE_ZCL_COLOR: {
- __zblib_request_free_zcl_color_request_data(request, request_type);
+ case ZBLIB_DRIVER_TYPE_ZCL_COLOR_CONTROL: {
+ __zblib_request_free_zcl_color_control_request_data(request, request_type);
}
break;
}
break;
- case ZBLIB_DRIVER_TYPE_ZDODEV_CONTROL: {
- __zblib_request_free_zdodev_control_request_data(request, request_type);
+ case ZBLIB_DRIVER_TYPE_ZDO_DEV_CONTROL: {
+ __zblib_request_free_zdo_dev_control_request_data(request, request_type);
}
break;
}
break;
- case ZBLIB_DRIVER_TYPE_NONE: /* Fallthrough */
+ case ZBLIB_DRIVER_TYPE_NONE: /* Fall through */
default: {
Z_LOGE("Unhandled driver type: [%d]", driver_type);
}
projects / platform / core / connectivity / zigbee-manager.git / commitdiff