?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
dcerpc-netlogon: maintain netlogon_auth_vars for NetrServerAuthenticateKerberos
[wireshark-sm.git] / epan / dissectors / packet-zbee-zcl-meas-sensing.c
blobd610b44b643f1faedc81d365fc3ac01cb663ffc1
1 /* packet-zbee-zcl-meas-sensing.c
2 * Dissector routines for the ZigBee ZCL Measurement & Sensing clusters like
3 * Illuminance Measurement, Temperature Measurement ...
4 * By Fabio Tarabelloni <fabio.tarabelloni@reloc.it>
5 * Copyright 2013 RELOC s.r.l.
6 *
7 * Wireshark - Network traffic analyzer
8 * By Gerald Combs <gerald@wireshark.org>
9 * Copyright 1998 Gerald Combs
10 *
11 * SPDX-License-Identifier: GPL-2.0-or-later
12 */
13
14 /* Include Files */
15 #include "config.h"
16
17 #include <math.h>
18 #include <epan/packet.h>
19
20 #include <wsutil/utf8_entities.h>
21
22 #include "packet-zbee.h"
23 #include "packet-zbee-aps.h"
24 #include "packet-zbee-zcl.h"
25
26
27 /* ########################################################################## */
28 /* #### (0x0400) ILLUMINANCE MEASUREMENT CLUSTER ############################ */
29 /* ########################################################################## */
30
31 /*************************/
32 /* Defines */
33 /*************************/
34
35 #define ZBEE_ZCL_ILLUM_MEAS_NUM_GENERIC_ETT 1
36 #define ZBEE_ZCL_ILLUM_MEAS_NUM_ETT ZBEE_ZCL_ILLUM_MEAS_NUM_GENERIC_ETT
37
38 /* Attributes */
39 #define ZBEE_ZCL_ATTR_ID_ILLUM_MEAS_MEASURED_VALUE 0x0000 /* Measured Value */
40 #define ZBEE_ZCL_ATTR_ID_ILLUM_MEAS_MIN_MEASURED_VALUE 0x0001 /* Min Measured Value */
41 #define ZBEE_ZCL_ATTR_ID_ILLUM_MEAS_MAX_MEASURED_VALUE 0x0002 /* Max Measured Value */
42 #define ZBEE_ZCL_ATTR_ID_ILLUM_MEAS_TOLERANCE 0x0003 /* Tolerance */
43 #define ZBEE_ZCL_ATTR_ID_ILLUM_MEAS_LIGHT_SENSOR_TYPE 0x0004 /* Light Sensor Type */
44
45 /* Server Commands Received - None */
46
47 /* Server Commands Generated - None */
48
49 #define ZBEE_ZCL_ATTR_ID_ILLUM_MEAS_TOO_LOW_VALUE 0x0000 /* Too Low Value */
50 #define ZBEE_ZCL_ATTR_ID_ILLUM_MEAS_INVALID_VALUE 0x8000 /* Invalid Value */
51
52 #define ZBEE_ZCL_ATTR_ID_ILLUM_MEAS_MIN_LO_VALUE 0x0002 /* Minimum Value (Low Bound) */
53 #define ZBEE_ZCL_ATTR_ID_ILLUM_MEAS_MIN_HI_VALUE 0xfffd /* Minimum Value (High Bound) */
54
55 #define ZBEE_ZCL_ATTR_ID_ILLUM_MEAS_MAX_LO_VALUE 0x0001 /* Maximum Value (Low Bound) */
56 #define ZBEE_ZCL_ATTR_ID_ILLUM_MEAS_MAX_HI_VALUE 0xfffe /* Maximum Value (High Bound) */
57
58 #define ZBEE_ZCL_ATTR_ID_ILLUM_MEAS_TOL_LO_VALUE 0x0000 /* Tolerance (Low Bound) */
59 #define ZBEE_ZCL_ATTR_ID_ILLUM_MEAS_TOL_HI_VALUE 0x0800 /* Tolerance (Low Bound) */
60
61 #define ZBEE_ZCL_ILLUM_MEAS_SENSOR_TYPE_PHOTODIODE 0x00 /* Photodiode */
62 #define ZBEE_ZCL_ILLUM_MEAS_SENSOR_TYPE_CMOS 0x01 /* CMOS */
63
64 /*************************/
65 /* Function Declarations */
66 /*************************/
67
68 void proto_register_zbee_zcl_illum_meas(void);
69 void proto_reg_handoff_zbee_zcl_illum_meas(void);
70
71 /* Command Dissector Helpers */
72 static void dissect_zcl_illum_meas_attr_data (proto_tree *tree, tvbuff_t *tvb, unsigned *offset, uint16_t attr_id, unsigned data_type, bool client_attr);
73
74 /* Private functions prototype */
75 static void decode_illum_meas_value (char *s, uint16_t value);
76 static void decode_illum_meas_min_value (char *s, uint16_t value);
77 static void decode_illum_meas_max_value (char *s, uint16_t value);
78 static void decode_illum_meas_tolerance (char *s, uint16_t value);
79
80 /*************************/
81 /* Global Variables */
82 /*************************/
83
84 /* Initialize the protocol and registered fields */
85 static int proto_zbee_zcl_illum_meas;
86
87 static int hf_zbee_zcl_illum_meas_attr_id;
88 static int hf_zbee_zcl_illum_meas_measured_value;
89 static int hf_zbee_zcl_illum_meas_min_measured_value;
90 static int hf_zbee_zcl_illum_meas_max_measured_value;
91 static int hf_zbee_zcl_illum_meas_tolerance;
92 static int hf_zbee_zcl_illum_meas_sensor_type;
93
94 /* Initialize the subtree pointers */
95 static int ett_zbee_zcl_illum_meas;
96
97 /* Attributes */
98 static const value_string zbee_zcl_illum_meas_attr_names[] = {
99 { ZBEE_ZCL_ATTR_ID_ILLUM_MEAS_MEASURED_VALUE, "Measured Value" },
100 { ZBEE_ZCL_ATTR_ID_ILLUM_MEAS_MIN_MEASURED_VALUE, "Min Measured Value" },
101 { ZBEE_ZCL_ATTR_ID_ILLUM_MEAS_MAX_MEASURED_VALUE, "Max Measured Value" },
102 { ZBEE_ZCL_ATTR_ID_ILLUM_MEAS_TOLERANCE, "Tolerance" },
103 { ZBEE_ZCL_ATTR_ID_ILLUM_MEAS_LIGHT_SENSOR_TYPE, "Light Sensor Type" },
104 { 0, NULL }
105 };
106
107 static const value_string zbee_zcl_illum_meas_sensor_type_names[] = {
108 { ZBEE_ZCL_ILLUM_MEAS_SENSOR_TYPE_PHOTODIODE, "Photodiode" },
109 { ZBEE_ZCL_ILLUM_MEAS_SENSOR_TYPE_CMOS, "CMOS" },
110 { 0, NULL }
111 };
112
113 /*************************/
114 /* Function Bodies */
115 /*************************/
116
117 /**
118 *ZigBee ZCL Illuminance Measurement cluster dissector for wireshark.
119 *
120 *@param tvb pointer to buffer containing raw packet.
121 *@param pinfo pointer to packet information fields
122 *@param tree pointer to data tree Wireshark uses to display packet.
123 */
124 static int
125 dissect_zbee_zcl_illum_meas(tvbuff_t *tvb _U_, packet_info *pinfo _U_, proto_tree *tree _U_, void* data _U_)
126 {
127 return tvb_captured_length(tvb);
128 } /*dissect_zbee_zcl_illum_meas*/
129
130 /**
131 *This function is called by ZCL foundation dissector in order to decode
132 *
133 *@param tree pointer to data tree Wireshark uses to display packet.
134 *@param tvb pointer to buffer containing raw packet.
135 *@param offset pointer to buffer offset
136 *@param attr_id attribute identifier
137 *@param data_type attribute data type
138 *@param client_attr ZCL client
139 */
140 static void
141 dissect_zcl_illum_meas_attr_data(proto_tree *tree, tvbuff_t *tvb, unsigned *offset, uint16_t attr_id, unsigned data_type, bool client_attr)
142 {
143 /* Dissect attribute data type and data */
144 switch ( attr_id ) {
145
146 case ZBEE_ZCL_ATTR_ID_ILLUM_MEAS_MEASURED_VALUE:
147 proto_tree_add_item(tree, hf_zbee_zcl_illum_meas_measured_value, tvb, *offset, 2, ENC_LITTLE_ENDIAN);
148 *offset += 2;
149 break;
150
151 case ZBEE_ZCL_ATTR_ID_ILLUM_MEAS_MIN_MEASURED_VALUE:
152 proto_tree_add_item(tree, hf_zbee_zcl_illum_meas_min_measured_value, tvb, *offset, 2, ENC_LITTLE_ENDIAN);
153 *offset += 2;
154 break;
155
156 case ZBEE_ZCL_ATTR_ID_ILLUM_MEAS_MAX_MEASURED_VALUE:
157 proto_tree_add_item(tree, hf_zbee_zcl_illum_meas_max_measured_value, tvb, *offset, 2, ENC_LITTLE_ENDIAN);
158 *offset += 2;
159 break;
160
161 case ZBEE_ZCL_ATTR_ID_ILLUM_MEAS_TOLERANCE:
162 proto_tree_add_item(tree, hf_zbee_zcl_illum_meas_tolerance, tvb, *offset, 2, ENC_LITTLE_ENDIAN);
163 *offset += 2;
164 break;
165
166 case ZBEE_ZCL_ATTR_ID_ILLUM_MEAS_LIGHT_SENSOR_TYPE:
167 proto_tree_add_item(tree, hf_zbee_zcl_illum_meas_sensor_type, tvb, *offset, 1, ENC_LITTLE_ENDIAN);
168 *offset += 1;
169 break;
170
171 default:
172 dissect_zcl_attr_data(tvb, tree, offset, data_type, client_attr);
173 break;
174 }
175 } /*dissect_zcl_illum_meas_attr_data*/
176
177 /**
178 *This function decodes illuminance value
179 *
180 *@param s string to display
181 *@param value value to decode
182 */
183 static void
184 decode_illum_meas_value(char *s, uint16_t value)
185 {
186 if (value == ZBEE_ZCL_ATTR_ID_ILLUM_MEAS_TOO_LOW_VALUE)
187 snprintf(s, ITEM_LABEL_LENGTH, "Value too low to be measured");
188 else if (value == ZBEE_ZCL_ATTR_ID_ILLUM_MEAS_INVALID_VALUE)
189 snprintf(s, ITEM_LABEL_LENGTH, "Invalid value");
190 else
191 /* calculate lux value from measured value according to doc 07-5123-04 */
192 snprintf(s, ITEM_LABEL_LENGTH, "%d (=%f [lx])", value, pow(10,value/10000.0)-1);
193
194 return;
195 } /*decode_illum_meas_value*/
196
197 /**
198 *This function decodes minimum illuminance value
199 *
200 *@param s string to display
201 *@param value value to decode
202 */
203 static void
204 decode_illum_meas_min_value(char *s, uint16_t value)
205 {
206 if ( (value < ZBEE_ZCL_ATTR_ID_ILLUM_MEAS_MIN_LO_VALUE) ||
207 (value > ZBEE_ZCL_ATTR_ID_ILLUM_MEAS_MIN_HI_VALUE) )
208 snprintf(s, ITEM_LABEL_LENGTH, "Out of range");
209 else
210 snprintf(s, ITEM_LABEL_LENGTH, "%d (=%f [lx])", value, pow(10,value/10000.0)-1);
211
212 return;
213 } /*decode_illum_meas_min_value*/
214
215 /**
216 *This function decodes maximum illuminance value
217 *
218 *@param s string to display
219 *@param value value to decode
220 */
221 static void
222 decode_illum_meas_max_value(char *s, uint16_t value)
223 {
224 if ( (value < ZBEE_ZCL_ATTR_ID_ILLUM_MEAS_MAX_LO_VALUE) ||
225 (value > ZBEE_ZCL_ATTR_ID_ILLUM_MEAS_MAX_HI_VALUE) )
226 snprintf(s, ITEM_LABEL_LENGTH, "Out of range");
227 else
228 snprintf(s, ITEM_LABEL_LENGTH, "%d (=%f [lx])", value, pow(10,value/10000.0)-1);
229
230 return;
231 } /*decode_illum_meas_max_value*/
232
233 /**
234 *This function decodes tolerance value
235 *
236 *@param s string to display
237 *@param value value to decode
238 */
239 static void
240 decode_illum_meas_tolerance(char *s, uint16_t value)
241 {
242 if (value > ZBEE_ZCL_ATTR_ID_ILLUM_MEAS_TOL_HI_VALUE)
243 snprintf(s, ITEM_LABEL_LENGTH, "Out of range");
244 else
245 snprintf(s, ITEM_LABEL_LENGTH, "%d", value);
246
247 return;
248 } /*decode_illum_meas_tolerance*/
249
250 /**
251 *This function registers the ZCL Illuminance Measurement dissector
252 *
253 */
254 void
255 proto_register_zbee_zcl_illum_meas(void)
256 {
257 static hf_register_info hf[] = {
258
259 { &hf_zbee_zcl_illum_meas_attr_id,
260 { "Attribute", "zbee_zcl_meas_sensing.illummeas.attr_id", FT_UINT16, BASE_HEX, VALS(zbee_zcl_illum_meas_attr_names),
261 0x0, NULL, HFILL } },
262
263 { &hf_zbee_zcl_illum_meas_measured_value,
264 { "Measured Value", "zbee_zcl_meas_sensing.illummeas.attr.value", FT_UINT16, BASE_CUSTOM, CF_FUNC(decode_illum_meas_value),
265 0x0, NULL, HFILL } },
266
267 { &hf_zbee_zcl_illum_meas_min_measured_value,
268 { "Min Measured Value", "zbee_zcl_meas_sensing.illummeas.attr.value.min", FT_UINT16, BASE_CUSTOM, CF_FUNC(decode_illum_meas_min_value),
269 0x0, NULL, HFILL } },
270
271 { &hf_zbee_zcl_illum_meas_max_measured_value,
272 { "Max Measured Value", "zbee_zcl_meas_sensing.illummeas.attr.value.max", FT_UINT16, BASE_CUSTOM, CF_FUNC(decode_illum_meas_max_value),
273 0x0, NULL, HFILL } },
274
275 { &hf_zbee_zcl_illum_meas_tolerance,
276 { "Tolerance", "zbee_zcl_meas_sensing.illummeas.attr.tolerance", FT_UINT16, BASE_CUSTOM, CF_FUNC(decode_illum_meas_tolerance),
277 0x0, NULL, HFILL } },
278
279 { &hf_zbee_zcl_illum_meas_sensor_type,
280 { "Sensor Type", "zbee_zcl_meas_sensing.illummeas.attr.sensor_type", FT_UINT8, BASE_HEX, VALS(zbee_zcl_illum_meas_sensor_type_names),
281 0x0, NULL, HFILL } }
282 };
283
284 /* ZCL Illuminance Measurement subtrees */
285 int *ett[] = {
286 &ett_zbee_zcl_illum_meas
287 };
288
289 /* Register the ZigBee ZCL Illuminance Measurement cluster protocol name and description */
290 proto_zbee_zcl_illum_meas = proto_register_protocol("ZigBee ZCL Illuminance Meas.", "ZCL Illuminance Meas.", ZBEE_PROTOABBREV_ZCL_ILLUMMEAS);
291 proto_register_field_array(proto_zbee_zcl_illum_meas, hf, array_length(hf));
292 proto_register_subtree_array(ett, array_length(ett));
293
294 /* Register the ZigBee ZCL Illuminance Measurement dissector. */
295 register_dissector(ZBEE_PROTOABBREV_ZCL_ILLUMMEAS, dissect_zbee_zcl_illum_meas, proto_zbee_zcl_illum_meas);
296
297 } /*proto_register_zbee_zcl_illum_meas*/
298
299
300 /**
301 *Hands off the ZCL Illuminance Measurement dissector.
302 *
303 */
304 void
305 proto_reg_handoff_zbee_zcl_illum_meas(void)
306 {
307 zbee_zcl_init_cluster( ZBEE_PROTOABBREV_ZCL_ILLUMMEAS,
308 proto_zbee_zcl_illum_meas,
309 ett_zbee_zcl_illum_meas,
310 ZBEE_ZCL_CID_ILLUMINANCE_MEASUREMENT,
311 ZBEE_MFG_CODE_NONE,
312 hf_zbee_zcl_illum_meas_attr_id,
313 hf_zbee_zcl_illum_meas_attr_id,
314 -1, -1,
315 (zbee_zcl_fn_attr_data)dissect_zcl_illum_meas_attr_data
316 );
317 } /*proto_reg_handoff_zbee_zcl_illum_meas*/
318
319
320 /* ########################################################################## */
321 /* #### (0x0401) ILLUMINANCE LEVEL SENSING CLUSTER ########################## */
322 /* ########################################################################## */
323
324 /*************************/
325 /* Defines */
326 /*************************/
327
328 #define ZBEE_ZCL_ILLUM_LEVEL_SEN_NUM_GENERIC_ETT 1
329 #define ZBEE_ZCL_ILLUM_LEVEL_SEN_NUM_ETT ZBEE_ZCL_ILLUM_LEVEL_SEN_NUM_GENERIC_ETT
330
331 /* Attributes */
332 #define ZBEE_ZCL_ATTR_ID_ILLUM_LEVEL_SEN_LEVEL_STATUS 0x0000 /* Level Status */
333 #define ZBEE_ZCL_ATTR_ID_ILLUM_LEVEL_SEN_LIGHT_SENSOR_TYPE 0x0001 /* Light Sensor Type */
334 #define ZBEE_ZCL_ATTR_ID_ILLUM_LEVEL_SEN_ILLUM_TARGET_LEVEL 0x0010 /* Illuminance Target Level */
335
336 /* Server Commands Received - None */
337
338 /* Server Commands Generated - None */
339
340 #define ZBEE_ZCL_ATTR_ID_ILLUM_LEVEL_SEN_TOO_LOW_VALUE 0x0000 /* Too Low Value */
341 #define ZBEE_ZCL_ATTR_ID_ILLUM_LEVEL_SEN_INVALID_VALUE 0x8000 /* Invalid Value */
342
343 #define ZBEE_ZCL_ILLUM_LEVEL_SEN_SENSOR_TYPE_PHOTODIODE 0x00 /* Photodiode */
344 #define ZBEE_ZCL_ILLUM_LEVEL_SEN_SENSOR_TYPE_CMOS 0x01 /* CMOS */
345
346 #define ZBEE_ZCL_ILLUM_LEVEL_SEN_ILLUM_ON_TARGET 0x00 /* Illuminance on Target */
347 #define ZBEE_ZCL_ILLUM_LEVEL_SEN_ILLUM_BELOW_TARGET 0x01 /* Illuminance below Target */
348 #define ZBEE_ZCL_ILLUM_LEVEL_SEN_ILLUM_ABOVE_TARGET 0x02 /* Illuminance above Target */
349
350 /*************************/
351 /* Function Declarations */
352 /*************************/
353
354 void proto_register_zbee_zcl_illum_level_sen(void);
355 void proto_reg_handoff_zbee_zcl_illum_level_sen(void);
356
357 /* Command Dissector Helpers */
358 static void dissect_zcl_illum_level_sen_attr_data (proto_tree *tree, tvbuff_t *tvb, unsigned *offset, uint16_t attr_id, unsigned data_type, bool client_attr);
359
360 /* Private functions prototype */
361 static void decode_illum_level_sen_target_level (char *s, uint16_t value);
362
363 /*************************/
364 /* Global Variables */
365 /*************************/
366
367 /* Initialize the protocol and registered fields */
368 static int proto_zbee_zcl_illum_level_sen;
369
370 static int hf_zbee_zcl_illum_level_sen_attr_id;
371 static int hf_zbee_zcl_illum_level_sen_level_status;
372 static int hf_zbee_zcl_illum_level_sen_light_sensor_type;
373 static int hf_zbee_zcl_illum_level_sen_illum_target_level;
374
375 /* Initialize the subtree pointers */
376 static int ett_zbee_zcl_illum_level_sen;
377
378 /* Attributes */
379 static const value_string zbee_zcl_illum_level_sen_attr_names[] = {
380 { ZBEE_ZCL_ATTR_ID_ILLUM_LEVEL_SEN_LEVEL_STATUS, "Level Status" },
381 { ZBEE_ZCL_ATTR_ID_ILLUM_LEVEL_SEN_LIGHT_SENSOR_TYPE, "Light Sensor Type" },
382 { ZBEE_ZCL_ATTR_ID_ILLUM_LEVEL_SEN_ILLUM_TARGET_LEVEL, "Illuminance Target Level" },
383 { 0, NULL }
384 };
385
386 static const value_string zbee_zcl_illum_level_sen_sensor_type_names[] = {
387 { ZBEE_ZCL_ILLUM_LEVEL_SEN_SENSOR_TYPE_PHOTODIODE, "Photodiode" },
388 { ZBEE_ZCL_ILLUM_LEVEL_SEN_SENSOR_TYPE_CMOS, "CMOS" },
389 { 0, NULL }
390 };
391
392 static const value_string zbee_zcl_illum_level_sen_level_status_names[] = {
393 { ZBEE_ZCL_ILLUM_LEVEL_SEN_ILLUM_ON_TARGET, "Illuminance on Target" },
394 { ZBEE_ZCL_ILLUM_LEVEL_SEN_ILLUM_BELOW_TARGET, "Illuminance below Target" },
395 { ZBEE_ZCL_ILLUM_LEVEL_SEN_ILLUM_ABOVE_TARGET, "Illuminance above Target" },
396 { 0, NULL }
397 };
398
399 /*************************/
400 /* Function Bodies */
401 /*************************/
402
403 /**
404 *ZigBee ZCL Illuminance Level Sensing cluster dissector for wireshark.
405 *
406 *@param tvb pointer to buffer containing raw packet.
407 *@param pinfo pointer to packet information fields
408 *@param tree pointer to data tree Wireshark uses to display packet.
409 */
410 static int
411 dissect_zbee_zcl_illum_level_sen(tvbuff_t *tvb _U_, packet_info *pinfo _U_, proto_tree *tree _U_, void* data _U_)
412 {
413 return tvb_captured_length(tvb);
414 } /*dissect_zbee_zcl_illum_level_sen*/
415
416 /**
417 *This function is called by ZCL foundation dissector in order to decode
418 *
419 *@param tree pointer to data tree Wireshark uses to display packet.
420 *@param tvb pointer to buffer containing raw packet.
421 *@param offset pointer to buffer offset
422 *@param attr_id attribute identifier
423 *@param data_type attribute data type
424 *@param client_attr ZCL client
425 */
426 static void
427 dissect_zcl_illum_level_sen_attr_data(proto_tree *tree, tvbuff_t *tvb, unsigned *offset, uint16_t attr_id, unsigned data_type, bool client_attr)
428 {
429 /* Dissect attribute data type and data */
430 switch ( attr_id ) {
431
432 case ZBEE_ZCL_ATTR_ID_ILLUM_LEVEL_SEN_LEVEL_STATUS:
433 proto_tree_add_item(tree, hf_zbee_zcl_illum_level_sen_level_status, tvb, *offset, 1, ENC_LITTLE_ENDIAN);
434 *offset += 1;
435 break;
436
437 case ZBEE_ZCL_ATTR_ID_ILLUM_LEVEL_SEN_LIGHT_SENSOR_TYPE:
438 proto_tree_add_item(tree, hf_zbee_zcl_illum_level_sen_light_sensor_type, tvb, *offset, 1, ENC_LITTLE_ENDIAN);
439 *offset += 1;
440 break;
441
442 case ZBEE_ZCL_ATTR_ID_ILLUM_LEVEL_SEN_ILLUM_TARGET_LEVEL:
443 proto_tree_add_item(tree, hf_zbee_zcl_illum_level_sen_illum_target_level, tvb, *offset, 2, ENC_LITTLE_ENDIAN);
444 *offset += 2;
445 break;
446
447 default:
448 dissect_zcl_attr_data(tvb, tree, offset, data_type, client_attr);
449 break;
450 }
451 } /*dissect_zcl_illum_level_sen_attr_data*/
452
453 /**
454 *This function decodes illuminance value
455 *
456 *@param s string to display
457 *@param value value to decode
458 */
459 static void
460 decode_illum_level_sen_target_level(char *s, uint16_t value)
461 {
462 if (value == ZBEE_ZCL_ATTR_ID_ILLUM_LEVEL_SEN_TOO_LOW_VALUE)
463 snprintf(s, ITEM_LABEL_LENGTH, "Value too low to be measured");
464 else if (value == ZBEE_ZCL_ATTR_ID_ILLUM_LEVEL_SEN_INVALID_VALUE)
465 snprintf(s, ITEM_LABEL_LENGTH, "Invalid value");
466 else
467 /* calculate lux value from measured value according to doc 07-5123-04 */
468 snprintf(s, ITEM_LABEL_LENGTH, "%d (=%f [lx])", value, pow(10,value/10000.0)-1);
469
470 return;
471 } /*decode_illum_level_sen_value*/
472
473 /**
474 *This function registers the ZCL Illuminance Level Sensing dissector
475 *
476 */
477 void
478 proto_register_zbee_zcl_illum_level_sen(void)
479 {
480 static hf_register_info hf[] = {
481
482 { &hf_zbee_zcl_illum_level_sen_attr_id,
483 { "Attribute", "zbee_zcl_meas_sensing.illumlevelsen.attr_id", FT_UINT16, BASE_HEX, VALS(zbee_zcl_illum_level_sen_attr_names),
484 0x0, NULL, HFILL } },
485
486 { &hf_zbee_zcl_illum_level_sen_level_status,
487 { "Level Status", "zbee_zcl_meas_sensing.illumlevelsen.attr.level_status", FT_UINT8, BASE_HEX, VALS(zbee_zcl_illum_level_sen_level_status_names),
488 0x0, NULL, HFILL } },
489
490 { &hf_zbee_zcl_illum_level_sen_light_sensor_type,
491 { "Light Sensor Type", "zbee_zcl_meas_sensing.illumlevelsen.attr.light_sensor_type", FT_UINT8, BASE_HEX, VALS(zbee_zcl_illum_level_sen_sensor_type_names),
492 0x0, NULL, HFILL } },
493
494 { &hf_zbee_zcl_illum_level_sen_illum_target_level,
495 { "Target Level", "zbee_zcl_meas_sensing.illumlevelsen.attr.target_level", FT_UINT16, BASE_CUSTOM, CF_FUNC(decode_illum_level_sen_target_level),
496 0x0, NULL, HFILL } }
497 };
498
499 /* ZCL Illuminance Level Sensing subtrees */
500 int *ett[] = {
501 &ett_zbee_zcl_illum_level_sen
502 };
503
504 /* Register the ZigBee ZCL Illuminance Level Sensing cluster protocol name and description */
505 proto_zbee_zcl_illum_level_sen = proto_register_protocol("ZigBee ZCL Illuminance Level Sensing", "ZCL Illuminance Level Sensing", ZBEE_PROTOABBREV_ZCL_ILLUMLEVELSEN);
506 proto_register_field_array(proto_zbee_zcl_illum_level_sen, hf, array_length(hf));
507 proto_register_subtree_array(ett, array_length(ett));
508
509 /* Register the ZigBee ZCL Illuminance Level Sensing dissector. */
510 register_dissector(ZBEE_PROTOABBREV_ZCL_ILLUMLEVELSEN, dissect_zbee_zcl_illum_level_sen, proto_zbee_zcl_illum_level_sen);
511
512 } /*proto_register_zbee_zcl_illum_level_sen*/
513
514
515 /**
516 *Hands off the ZCL Illuminance Level Sensing dissector.
517 *
518 */
519 void
520 proto_reg_handoff_zbee_zcl_illum_level_sen(void)
521 {
522 zbee_zcl_init_cluster( ZBEE_PROTOABBREV_ZCL_ILLUMLEVELSEN,
523 proto_zbee_zcl_illum_level_sen,
524 ett_zbee_zcl_illum_level_sen,
525 ZBEE_ZCL_CID_ILLUMINANCE_LEVEL_SENSING,
526 ZBEE_MFG_CODE_NONE,
527 hf_zbee_zcl_illum_level_sen_attr_id,
528 hf_zbee_zcl_illum_level_sen_attr_id,
529 -1, -1,
530 (zbee_zcl_fn_attr_data)dissect_zcl_illum_level_sen_attr_data
531 );
532 } /*proto_reg_handoff_zbee_zcl_illum_level_sen*/
533
534
535
536 /* ########################################################################## */
537 /* #### (0x0402) TEMPERATURE MEASUREMENT CLUSTER ############################ */
538 /* ########################################################################## */
539
540 /*************************/
541 /* Defines */
542 /*************************/
543
544 #define ZBEE_ZCL_TEMP_MEAS_NUM_GENERIC_ETT 1
545 #define ZBEE_ZCL_TEMP_MEAS_NUM_ETT ZBEE_ZCL_TEMP_MEAS_NUM_GENERIC_ETT
546
547 /* Attributes */
548 #define ZBEE_ZCL_ATTR_ID_TEMP_MEAS_MEASURED_VALUE 0x0000 /* Measured Value */
549 #define ZBEE_ZCL_ATTR_ID_TEMP_MEAS_MIN_MEASURED_VALUE 0x0001 /* Min Measured Value */
550 #define ZBEE_ZCL_ATTR_ID_TEMP_MEAS_MAX_MEASURED_VALUE 0x0002 /* Max Measured Value */
551 #define ZBEE_ZCL_ATTR_ID_TEMP_MEAS_TOLERANCE 0x0003 /* Tolerance */
552
553 /* Server Commands Received - None */
554
555 /* Server Commands Generated - None */
556
557 #define ZBEE_ZCL_ATTR_ID_TEMP_MEAS_INVALID_VALUE 0x8000 /* Invalid Value */
558
559 #define ZBEE_ZCL_ATTR_ID_TEMP_MEAS_MIN_LO_VALUE 0x954d /* Minimum Value (Low Bound) */
560 #define ZBEE_ZCL_ATTR_ID_TEMP_MEAS_MIN_HI_VALUE 0x7ffe /* Minimum Value (High Bound) */
561
562 #define ZBEE_ZCL_ATTR_ID_TEMP_MEAS_MAX_LO_VALUE 0x954e /* Maximum Value (Low Bound) */
563 #define ZBEE_ZCL_ATTR_ID_TEMP_MEAS_MAX_HI_VALUE 0x7fff /* Maximum Value (High Bound) */
564
565 #define ZBEE_ZCL_ATTR_ID_TEMP_MEAS_TOL_LO_VALUE 0x0000 /* Tolerance (Low Bound) */
566 #define ZBEE_ZCL_ATTR_ID_TEMP_MEAS_TOL_HI_VALUE 0x0800 /* Tolerance (Low Bound) */
567
568 /*************************/
569 /* Function Declarations */
570 /*************************/
571
572 void proto_register_zbee_zcl_temp_meas(void);
573 void proto_reg_handoff_zbee_zcl_temp_meas(void);
574
575 /* Command Dissector Helpers */
576 static void dissect_zcl_temp_meas_attr_data (proto_tree *tree, tvbuff_t *tvb, unsigned *offset, uint16_t attr_id, unsigned data_type, bool client_attr);
577
578 /* Private functions prototype */
579 static void decode_temp_meas_value (char *s, int16_t value);
580 static void decode_temp_meas_min_value (char *s, int16_t value);
581 static void decode_temp_meas_max_value (char *s, int16_t value);
582 static void decode_temp_meas_tolerance (char *s, uint16_t value);
583
584 /*************************/
585 /* Global Variables */
586 /*************************/
587
588 /* Initialize the protocol and registered fields */
589 static int proto_zbee_zcl_temp_meas;
590
591 static int hf_zbee_zcl_temp_meas_attr_id;
592 static int hf_zbee_zcl_temp_meas_measured_value;
593 static int hf_zbee_zcl_temp_meas_min_measured_value;
594 static int hf_zbee_zcl_temp_meas_max_measured_value;
595 static int hf_zbee_zcl_temp_meas_tolerance;
596
597 /* Initialize the subtree pointers */
598 static int ett_zbee_zcl_temp_meas;
599
600 /* Attributes */
601 static const value_string zbee_zcl_temp_meas_attr_names[] = {
602 { ZBEE_ZCL_ATTR_ID_TEMP_MEAS_MEASURED_VALUE, "Measured Value" },
603 { ZBEE_ZCL_ATTR_ID_TEMP_MEAS_MIN_MEASURED_VALUE, "Min Measured Value" },
604 { ZBEE_ZCL_ATTR_ID_TEMP_MEAS_MAX_MEASURED_VALUE, "Max Measured Value" },
605 { ZBEE_ZCL_ATTR_ID_TEMP_MEAS_TOLERANCE, "Tolerance" },
606 { 0, NULL }
607 };
608
609 /*************************/
610 /* Function Bodies */
611 /*************************/
612
613 /**
614 *ZigBee ZCL Temperature Measurement cluster dissector for wireshark.
615 *
616 *@param tvb pointer to buffer containing raw packet.
617 *@param pinfo pointer to packet information fields
618 *@param tree pointer to data tree Wireshark uses to display packet.
619 */
620 static int
621 dissect_zbee_zcl_temp_meas(tvbuff_t *tvb _U_, packet_info *pinfo _U_, proto_tree *tree _U_, void* data _U_)
622 {
623 return tvb_captured_length(tvb);
624 } /*dissect_zbee_zcl_temp_meas*/
625
626 /**
627 *This function is called by ZCL foundation dissector in order to decode
628 *
629 *@param tree pointer to data tree Wireshark uses to display packet.
630 *@param tvb pointer to buffer containing raw packet.
631 *@param offset pointer to buffer offset
632 *@param attr_id attribute identifier
633 *@param data_type attribute data type
634 *@param client_attr ZCL client
635 */
636 static void
637 dissect_zcl_temp_meas_attr_data(proto_tree *tree, tvbuff_t *tvb, unsigned *offset, uint16_t attr_id, unsigned data_type, bool client_attr)
638 {
639 /* Dissect attribute data type and data */
640 switch ( attr_id ) {
641
642 case ZBEE_ZCL_ATTR_ID_TEMP_MEAS_MEASURED_VALUE:
643 proto_tree_add_item(tree, hf_zbee_zcl_temp_meas_measured_value, tvb, *offset, 2, ENC_LITTLE_ENDIAN);
644 *offset += 2;
645 break;
646
647 case ZBEE_ZCL_ATTR_ID_TEMP_MEAS_MIN_MEASURED_VALUE:
648 proto_tree_add_item(tree, hf_zbee_zcl_temp_meas_min_measured_value, tvb, *offset, 2, ENC_LITTLE_ENDIAN);
649 *offset += 2;
650 break;
651
652 case ZBEE_ZCL_ATTR_ID_TEMP_MEAS_MAX_MEASURED_VALUE:
653 proto_tree_add_item(tree, hf_zbee_zcl_temp_meas_max_measured_value, tvb, *offset, 2, ENC_LITTLE_ENDIAN);
654 *offset += 2;
655 break;
656
657 case ZBEE_ZCL_ATTR_ID_TEMP_MEAS_TOLERANCE:
658 proto_tree_add_item(tree, hf_zbee_zcl_temp_meas_tolerance, tvb, *offset, 2, ENC_LITTLE_ENDIAN);
659 *offset += 2;
660 break;
661
662 default:
663 dissect_zcl_attr_data(tvb, tree, offset, data_type, client_attr);
664 break;
665 }
666
667 } /*dissect_zcl_temp_meas_attr_data*/
668
669 /**
670 *This function decodes temperature value
671 *
672 *@param s string to display
673 *@param value value to decode
674 */
675 static void
676 decode_temp_meas_value(char *s, int16_t value)
677 {
678 if (value == (int16_t)ZBEE_ZCL_ATTR_ID_TEMP_MEAS_INVALID_VALUE)
679 snprintf(s, ITEM_LABEL_LENGTH, "Invalid value");
680 else
681 snprintf(s, ITEM_LABEL_LENGTH, "%.2f [" UTF8_DEGREE_SIGN "C]", value/100.0);
682
683 return;
684 } /*decode_temp_meas_value*/
685
686 /**
687 *This function decodes minimum temperature value
688 *
689 *@param s string to display
690 *@param value value to decode
691 */
692 static void
693 decode_temp_meas_min_value(char *s, int16_t value)
694 {
695 if ( (value < (int16_t)ZBEE_ZCL_ATTR_ID_TEMP_MEAS_MIN_LO_VALUE) ||
696 (value > (int16_t)ZBEE_ZCL_ATTR_ID_TEMP_MEAS_MIN_HI_VALUE) )
697 snprintf(s, ITEM_LABEL_LENGTH, "Out of range");
698 else
699 snprintf(s, ITEM_LABEL_LENGTH, "%.2f [" UTF8_DEGREE_SIGN "C]", value/100.0);
700
701 return;
702 } /*decode_temp_meas_min_value*/
703
704 /**
705 *This function decodes maximum temperature value
706 *
707 *@param s string to display
708 *@param value value to decode
709 */
710 static void
711 decode_temp_meas_max_value(char *s, int16_t value)
712 {
713 if (value < (int16_t)ZBEE_ZCL_ATTR_ID_TEMP_MEAS_MAX_LO_VALUE)
714 snprintf(s, ITEM_LABEL_LENGTH, "Out of range");
715 else
716 snprintf(s, ITEM_LABEL_LENGTH, "%.2f [" UTF8_DEGREE_SIGN "C]", value/100.0);
717
718 return;
719 } /*decode_temp_meas_max_value*/
720
721 /**
722 *This function decodes tolerance value
723 *
724 *@param s string to display
725 *@param value value to decode
726 */
727 static void
728 decode_temp_meas_tolerance(char *s, uint16_t value)
729 {
730 if (value > ZBEE_ZCL_ATTR_ID_TEMP_MEAS_TOL_HI_VALUE)
731 snprintf(s, ITEM_LABEL_LENGTH, "Out of range");
732 else
733 snprintf(s, ITEM_LABEL_LENGTH, "%d.%d [" UTF8_DEGREE_SIGN "C]", value/100, value%100);
734
735 return;
736 } /*decode_temp_meas_tolerance*/
737
738 /**
739 *This function registers the ZCL Temperature Measurement dissector
740 *
741 */
742 void
743 proto_register_zbee_zcl_temp_meas(void)
744 {
745 static hf_register_info hf[] = {
746
747 { &hf_zbee_zcl_temp_meas_attr_id,
748 { "Attribute", "zbee_zcl_meas_sensing.tempmeas.attr_id", FT_UINT16, BASE_HEX, VALS(zbee_zcl_temp_meas_attr_names),
749 0x0, NULL, HFILL } },
750
751 { &hf_zbee_zcl_temp_meas_measured_value,
752 { "Measured Value", "zbee_zcl_meas_sensing.tempmeas.attr.value", FT_INT16, BASE_CUSTOM, CF_FUNC(decode_temp_meas_value),
753 0x0, NULL, HFILL } },
754
755 { &hf_zbee_zcl_temp_meas_min_measured_value,
756 { "Min Measured Value", "zbee_zcl_meas_sensing.tempmeas.attr.value.min", FT_INT16, BASE_CUSTOM, CF_FUNC(decode_temp_meas_min_value),
757 0x0, NULL, HFILL } },
758
759 { &hf_zbee_zcl_temp_meas_max_measured_value,
760 { "Max Measured Value", "zbee_zcl_meas_sensing.tempmeas.attr.value.max", FT_INT16, BASE_CUSTOM, CF_FUNC(decode_temp_meas_max_value),
761 0x0, NULL, HFILL } },
762
763 { &hf_zbee_zcl_temp_meas_tolerance,
764 { "Tolerance", "zbee_zcl_meas_sensing.tempmeas.attr.tolerance", FT_UINT16, BASE_CUSTOM, CF_FUNC(decode_temp_meas_tolerance),
765 0x0, NULL, HFILL } }
766
767 };
768
769 /* ZCL Temperature Measurement subtrees */
770 int *ett[] = {
771 &ett_zbee_zcl_temp_meas
772 };
773
774 /* Register the ZigBee ZCL Temperature Measurement cluster protocol name and description */
775 proto_zbee_zcl_temp_meas = proto_register_protocol("ZigBee ZCL Temperature Meas.", "ZCL Temperature Meas.", ZBEE_PROTOABBREV_ZCL_TEMPMEAS);
776 proto_register_field_array(proto_zbee_zcl_temp_meas, hf, array_length(hf));
777 proto_register_subtree_array(ett, array_length(ett));
778
779 /* Register the ZigBee ZCL Temperature Measurement dissector. */
780 register_dissector(ZBEE_PROTOABBREV_ZCL_TEMPMEAS, dissect_zbee_zcl_temp_meas, proto_zbee_zcl_temp_meas);
781 } /*proto_register_zbee_zcl_temp_meas*/
782
783 /**
784 *Hands off the ZCL Temperature Measurement dissector.
785 *
786 */
787 void
788 proto_reg_handoff_zbee_zcl_temp_meas(void)
789 {
790 zbee_zcl_init_cluster( ZBEE_PROTOABBREV_ZCL_TEMPMEAS,
791 proto_zbee_zcl_temp_meas,
792 ett_zbee_zcl_temp_meas,
793 ZBEE_ZCL_CID_TEMPERATURE_MEASUREMENT,
794 ZBEE_MFG_CODE_NONE,
795 hf_zbee_zcl_temp_meas_attr_id,
796 hf_zbee_zcl_temp_meas_attr_id,
797 -1, -1,
798 (zbee_zcl_fn_attr_data)dissect_zcl_temp_meas_attr_data
799 );
800 } /*proto_reg_handoff_zbee_zcl_temp_meas*/
801
802
803 /* ########################################################################## */
804 /* #### (0x0403) PRESSURE MEASUREMENT CLUSTER ############################### */
805 /* ########################################################################## */
806
807 /*************************/
808 /* Defines */
809 /*************************/
810
811 #define ZBEE_ZCL_PRESS_MEAS_NUM_GENERIC_ETT 1
812 #define ZBEE_ZCL_PRESS_MEAS_NUM_ETT ZBEE_ZCL_PRESS_MEAS_NUM_GENERIC_ETT
813
814 /* Attributes */
815 #define ZBEE_ZCL_ATTR_ID_PRESS_MEAS_MEASURED_VALUE 0x0000 /* Measured Value */
816 #define ZBEE_ZCL_ATTR_ID_PRESS_MEAS_MIN_MEASURED_VALUE 0x0001 /* Min Measured Value */
817 #define ZBEE_ZCL_ATTR_ID_PRESS_MEAS_MAX_MEASURED_VALUE 0x0002 /* Max Measured Value */
818 #define ZBEE_ZCL_ATTR_ID_PRESS_MEAS_TOLERANCE 0x0003 /* Tolerance */
819 #define ZBEE_ZCL_ATTR_ID_PRESS_MEAS_SCALED_VALUE 0x0010 /* Scaled Value */
820 #define ZBEE_ZCL_ATTR_ID_PRESS_MEAS_MIN_SCALED_VALUE 0x0011 /* Min Scaled Value */
821 #define ZBEE_ZCL_ATTR_ID_PRESS_MEAS_MAX_SCALED_VALUE 0x0012 /* Max Scaled Value */
822 #define ZBEE_ZCL_ATTR_ID_PRESS_MEAS_SCALED_TOLERANCE 0x0013 /* Scaled Tolerance */
823 #define ZBEE_ZCL_ATTR_ID_PRESS_MEAS_SCALE 0x0014 /* Scale */
824
825 /* Server Commands Received - None */
826
827 /* Server Commands Generated - None */
828
829 #define ZBEE_ZCL_ATTR_ID_PRESS_MEAS_INVALID_VALUE 0x8000 /* Invalid Value */
830
831 #define ZBEE_ZCL_ATTR_ID_PRESS_MEAS_MIN_LO_VALUE 0x8001 /* Minimum Value (Low Bound) */
832 #define ZBEE_ZCL_ATTR_ID_PRESS_MEAS_MIN_HI_VALUE 0x7ffe /* Minimum Value (High Bound) */
833
834 #define ZBEE_ZCL_ATTR_ID_PRESS_MEAS_MAX_LO_VALUE 0x8002 /* Maximum Value (Low Bound) */
835 #define ZBEE_ZCL_ATTR_ID_PRESS_MEAS_MAX_HI_VALUE 0x7fff /* Maximum Value (High Bound) */
836
837 #define ZBEE_ZCL_ATTR_ID_PRESS_MEAS_TOL_LO_VALUE 0x0000 /* Tolerance (Low Bound) */
838 #define ZBEE_ZCL_ATTR_ID_PRESS_MEAS_TOL_HI_VALUE 0x0800 /* Tolerance (Low Bound) */
839
840 #define ZBEE_ZCL_ATTR_ID_PRESS_MEAS_SCALE_LO_VALUE 0x81 /* Scale (Low Bound) */
841 #define ZBEE_ZCL_ATTR_ID_PRESS_MEAS_SCALE_HI_VALUE 0x7f /* Scale (Low Bound) */
842
843 /*************************/
844 /* Function Declarations */
845 /*************************/
846
847 void proto_register_zbee_zcl_press_meas(void);
848 void proto_reg_handoff_zbee_zcl_press_meas(void);
849
850 /* Command Dissector Helpers */
851 static void dissect_zcl_press_meas_attr_data (proto_tree *tree, tvbuff_t *tvb, unsigned *offset, uint16_t attr_id, unsigned data_type, bool client_attr);
852
853 /* Private functions prototype */
854 static void decode_press_meas_value (char *s, int16_t value);
855 static void decode_press_meas_min_value (char *s, int16_t value);
856 static void decode_press_meas_max_value (char *s, int16_t value);
857 static void decode_press_meas_tolerance (char *s, uint16_t value);
858
859 /*************************/
860 /* Global Variables */
861 /*************************/
862
863 /* Initialize the protocol and registered fields */
864 static int proto_zbee_zcl_press_meas;
865
866 static int hf_zbee_zcl_press_meas_attr_id;
867 static int hf_zbee_zcl_press_meas_measured_value;
868 static int hf_zbee_zcl_press_meas_min_measured_value;
869 static int hf_zbee_zcl_press_meas_max_measured_value;
870 static int hf_zbee_zcl_press_meas_tolerance;
871 static int hf_zbee_zcl_press_meas_scaled_value;
872 static int hf_zbee_zcl_press_meas_min_scaled_value;
873 static int hf_zbee_zcl_press_meas_max_scaled_value;
874 static int hf_zbee_zcl_press_meas_scaled_tolerance;
875 static int hf_zbee_zcl_press_meas_scale;
876
877 /* Initialize the subtree pointers */
878 static int ett_zbee_zcl_press_meas;
879
880 /* Attributes */
881 static const value_string zbee_zcl_press_meas_attr_names[] = {
882 { ZBEE_ZCL_ATTR_ID_PRESS_MEAS_MEASURED_VALUE, "Measured Value" },
883 { ZBEE_ZCL_ATTR_ID_PRESS_MEAS_MIN_MEASURED_VALUE, "Min Measured Value" },
884 { ZBEE_ZCL_ATTR_ID_PRESS_MEAS_MAX_MEASURED_VALUE, "Max Measured Value" },
885 { ZBEE_ZCL_ATTR_ID_PRESS_MEAS_TOLERANCE, "Tolerance" },
886 { ZBEE_ZCL_ATTR_ID_PRESS_MEAS_SCALED_VALUE, "Scaled Value" },
887 { ZBEE_ZCL_ATTR_ID_PRESS_MEAS_MIN_SCALED_VALUE, "Min Scaled Value" },
888 { ZBEE_ZCL_ATTR_ID_PRESS_MEAS_MAX_SCALED_VALUE, "Max Scaled Value" },
889 { ZBEE_ZCL_ATTR_ID_PRESS_MEAS_SCALED_TOLERANCE, "Scaled Tolerance" },
890 { ZBEE_ZCL_ATTR_ID_PRESS_MEAS_SCALE, "Scale" },
891 { 0, NULL }
892 };
893
894 /*************************/
895 /* Function Bodies */
896 /*************************/
897
898 /**
899 *ZigBee ZCL Pressure Measurement cluster dissector for wireshark.
900 *
901 *@param tvb pointer to buffer containing raw packet.
902 *@param pinfo pointer to packet information fields
903 *@param tree pointer to data tree Wireshark uses to display packet.
904 */
905 static int
906 dissect_zbee_zcl_press_meas(tvbuff_t *tvb _U_, packet_info *pinfo _U_, proto_tree *tree _U_, void* data _U_)
907 {
908 return tvb_captured_length(tvb);
909 } /*dissect_zbee_zcl_press_meas*/
910
911 /**
912 *This function is called by ZCL foundation dissector in order to decode
913 *
914 *@param tree pointer to data tree Wireshark uses to display packet.
915 *@param tvb pointer to buffer containing raw packet.
916 *@param offset pointer to buffer offset
917 *@param attr_id attribute identifier
918 *@param data_type attribute data type
919 *@param client_attr ZCL client
920 */
921 static void
922 dissect_zcl_press_meas_attr_data(proto_tree *tree, tvbuff_t *tvb, unsigned *offset, uint16_t attr_id, unsigned data_type, bool client_attr)
923 {
924 /* Dissect attribute data type and data */
925 switch ( attr_id ) {
926
927 case ZBEE_ZCL_ATTR_ID_PRESS_MEAS_MEASURED_VALUE:
928 proto_tree_add_item(tree, hf_zbee_zcl_press_meas_measured_value, tvb, *offset, 2, ENC_LITTLE_ENDIAN);
929 *offset += 2;
930 break;
931
932 case ZBEE_ZCL_ATTR_ID_PRESS_MEAS_MIN_MEASURED_VALUE:
933 proto_tree_add_item(tree, hf_zbee_zcl_press_meas_min_measured_value, tvb, *offset, 2, ENC_LITTLE_ENDIAN);
934 *offset += 2;
935 break;
936
937 case ZBEE_ZCL_ATTR_ID_PRESS_MEAS_MAX_MEASURED_VALUE:
938 proto_tree_add_item(tree, hf_zbee_zcl_press_meas_max_measured_value, tvb, *offset, 2, ENC_LITTLE_ENDIAN);
939 *offset += 2;
940 break;
941
942 case ZBEE_ZCL_ATTR_ID_PRESS_MEAS_TOLERANCE:
943 proto_tree_add_item(tree, hf_zbee_zcl_press_meas_tolerance, tvb, *offset, 2, ENC_LITTLE_ENDIAN);
944 *offset += 2;
945 break;
946
947 case ZBEE_ZCL_ATTR_ID_PRESS_MEAS_SCALED_VALUE:
948 proto_tree_add_item(tree, hf_zbee_zcl_press_meas_scaled_value, tvb, *offset, 2, ENC_LITTLE_ENDIAN);
949 *offset += 2;
950 break;
951
952 case ZBEE_ZCL_ATTR_ID_PRESS_MEAS_MIN_SCALED_VALUE:
953 proto_tree_add_item(tree, hf_zbee_zcl_press_meas_min_scaled_value, tvb, *offset, 2, ENC_LITTLE_ENDIAN);
954 *offset += 2;
955 break;
956
957 case ZBEE_ZCL_ATTR_ID_PRESS_MEAS_MAX_SCALED_VALUE:
958 proto_tree_add_item(tree, hf_zbee_zcl_press_meas_max_scaled_value, tvb, *offset, 2, ENC_LITTLE_ENDIAN);
959 *offset += 2;
960 break;
961
962 case ZBEE_ZCL_ATTR_ID_PRESS_MEAS_SCALED_TOLERANCE:
963 proto_tree_add_item(tree, hf_zbee_zcl_press_meas_scaled_tolerance, tvb, *offset, 2, ENC_LITTLE_ENDIAN);
964 *offset += 2;
965 break;
966
967 case ZBEE_ZCL_ATTR_ID_PRESS_MEAS_SCALE:
968 proto_tree_add_item(tree, hf_zbee_zcl_press_meas_scale, tvb, *offset, 1, ENC_LITTLE_ENDIAN);
969 *offset += 1;
970 break;
971
972 default:
973 dissect_zcl_attr_data(tvb, tree, offset, data_type, client_attr);
974 break;
975 }
976 } /*dissect_zcl_press_meas_attr_data*/
977
978 /**
979 *This function decodes pressure value
980 *
981 *@param s string to display
982 *@param value value to decode
983 */
984 static void
985 decode_press_meas_value(char *s, int16_t value)
986 {
987 if (value == (int16_t)ZBEE_ZCL_ATTR_ID_PRESS_MEAS_INVALID_VALUE)
988 snprintf(s, ITEM_LABEL_LENGTH, "Invalid value");
989 if (value < (int16_t)ZBEE_ZCL_ATTR_ID_PRESS_MEAS_MIN_LO_VALUE)
990 snprintf(s, ITEM_LABEL_LENGTH, "Out of range");
991 else
992 snprintf(s, ITEM_LABEL_LENGTH, "%d.%d [kPa]", value/10, value%10);
993
994 return;
995 } /*decode_press_meas_value*/
996
997 /**
998 *This function decodes minimum pressure value
999 *
1000 *@param s string to display
1001 *@param value value to decode
1002 */
1003 static void
1004 decode_press_meas_min_value(char *s, int16_t value)
1005 {
1006 if (value > (int16_t)ZBEE_ZCL_ATTR_ID_PRESS_MEAS_MIN_HI_VALUE)
1007 snprintf(s, ITEM_LABEL_LENGTH, "Out of range");
1008 else
1009 snprintf(s, ITEM_LABEL_LENGTH, "%d.%d [kPa]", value/10, value%10);
1010
1011 return;
1012 } /*decode_press_meas_min_value*/
1013
1014 /**
1015 *This function decodes maximum pressure value
1016 *
1017 *@param s string to display
1018 *@param value value to decode
1019 */
1020 static void
1021 decode_press_meas_max_value(char *s, int16_t value)
1022 {
1023 if (value < (int16_t)ZBEE_ZCL_ATTR_ID_PRESS_MEAS_MAX_LO_VALUE)
1024 snprintf(s, ITEM_LABEL_LENGTH, "Out of range");
1025 else
1026 snprintf(s, ITEM_LABEL_LENGTH, "%d.%d [kPa]", value/10, value%10);
1027
1028 return;
1029 } /*decode_press_meas_max_value*/
1030
1031 /**
1032 *This function decodes tolerance value
1033 *
1034 *@param s string to display
1035 *@param value value to decode
1036 */
1037 static void
1038 decode_press_meas_tolerance(char *s, uint16_t value)
1039 {
1040 if (value > (uint16_t)ZBEE_ZCL_ATTR_ID_PRESS_MEAS_TOL_HI_VALUE)
1041 snprintf(s, ITEM_LABEL_LENGTH, "Out of range");
1042 else
1043 snprintf(s, ITEM_LABEL_LENGTH, "%d.%d [kPa]", value/10, value%10);
1044
1045 return;
1046 } /*decode_press_meas_tolerance*/
1047
1048 /**
1049 *This function registers the ZCL Pressure Measurement dissector
1050 *
1051 */
1052 void
1053 proto_register_zbee_zcl_press_meas(void)
1054 {
1055 static hf_register_info hf[] = {
1056
1057 { &hf_zbee_zcl_press_meas_attr_id,
1058 { "Attribute", "zbee_zcl_meas_sensing.pressmeas.attr_id", FT_UINT16, BASE_HEX, VALS(zbee_zcl_press_meas_attr_names),
1059 0x0, NULL, HFILL } },
1060
1061 { &hf_zbee_zcl_press_meas_measured_value,
1062 { "Measured Value", "zbee_zcl_meas_sensing.pressmeas.attr.value", FT_INT16, BASE_CUSTOM, CF_FUNC(decode_press_meas_value),
1063 0x0, NULL, HFILL } },
1064
1065 { &hf_zbee_zcl_press_meas_min_measured_value,
1066 { "Min Measured Value", "zbee_zcl_meas_sensing.pressmeas.attr.value.min", FT_INT16, BASE_CUSTOM, CF_FUNC(decode_press_meas_min_value),
1067 0x0, NULL, HFILL } },
1068
1069 { &hf_zbee_zcl_press_meas_max_measured_value,
1070 { "Max Measured Value", "zbee_zcl_meas_sensing.pressmeas.attr.value.max", FT_INT16, BASE_CUSTOM, CF_FUNC(decode_press_meas_max_value),
1071 0x0, NULL, HFILL } },
1072
1073 { &hf_zbee_zcl_press_meas_tolerance,
1074 { "Tolerance", "zbee_zcl_meas_sensing.pressmeas.attr.tolerance", FT_UINT16, BASE_CUSTOM, CF_FUNC(decode_press_meas_tolerance),
1075 0x0, NULL, HFILL } },
1076
1077 { &hf_zbee_zcl_press_meas_scaled_value,
1078 { "Scaled Value", "zbee_zcl_meas_sensing.pressmeas.attr.scaled_value", FT_INT16, BASE_DEC, NULL,
1079 0x0, NULL, HFILL } },
1080
1081 { &hf_zbee_zcl_press_meas_min_scaled_value,
1082 { "Min Scaled Value", "zbee_zcl_meas_sensing.pressmeas.attr.scaled_value.min", FT_INT16, BASE_DEC, NULL,
1083 0x0, NULL, HFILL } },
1084
1085 { &hf_zbee_zcl_press_meas_max_scaled_value,
1086 { "Max Scaled Value", "zbee_zcl_meas_sensing.pressmeas.attr.scaled_value.max", FT_INT16, BASE_DEC, NULL,
1087 0x0, NULL, HFILL } },
1088
1089 { &hf_zbee_zcl_press_meas_scaled_tolerance,
1090 { "Scaled Tolerance", "zbee_zcl_meas_sensing.pressmeas.attr.scaled_tolerance", FT_UINT16, BASE_DEC, NULL,
1091 0x0, NULL, HFILL } },
1092
1093 { &hf_zbee_zcl_press_meas_scale,
1094 { "Scale", "zbee_zcl_meas_sensing.pressmeas.attr.scale", FT_UINT8, BASE_DEC, NULL,
1095 0x0, NULL, HFILL } }
1096
1097 };
1098
1099 /* ZCL Pressure Measurement subtrees */
1100 int *ett[] = {
1101 &ett_zbee_zcl_press_meas
1102 };
1103
1104 /* Register the ZigBee ZCL Pressure Measurement cluster protocol name and description */
1105 proto_zbee_zcl_press_meas = proto_register_protocol("ZigBee ZCL Pressure Meas.", "ZCL Pressure Meas.", ZBEE_PROTOABBREV_ZCL_PRESSMEAS);
1106 proto_register_field_array(proto_zbee_zcl_press_meas, hf, array_length(hf));
1107 proto_register_subtree_array(ett, array_length(ett));
1108
1109 /* Register the ZigBee ZCL Pressure Measurement dissector. */
1110 register_dissector(ZBEE_PROTOABBREV_ZCL_PRESSMEAS, dissect_zbee_zcl_press_meas, proto_zbee_zcl_press_meas);
1111 } /*proto_register_zbee_zcl_press_meas*/
1112
1113 /**
1114 *Hands off the ZCL Pressure Measurement dissector.
1115 *
1116 */
1117 void
1118 proto_reg_handoff_zbee_zcl_press_meas(void)
1119 {
1120 zbee_zcl_init_cluster( ZBEE_PROTOABBREV_ZCL_PRESSMEAS,
1121 proto_zbee_zcl_press_meas,
1122 ett_zbee_zcl_press_meas,
1123 ZBEE_ZCL_CID_PRESSURE_MEASUREMENT,
1124 ZBEE_MFG_CODE_NONE,
1125 hf_zbee_zcl_press_meas_attr_id,
1126 hf_zbee_zcl_press_meas_attr_id,
1127 -1, -1,
1128 (zbee_zcl_fn_attr_data)dissect_zcl_press_meas_attr_data
1129 );
1130 } /*proto_reg_handoff_zbee_zcl_press_meas*/
1131
1132 /* ########################################################################## */
1133 /* #### (0x0404) FLOW MEASUREMENT CLUSTER ################################### */
1134 /* ########################################################################## */
1135
1136 /*************************/
1137 /* Defines */
1138 /*************************/
1139
1140 #define ZBEE_ZCL_FLOW_MEAS_NUM_GENERIC_ETT 1
1141 #define ZBEE_ZCL_FLOW_MEAS_NUM_ETT ZBEE_ZCL_FLOW_MEAS_NUM_GENERIC_ETT
1142
1143 /* Attributes */
1144 #define ZBEE_ZCL_ATTR_ID_FLOW_MEAS_MEASURED_VALUE 0x0000 /* Measured Value */
1145 #define ZBEE_ZCL_ATTR_ID_FLOW_MEAS_MIN_MEASURED_VALUE 0x0001 /* Min Measured Value */
1146 #define ZBEE_ZCL_ATTR_ID_FLOW_MEAS_MAX_MEASURED_VALUE 0x0002 /* Max Measured Value */
1147 #define ZBEE_ZCL_ATTR_ID_FLOW_MEAS_TOLERANCE 0x0003 /* Tolerance */
1148
1149 /* Server Commands Received - None */
1150
1151 /* Server Commands Generated - None */
1152
1153 #define ZBEE_ZCL_ATTR_ID_FLOW_MEAS_TOO_LOW_VALUE 0x0000 /* Too Low Value */
1154 #define ZBEE_ZCL_ATTR_ID_FLOW_MEAS_INVALID_VALUE 0xffff /* Invalid Value */
1155
1156 #define ZBEE_ZCL_ATTR_ID_FLOW_MEAS_MIN_LO_VALUE 0x0000 /* Minimum Value (Low Bound) */
1157 #define ZBEE_ZCL_ATTR_ID_FLOW_MEAS_MIN_HI_VALUE 0xfffd /* Minimum Value (High Bound) */
1158
1159 #define ZBEE_ZCL_ATTR_ID_FLOW_MEAS_MAX_LO_VALUE 0x0001 /* Maximum Value (Low Bound) */
1160 #define ZBEE_ZCL_ATTR_ID_FLOW_MEAS_MAX_HI_VALUE 0xfffe /* Maximum Value (High Bound) */
1161
1162 #define ZBEE_ZCL_ATTR_ID_FLOW_MEAS_TOL_LO_VALUE 0x0000 /* Tolerance (Low Bound) */
1163 #define ZBEE_ZCL_ATTR_ID_FLOW_MEAS_TOL_HI_VALUE 0x0800 /* Tolerance (Low Bound) */
1164
1165 /*************************/
1166 /* Function Declarations */
1167 /*************************/
1168
1169 void proto_register_zbee_zcl_flow_meas(void);
1170 void proto_reg_handoff_zbee_zcl_flow_meas(void);
1171
1172 /* Command Dissector Helpers */
1173 static void dissect_zcl_flow_meas_attr_data (proto_tree *tree, tvbuff_t *tvb, unsigned *offset, uint16_t attr_id, unsigned data_type, bool client_attr);
1174
1175 /* Private functions prototype */
1176 static void decode_flow_meas_value (char *s, uint16_t value);
1177 static void decode_flow_meas_min_value (char *s, uint16_t value);
1178 static void decode_flow_meas_max_value (char *s, uint16_t value);
1179 static void decode_flow_meas_tolerance (char *s, uint16_t value);
1180
1181 /*************************/
1182 /* Global Variables */
1183 /*************************/
1184
1185 /* Initialize the protocol and registered fields */
1186 static int proto_zbee_zcl_flow_meas;
1187
1188 static int hf_zbee_zcl_flow_meas_attr_id;
1189 static int hf_zbee_zcl_flow_meas_measured_value;
1190 static int hf_zbee_zcl_flow_meas_min_measured_value;
1191 static int hf_zbee_zcl_flow_meas_max_measured_value;
1192 static int hf_zbee_zcl_flow_meas_tolerance;
1193
1194 /* Initialize the subtree pointers */
1195 static int ett_zbee_zcl_flow_meas;
1196
1197 /* Attributes */
1198 static const value_string zbee_zcl_flow_meas_attr_names[] = {
1199 { ZBEE_ZCL_ATTR_ID_FLOW_MEAS_MEASURED_VALUE, "Measured Value" },
1200 { ZBEE_ZCL_ATTR_ID_FLOW_MEAS_MIN_MEASURED_VALUE, "Min Measured Value" },
1201 { ZBEE_ZCL_ATTR_ID_FLOW_MEAS_MAX_MEASURED_VALUE, "Max Measured Value" },
1202 { ZBEE_ZCL_ATTR_ID_FLOW_MEAS_TOLERANCE, "Tolerance" },
1203 { 0, NULL }
1204 };
1205
1206 /*************************/
1207 /* Function Bodies */
1208 /*************************/
1209
1210 /**
1211 *ZigBee ZCL Flow Measurement cluster dissector for wireshark.
1212 *
1213 *@param tvb pointer to buffer containing raw packet.
1214 *@param pinfo pointer to packet information fields
1215 *@param tree pointer to data tree Wireshark uses to display packet.
1216 */
1217 static int
1218 dissect_zbee_zcl_flow_meas(tvbuff_t *tvb _U_, packet_info *pinfo _U_, proto_tree *tree _U_, void* data _U_)
1219 {
1220 return tvb_captured_length(tvb);
1221 } /*dissect_zbee_zcl_flow_meas*/
1222
1223 /**
1224 *This function is called by ZCL foundation dissector in order to decode
1225 *
1226 *@param tree pointer to data tree Wireshark uses to display packet.
1227 *@param tvb pointer to buffer containing raw packet.
1228 *@param offset pointer to buffer offset
1229 *@param attr_id attribute identifier
1230 *@param data_type attribute data type
1231 *@param client_attr ZCL client
1232 */
1233 static void
1234 dissect_zcl_flow_meas_attr_data(proto_tree *tree, tvbuff_t *tvb, unsigned *offset, uint16_t attr_id, unsigned data_type, bool client_attr)
1235 {
1236 /* Dissect attribute data type and data */
1237 switch ( attr_id ) {
1238
1239 case ZBEE_ZCL_ATTR_ID_FLOW_MEAS_MEASURED_VALUE:
1240 proto_tree_add_item(tree, hf_zbee_zcl_flow_meas_measured_value, tvb, *offset, 2, ENC_LITTLE_ENDIAN);
1241 *offset += 2;
1242 break;
1243
1244 case ZBEE_ZCL_ATTR_ID_FLOW_MEAS_MIN_MEASURED_VALUE:
1245 proto_tree_add_item(tree, hf_zbee_zcl_flow_meas_min_measured_value, tvb, *offset, 2, ENC_LITTLE_ENDIAN);
1246 *offset += 2;
1247 break;
1248
1249 case ZBEE_ZCL_ATTR_ID_FLOW_MEAS_MAX_MEASURED_VALUE:
1250 proto_tree_add_item(tree, hf_zbee_zcl_flow_meas_max_measured_value, tvb, *offset, 2, ENC_LITTLE_ENDIAN);
1251 *offset += 2;
1252 break;
1253
1254 case ZBEE_ZCL_ATTR_ID_FLOW_MEAS_TOLERANCE:
1255 proto_tree_add_item(tree, hf_zbee_zcl_flow_meas_tolerance, tvb, *offset, 2, ENC_LITTLE_ENDIAN);
1256 *offset += 2;
1257 break;
1258
1259 default:
1260 dissect_zcl_attr_data(tvb, tree, offset, data_type, client_attr);
1261 break;
1262 }
1263 } /*dissect_zcl_flow_meas_attr_data*/
1264
1265 /**
1266 *This function decodes flow value
1267 *
1268 *@param s string to display
1269 *@param value value to decode
1270 */
1271 static void
1272 decode_flow_meas_value(char *s, uint16_t value)
1273 {
1274 if (value == ZBEE_ZCL_ATTR_ID_FLOW_MEAS_TOO_LOW_VALUE)
1275 snprintf(s, ITEM_LABEL_LENGTH, "Value too low to be measured");
1276 else if (value == ZBEE_ZCL_ATTR_ID_FLOW_MEAS_INVALID_VALUE)
1277 snprintf(s, ITEM_LABEL_LENGTH, "Invalid value");
1278 else
1279 /* calculate flow value from measured value according to doc 07-5123-04 */
1280 snprintf(s, ITEM_LABEL_LENGTH, "%d (=%f [m^3/h])", value, value/10.0);
1281
1282 return;
1283 } /*decode_flow_meas_value*/
1284
1285 /**
1286 *This function decodes minimum flow value
1287 *
1288 *@param s string to display
1289 *@param value value to decode
1290 */
1291 static void
1292 decode_flow_meas_min_value(char *s, uint16_t value)
1293 {
1294 if ( /*(value < ZBEE_ZCL_ATTR_ID_FLOW_MEAS_MIN_LO_VALUE) ||*/
1295 (value > ZBEE_ZCL_ATTR_ID_FLOW_MEAS_MIN_HI_VALUE) )
1296 snprintf(s, ITEM_LABEL_LENGTH, "Out of range");
1297 else
1298 snprintf(s, ITEM_LABEL_LENGTH, "%d (=%f [m^3/h])", value, value/10.0);
1299
1300 return;
1301 } /*decode_flow_meas_min_value*/
1302
1303 /**
1304 *This function decodes maximum flow value
1305 *
1306 *@param s string to display
1307 *@param value value to decode
1308 */
1309 static void
1310 decode_flow_meas_max_value(char *s, uint16_t value)
1311 {
1312 if ( (value < ZBEE_ZCL_ATTR_ID_FLOW_MEAS_MAX_LO_VALUE) ||
1313 (value > ZBEE_ZCL_ATTR_ID_FLOW_MEAS_MAX_HI_VALUE) )
1314 snprintf(s, ITEM_LABEL_LENGTH, "Out of range");
1315 else
1316 snprintf(s, ITEM_LABEL_LENGTH, "%d (=%f [m^3/h])", value, value/10.0);
1317
1318 return;
1319 } /*decode_flow_meas_max_value*/
1320
1321 /**
1322 *This function decodes tolerance value
1323 *
1324 *@param s string to display
1325 *@param value value to decode
1326 */
1327 static void
1328 decode_flow_meas_tolerance(char *s, uint16_t value)
1329 {
1330 if (value > ZBEE_ZCL_ATTR_ID_FLOW_MEAS_TOL_HI_VALUE)
1331 snprintf(s, ITEM_LABEL_LENGTH, "Out of range");
1332 else
1333 snprintf(s, ITEM_LABEL_LENGTH, "%d", value);
1334
1335 return;
1336 } /*decode_flow_meas_tolerance*/
1337
1338 /**
1339 *This function registers the ZCL Flow Measurement dissector
1340 *
1341 */
1342 void
1343 proto_register_zbee_zcl_flow_meas(void)
1344 {
1345 static hf_register_info hf[] = {
1346
1347 { &hf_zbee_zcl_flow_meas_attr_id,
1348 { "Attribute", "zbee_zcl_meas_sensing.flowmeas.attr_id", FT_UINT16, BASE_HEX, VALS(zbee_zcl_flow_meas_attr_names),
1349 0x0, NULL, HFILL } },
1350
1351 { &hf_zbee_zcl_flow_meas_measured_value,
1352 { "Measured Value", "zbee_zcl_meas_sensing.flowmeas.attr.value", FT_UINT16, BASE_CUSTOM, CF_FUNC(decode_flow_meas_value),
1353 0x0, NULL, HFILL } },
1354
1355 { &hf_zbee_zcl_flow_meas_min_measured_value,
1356 { "Min Measured Value", "zbee_zcl_meas_sensing.flowmeas.attr.value.min", FT_UINT16, BASE_CUSTOM, CF_FUNC(decode_flow_meas_min_value),
1357 0x0, NULL, HFILL } },
1358
1359 { &hf_zbee_zcl_flow_meas_max_measured_value,
1360 { "Max Measured Value", "zbee_zcl_meas_sensing.flowmeas.attr.value.max", FT_UINT16, BASE_CUSTOM, CF_FUNC(decode_flow_meas_max_value),
1361 0x0, NULL, HFILL } },
1362
1363 { &hf_zbee_zcl_flow_meas_tolerance,
1364 { "Tolerance", "zbee_zcl_meas_sensing.flowmeas.attr.tolerance", FT_UINT16, BASE_CUSTOM, CF_FUNC(decode_flow_meas_tolerance),
1365 0x0, NULL, HFILL } }
1366 };
1367
1368 /* ZCL Flow Measurement subtrees */
1369 int *ett[] = {
1370 &ett_zbee_zcl_flow_meas
1371 };
1372
1373 /* Register the ZigBee ZCL Flow Measurement cluster protocol name and description */
1374 proto_zbee_zcl_flow_meas = proto_register_protocol("ZigBee ZCL Flow Meas.", "ZCL Flow Meas.", ZBEE_PROTOABBREV_ZCL_FLOWMEAS);
1375 proto_register_field_array(proto_zbee_zcl_flow_meas, hf, array_length(hf));
1376 proto_register_subtree_array(ett, array_length(ett));
1377
1378 /* Register the ZigBee ZCL Flow Measurement dissector. */
1379 register_dissector(ZBEE_PROTOABBREV_ZCL_FLOWMEAS, dissect_zbee_zcl_flow_meas, proto_zbee_zcl_flow_meas);
1380
1381 } /*proto_register_zbee_zcl_flow_meas*/
1382
1383
1384 /**
1385 *Hands off the ZCL Flow Measurement dissector.
1386 *
1387 */
1388 void
1389 proto_reg_handoff_zbee_zcl_flow_meas(void)
1390 {
1391 zbee_zcl_init_cluster( ZBEE_PROTOABBREV_ZCL_FLOWMEAS,
1392 proto_zbee_zcl_flow_meas,
1393 ett_zbee_zcl_flow_meas,
1394 ZBEE_ZCL_CID_FLOW_MEASUREMENT,
1395 ZBEE_MFG_CODE_NONE,
1396 hf_zbee_zcl_flow_meas_attr_id,
1397 hf_zbee_zcl_flow_meas_attr_id,
1398 -1, -1,
1399 (zbee_zcl_fn_attr_data)dissect_zcl_flow_meas_attr_data
1400 );
1401 } /*proto_reg_handoff_zbee_zcl_flow_meas*/
1402
1403 /* ########################################################################## */
1404 /* #### (0x0405) RELATIVE HUMIDITY MEASUREMENT CLUSTER ###################### */
1405 /* ########################################################################## */
1406
1407
1408 /*************************/
1409 /* Defines */
1410 /*************************/
1411
1412 #define ZBEE_ZCL_RELHUM_MEAS_NUM_GENERIC_ETT 1
1413 #define ZBEE_ZCL_RELHUM_MEAS_NUM_ETT ZBEE_ZCL_RELHUM_MEAS_NUM_GENERIC_ETT
1414
1415 /* Attributes */
1416 #define ZBEE_ZCL_ATTR_ID_RELHUM_MEAS_MEASURED_VALUE 0x0000 /* Measured Value */
1417 #define ZBEE_ZCL_ATTR_ID_RELHUM_MEAS_MIN_MEASURED_VALUE 0x0001 /* Min Measured Value */
1418 #define ZBEE_ZCL_ATTR_ID_RELHUM_MEAS_MAX_MEASURED_VALUE 0x0002 /* Max Measured Value */
1419 #define ZBEE_ZCL_ATTR_ID_RELHUM_MEAS_TOLERANCE 0x0003 /* Tolerance */
1420
1421 /* Server Commands Received - None */
1422
1423 /* Server Commands Generated - None */
1424
1425 #define ZBEE_ZCL_ATTR_ID_RELHUM_MEAS_INVALID_VALUE 0xffff /* Invalid Value */
1426
1427 #define ZBEE_ZCL_ATTR_ID_RELHUM_MEAS_MIN_LO_VALUE 0x0000 /* Minimum Value (Low Bound) */
1428 #define ZBEE_ZCL_ATTR_ID_RELHUM_MEAS_MIN_HI_VALUE 0x270f /* Minimum Value (High Bound) */
1429
1430 #define ZBEE_ZCL_ATTR_ID_RELHUM_MEAS_MAX_LO_VALUE 0x0000 /* Maximum Value (Low Bound) */
1431 #define ZBEE_ZCL_ATTR_ID_RELHUM_MEAS_MAX_HI_VALUE 0x2710 /* Maximum Value (High Bound) */
1432
1433 #define ZBEE_ZCL_ATTR_ID_RELHUM_MEAS_TOL_LO_VALUE 0x0000 /* Tolerance (Low Bound) */
1434 #define ZBEE_ZCL_ATTR_ID_RELHUM_MEAS_TOL_HI_VALUE 0x0800 /* Tolerance (Low Bound) */
1435
1436 /*************************/
1437 /* Function Declarations */
1438 /*************************/
1439
1440 void proto_register_zbee_zcl_relhum_meas(void);
1441 void proto_reg_handoff_zbee_zcl_relhum_meas(void);
1442
1443 /* Command Dissector Helpers */
1444 static void dissect_zcl_relhum_meas_attr_data (proto_tree *tree, tvbuff_t *tvb, unsigned *offset, uint16_t attr_id, unsigned data_type, bool client_attr);
1445
1446 /* Private functions prototype */
1447 static void decode_relhum_meas_value (char *s, uint16_t value);
1448 static void decode_relhum_meas_min_value (char *s, uint16_t value);
1449 static void decode_relhum_meas_max_value (char *s, uint16_t value);
1450 static void decode_relhum_meas_tolerance (char *s, uint16_t value);
1451
1452 /*************************/
1453 /* Global Variables */
1454 /*************************/
1455
1456 /* Initialize the protocol and registered fields */
1457 static int proto_zbee_zcl_relhum_meas;
1458
1459 static int hf_zbee_zcl_relhum_meas_attr_id;
1460 static int hf_zbee_zcl_relhum_meas_measured_value;
1461 static int hf_zbee_zcl_relhum_meas_min_measured_value;
1462 static int hf_zbee_zcl_relhum_meas_max_measured_value;
1463 static int hf_zbee_zcl_relhum_meas_tolerance;
1464
1465 /* Initialize the subtree pointers */
1466 static int ett_zbee_zcl_relhum_meas;
1467
1468 /* Attributes */
1469 static const value_string zbee_zcl_relhum_meas_attr_names[] = {
1470 { ZBEE_ZCL_ATTR_ID_RELHUM_MEAS_MEASURED_VALUE, "Measured Value" },
1471 { ZBEE_ZCL_ATTR_ID_RELHUM_MEAS_MIN_MEASURED_VALUE, "Min Measured Value" },
1472 { ZBEE_ZCL_ATTR_ID_RELHUM_MEAS_MAX_MEASURED_VALUE, "Max Measured Value" },
1473 { ZBEE_ZCL_ATTR_ID_RELHUM_MEAS_TOLERANCE, "Tolerance" },
1474 { 0, NULL }
1475 };
1476
1477 /*************************/
1478 /* Function Bodies */
1479 /*************************/
1480
1481 /**
1482 *ZigBee ZCL Relative Humidity Measurement cluster dissector for wireshark.
1483 *
1484 *@param tvb pointer to buffer containing raw packet.
1485 *@param pinfo pointer to packet information fields
1486 *@param tree pointer to data tree Wireshark uses to display packet.
1487 */
1488 static int
1489 dissect_zbee_zcl_relhum_meas(tvbuff_t *tvb _U_, packet_info *pinfo _U_, proto_tree *tree _U_, void* data _U_)
1490 {
1491 return tvb_captured_length(tvb);
1492 } /*dissect_zbee_zcl_relhum_meas*/
1493
1494 /**
1495 *This function is called by ZCL foundation dissector in order to decode
1496 *
1497 *@param tree pointer to data tree Wireshark uses to display packet.
1498 *@param tvb pointer to buffer containing raw packet.
1499 *@param offset pointer to buffer offset
1500 *@param attr_id attribute identifier
1501 *@param data_type attribute data type
1502 *@param client_attr ZCL client
1503 */
1504 static void
1505 dissect_zcl_relhum_meas_attr_data(proto_tree *tree, tvbuff_t *tvb, unsigned *offset, uint16_t attr_id, unsigned data_type, bool client_attr)
1506 {
1507 /* Dissect attribute data type and data */
1508 switch ( attr_id ) {
1509
1510 case ZBEE_ZCL_ATTR_ID_RELHUM_MEAS_MEASURED_VALUE:
1511 proto_tree_add_item(tree, hf_zbee_zcl_relhum_meas_measured_value, tvb, *offset, 2, ENC_LITTLE_ENDIAN);
1512 *offset += 2;
1513 break;
1514
1515 case ZBEE_ZCL_ATTR_ID_RELHUM_MEAS_MIN_MEASURED_VALUE:
1516 proto_tree_add_item(tree, hf_zbee_zcl_relhum_meas_min_measured_value, tvb, *offset, 2, ENC_LITTLE_ENDIAN);
1517 *offset += 2;
1518 break;
1519
1520 case ZBEE_ZCL_ATTR_ID_RELHUM_MEAS_MAX_MEASURED_VALUE:
1521 proto_tree_add_item(tree, hf_zbee_zcl_relhum_meas_max_measured_value, tvb, *offset, 2, ENC_LITTLE_ENDIAN);
1522 *offset += 2;
1523 break;
1524
1525 case ZBEE_ZCL_ATTR_ID_RELHUM_MEAS_TOLERANCE:
1526 proto_tree_add_item(tree, hf_zbee_zcl_relhum_meas_tolerance, tvb, *offset, 2, ENC_LITTLE_ENDIAN);
1527 *offset += 2;
1528 break;
1529
1530 default:
1531 dissect_zcl_attr_data(tvb, tree, offset, data_type, client_attr);
1532 break;
1533 }
1534 } /*dissect_zcl_relhum_meas_attr_data*/
1535
1536 /**
1537 *This function decodes relative humidity value
1538 *
1539 *@param s string to display
1540 *@param value value to decode
1541 */
1542 static void
1543 decode_relhum_meas_value(char *s, uint16_t value)
1544 {
1545 if (value == ZBEE_ZCL_ATTR_ID_RELHUM_MEAS_INVALID_VALUE)
1546 snprintf(s, ITEM_LABEL_LENGTH, "Invalid value");
1547 else
1548 snprintf(s, ITEM_LABEL_LENGTH, "%d.%02d [%%]", value/100, value%100);
1549
1550 return;
1551 } /*decode_relhum_meas_value*/
1552
1553 /**
1554 *This function decodes minimum relative humidity value
1555 *
1556 *@param s string to display
1557 *@param value value to decode
1558 */
1559 static void
1560 decode_relhum_meas_min_value(char *s, uint16_t value)
1561 {
1562 if (value > ZBEE_ZCL_ATTR_ID_RELHUM_MEAS_MIN_HI_VALUE)
1563 snprintf(s, ITEM_LABEL_LENGTH, "Out of range");
1564 else
1565 snprintf(s, ITEM_LABEL_LENGTH, "%d.%02d [%%]", value/100, value%100);
1566
1567 return;
1568 } /*decode_relhum_meas_min_value*/
1569
1570 /**
1571 *This function decodes maximum relative humidity value
1572 *
1573 *@param s string to display
1574 *@param value value to decode
1575 */
1576 static void
1577 decode_relhum_meas_max_value(char *s, uint16_t value)
1578 {
1579 if (value > ZBEE_ZCL_ATTR_ID_RELHUM_MEAS_MAX_HI_VALUE)
1580 snprintf(s, ITEM_LABEL_LENGTH, "Out of range");
1581 else
1582 snprintf(s, ITEM_LABEL_LENGTH, "%d.%02d [%%]", value/100, value%100);
1583
1584 return;
1585 } /*decode_relhum_meas_max_value*/
1586
1587 /**
1588 *This function decodes tolerance value
1589 *
1590 *@param s string to display
1591 *@param value value to decode
1592 */
1593 static void
1594 decode_relhum_meas_tolerance(char *s, uint16_t value)
1595 {
1596 if (value > ZBEE_ZCL_ATTR_ID_RELHUM_MEAS_TOL_HI_VALUE)
1597 snprintf(s, ITEM_LABEL_LENGTH, "Out of range");
1598 else
1599 snprintf(s, ITEM_LABEL_LENGTH, "%d.%02d [%%]", value/100, value%100);
1600
1601 return;
1602 } /*decode_relhum_meas_tolerance*/
1603
1604 /**
1605 *This function registers the ZCL Relative Humidity Measurement dissector
1606 *
1607 */
1608 void
1609 proto_register_zbee_zcl_relhum_meas(void)
1610 {
1611 static hf_register_info hf[] = {
1612
1613 { &hf_zbee_zcl_relhum_meas_attr_id,
1614 { "Attribute", "zbee_zcl_meas_sensing.relhummeas.attr_id", FT_UINT16, BASE_HEX, VALS(zbee_zcl_relhum_meas_attr_names),
1615 0x0, NULL, HFILL } },
1616
1617 { &hf_zbee_zcl_relhum_meas_measured_value,
1618 { "Measured Value", "zbee_zcl_meas_sensing.relhummeas.attr.value", FT_UINT16, BASE_CUSTOM, CF_FUNC(decode_relhum_meas_value),
1619 0x0, NULL, HFILL } },
1620
1621 { &hf_zbee_zcl_relhum_meas_min_measured_value,
1622 { "Min Measured Value", "zbee_zcl_meas_sensing.relhummeas.attr.value.min", FT_UINT16, BASE_CUSTOM, CF_FUNC(decode_relhum_meas_min_value),
1623 0x0, NULL, HFILL } },
1624
1625 { &hf_zbee_zcl_relhum_meas_max_measured_value,
1626 { "Max Measured Value", "zbee_zcl_meas_sensing.relhummeas.attr.value.max", FT_UINT16, BASE_CUSTOM, CF_FUNC(decode_relhum_meas_max_value),
1627 0x0, NULL, HFILL } },
1628
1629 { &hf_zbee_zcl_relhum_meas_tolerance,
1630 { "Tolerance", "zbee_zcl_meas_sensing.relhummeas.attr.tolerance", FT_UINT16, BASE_CUSTOM, CF_FUNC(decode_relhum_meas_tolerance),
1631 0x0, NULL, HFILL } }
1632
1633 };
1634
1635 /* ZCL Relative Humidity Measurement subtrees */
1636 int *ett[] = {
1637 &ett_zbee_zcl_relhum_meas
1638 };
1639
1640 /* Register the ZigBee ZCL Relative Humidity Measurement cluster protocol name and description */
1641 proto_zbee_zcl_relhum_meas = proto_register_protocol("ZigBee ZCL Rel. Humidity Meas.", "ZCL Relative Humidity Meas.", ZBEE_PROTOABBREV_ZCL_RELHUMMEAS);
1642 proto_register_field_array(proto_zbee_zcl_relhum_meas, hf, array_length(hf));
1643 proto_register_subtree_array(ett, array_length(ett));
1644
1645 /* Register the ZigBee ZCL Relative Humidity Measurement dissector. */
1646 register_dissector(ZBEE_PROTOABBREV_ZCL_RELHUMMEAS, dissect_zbee_zcl_relhum_meas, proto_zbee_zcl_relhum_meas);
1647 } /*proto_register_zbee_zcl_relhum_meas*/
1648
1649
1650 /**
1651 *Hands off the ZCL Relative Humidity Measurement dissector.
1652 *
1653 */
1654 void
1655 proto_reg_handoff_zbee_zcl_relhum_meas(void)
1656 {
1657 zbee_zcl_init_cluster( ZBEE_PROTOABBREV_ZCL_RELHUMMEAS,
1658 proto_zbee_zcl_relhum_meas,
1659 ett_zbee_zcl_relhum_meas,
1660 ZBEE_ZCL_CID_REL_HUMIDITY_MEASUREMENT,
1661 ZBEE_MFG_CODE_NONE,
1662 hf_zbee_zcl_relhum_meas_attr_id,
1663 hf_zbee_zcl_relhum_meas_attr_id,
1664 -1, -1,
1665 (zbee_zcl_fn_attr_data)dissect_zcl_relhum_meas_attr_data
1666 );
1667 } /*proto_reg_handoff_zbee_zcl_relhum_meas*/
1668
1669
1670 /* ########################################################################## */
1671 /* #### (0x0406) OCCUPANCY SENSING CLUSTER ################################## */
1672 /* ########################################################################## */
1673
1674 /*************************/
1675 /* Defines */
1676 /*************************/
1677
1678 #define ZBEE_ZCL_OCC_SEN_NUM_ETT 2
1679
1680 /* Attributes */
1681 #define ZBEE_ZCL_ATTR_ID_OCC_SEN_OCCUPANCY 0x0000 /* Occupancy */
1682 #define ZBEE_ZCL_ATTR_ID_OCC_SEN_OCC_SENSOR_TYPE 0x0001 /* Occupancy Sensor Type */
1683 #define ZBEE_ZCL_ATTR_ID_OCC_SEN_PIR_OCC_TO_UNOCC_DELAY 0x0010 /* PIR Occupied to Unoccupied Delay */
1684 #define ZBEE_ZCL_ATTR_ID_OCC_SEN_PIR_UNOCC_TO_OCC_DELAY 0x0011 /* PIR Unoccupied to Occupied Delay */
1685 #define ZBEE_ZCL_ATTR_ID_OCC_SEN_PIR_UNOCC_TO_OCC_THOLD 0x0012 /* PIR Unoccupied to Occupied Threshold */
1686 #define ZBEE_ZCL_ATTR_ID_OCC_SEN_USONIC_OCC_TO_UNOCC_DELAY 0x0020 /* Ultrasonic Occupied to Unoccupied Threshold */
1687 #define ZBEE_ZCL_ATTR_ID_OCC_SEN_USONIC_UNOCC_TO_OCC_DELAY 0x0021 /* Ultrasonic Unoccupied to Occupied Delay */
1688 #define ZBEE_ZCL_ATTR_ID_OCC_SEN_USONIC_UNOCC_TO_OCC_THOLD 0x0022 /* Ultrasonic Unoccupied to Occupied Threshold */
1689
1690 /* Server Commands Received - None */
1691
1692 /* Server Commands Generated - None */
1693
1694 /* Occupancy Mask fields */
1695 #define ZBEE_ZCL_OCCUPANCY_SENSED_OCC 0x01 /* Sensed Occupancy */
1696
1697 /* Occupancy Sensor Type */
1698 #define ZBEE_ZCL_OCC_SENSOR_TYPE_PIR 0x00 /* PIR */
1699 #define ZBEE_ZCL_OCC_SENSOR_TYPE_USONIC 0x01 /* Ultrasonic */
1700 #define ZBEE_ZCL_OCC_SENSOR_TYPE_PIR_AND_USONIC 0x02 /* PIR and Ultrasonic */
1701
1702 /*************************/
1703 /* Function Declarations */
1704 /*************************/
1705
1706 void proto_register_zbee_zcl_occ_sen(void);
1707 void proto_reg_handoff_zbee_zcl_occ_sen(void);
1708
1709 /* Command Dissector Helpers */
1710 static void dissect_zcl_occ_sen_attr_data (proto_tree *tree, tvbuff_t *tvb, unsigned *offset, uint16_t attr_id, unsigned data_type, bool client_attr);
1711
1712 /*************************/
1713 /* Global Variables */
1714 /*************************/
1715
1716 /* Initialize the protocol and registered fields */
1717 static int proto_zbee_zcl_occ_sen;
1718
1719 static int hf_zbee_zcl_occ_sen_attr_id;
1720 static int hf_zbee_zcl_occ_sen_occupancy;
1721 static int hf_zbee_zcl_occ_sen_occupancy_occupied;
1722 static int hf_zbee_zcl_occ_sen_occ_sensor_type;
1723
1724 /* Initialize the subtree pointers */
1725 static int ett_zbee_zcl_occ_sen;
1726 static int ett_zbee_zcl_occ_sen_occupancy;
1727
1728 /* Attributes */
1729 static const value_string zbee_zcl_occ_sen_attr_names[] = {
1730 { ZBEE_ZCL_ATTR_ID_OCC_SEN_OCCUPANCY, "Occupancy" },
1731 { ZBEE_ZCL_ATTR_ID_OCC_SEN_OCC_SENSOR_TYPE, "Occupancy Sensor Type" },
1732 { ZBEE_ZCL_ATTR_ID_OCC_SEN_PIR_OCC_TO_UNOCC_DELAY, "PIR Occupied to Unoccupied Delay" },
1733 { ZBEE_ZCL_ATTR_ID_OCC_SEN_PIR_UNOCC_TO_OCC_DELAY, "PIR Unoccupied to Occupied Delay" },
1734 { ZBEE_ZCL_ATTR_ID_OCC_SEN_PIR_UNOCC_TO_OCC_THOLD, "PIR Unoccupied to Occupied Threshold" },
1735 { ZBEE_ZCL_ATTR_ID_OCC_SEN_USONIC_OCC_TO_UNOCC_DELAY, "Ultrasonic Occupied to Unoccupied Threshold" },
1736 { ZBEE_ZCL_ATTR_ID_OCC_SEN_USONIC_UNOCC_TO_OCC_DELAY, "Ultrasonic Unoccupied to Occupied Delay" },
1737 { ZBEE_ZCL_ATTR_ID_OCC_SEN_USONIC_UNOCC_TO_OCC_THOLD, "Ultrasonic Unoccupied to Occupied Threshold" },
1738 { 0, NULL }
1739 };
1740
1741 /* Occupancy Sensor types */
1742 static const value_string zbee_zcl_occ_sen_sensor_type_names[] = {
1743 { ZBEE_ZCL_OCC_SENSOR_TYPE_PIR, "PIR" },
1744 { ZBEE_ZCL_OCC_SENSOR_TYPE_USONIC, "Ultrasonic" },
1745 { ZBEE_ZCL_OCC_SENSOR_TYPE_PIR_AND_USONIC, "PIR and Ultrasonic" },
1746 { 0, NULL }
1747 };
1748
1749 /*************************/
1750 /* Function Bodies */
1751 /*************************/
1752
1753 /**
1754 *ZigBee ZCL Occupancy Sensing cluster dissector for wireshark.
1755 *
1756 *@param tvb pointer to buffer containing raw packet.
1757 *@param pinfo pointer to packet information fields
1758 *@param tree pointer to data tree Wireshark uses to display packet.
1759 */
1760 static int
1761 dissect_zbee_zcl_occ_sen(tvbuff_t *tvb _U_, packet_info *pinfo _U_, proto_tree *tree _U_, void* data _U_)
1762 {
1763 return tvb_captured_length(tvb);
1764 } /*dissect_zbee_zcl_occ_sen*/
1765
1766 /**
1767 *This function is called by ZCL foundation dissector in order to decode
1768 *
1769 *@param tree pointer to data tree Wireshark uses to display packet.
1770 *@param tvb pointer to buffer containing raw packet.
1771 *@param offset pointer to buffer offset
1772 *@param attr_id attribute identifier
1773 *@param data_type attribute data type
1774 *@param client_attr ZCL client
1775 */
1776 static void
1777 dissect_zcl_occ_sen_attr_data(proto_tree *tree, tvbuff_t *tvb, unsigned *offset, uint16_t attr_id, unsigned data_type, bool client_attr)
1778 {
1779 static int * const occupancy[] = {
1780 &hf_zbee_zcl_occ_sen_occupancy_occupied,
1781 NULL
1782 };
1783
1784 /* Dissect attribute data type and data */
1785 switch ( attr_id ) {
1786
1787 case ZBEE_ZCL_ATTR_ID_OCC_SEN_OCCUPANCY:
1788 proto_tree_add_bitmask(tree, tvb, *offset, hf_zbee_zcl_occ_sen_occupancy, ett_zbee_zcl_occ_sen_occupancy, occupancy, ENC_LITTLE_ENDIAN);
1789 *offset += 1;
1790 break;
1791
1792 case ZBEE_ZCL_ATTR_ID_OCC_SEN_OCC_SENSOR_TYPE:
1793 proto_tree_add_item(tree, hf_zbee_zcl_occ_sen_occ_sensor_type, tvb, *offset, 1, ENC_LITTLE_ENDIAN);
1794 *offset += 1;
1795 break;
1796
1797 case ZBEE_ZCL_ATTR_ID_OCC_SEN_PIR_OCC_TO_UNOCC_DELAY:
1798 case ZBEE_ZCL_ATTR_ID_OCC_SEN_PIR_UNOCC_TO_OCC_DELAY:
1799 case ZBEE_ZCL_ATTR_ID_OCC_SEN_PIR_UNOCC_TO_OCC_THOLD:
1800 case ZBEE_ZCL_ATTR_ID_OCC_SEN_USONIC_OCC_TO_UNOCC_DELAY:
1801 case ZBEE_ZCL_ATTR_ID_OCC_SEN_USONIC_UNOCC_TO_OCC_DELAY:
1802 case ZBEE_ZCL_ATTR_ID_OCC_SEN_USONIC_UNOCC_TO_OCC_THOLD:
1803 default:
1804 dissect_zcl_attr_data(tvb, tree, offset, data_type, client_attr);
1805 break;
1806 }
1807 } /*dissect_zcl_occ_sen_attr_data*/
1808
1809 /**
1810 *This function registers the ZCL Occupancy Sensing dissector
1811 *
1812 */
1813 void
1814 proto_register_zbee_zcl_occ_sen(void)
1815 {
1816 static hf_register_info hf[] = {
1817
1818 { &hf_zbee_zcl_occ_sen_attr_id,
1819 { "Attribute", "zbee_zcl_meas_sensing.occsen.attr_id", FT_UINT16, BASE_HEX, VALS(zbee_zcl_occ_sen_attr_names),
1820 0x0, NULL, HFILL } },
1821
1822 { &hf_zbee_zcl_occ_sen_occupancy,
1823 { "Occupancy", "zbee_zcl_meas_sensing.occsen.attr.occupancy", FT_UINT8, BASE_HEX, NULL,
1824 0x0, NULL, HFILL } },
1825
1826 { &hf_zbee_zcl_occ_sen_occupancy_occupied,
1827 { "Occupied", "zbee_zcl_meas_sensing.occsen.attr.occupancy_occupied", FT_BOOLEAN, 8, NULL,
1828 ZBEE_ZCL_OCCUPANCY_SENSED_OCC, NULL, HFILL } },
1829
1830 { &hf_zbee_zcl_occ_sen_occ_sensor_type,
1831 { "Occupancy Sensor Type", "zbee_zcl_meas_sensing.occsen.attr.occ_sensor_type", FT_UINT8, BASE_HEX, VALS(zbee_zcl_occ_sen_sensor_type_names),
1832 0x0, NULL, HFILL } }
1833 };
1834
1835
1836 /* ZCL Occupancy Sensing subtrees */
1837 static int *ett[ZBEE_ZCL_OCC_SEN_NUM_ETT];
1838 ett[0] = &ett_zbee_zcl_occ_sen;
1839 ett[1] = &ett_zbee_zcl_occ_sen_occupancy;
1840
1841 /* Register the ZigBee ZCL Occupancy Sensing cluster protocol name and description */
1842 proto_zbee_zcl_occ_sen = proto_register_protocol("ZigBee ZCL Occupancy Sensing", "ZCL Occupancy Sensing", ZBEE_PROTOABBREV_ZCL_OCCSEN);
1843 proto_register_field_array(proto_zbee_zcl_occ_sen, hf, array_length(hf));
1844 proto_register_subtree_array(ett, array_length(ett));
1845
1846 /* Register the ZigBee ZCL Occupancy Sensing dissector. */
1847 register_dissector(ZBEE_PROTOABBREV_ZCL_OCCSEN, dissect_zbee_zcl_occ_sen, proto_zbee_zcl_occ_sen);
1848
1849 } /*proto_register_zbee_zcl_occ_sen*/
1850
1851
1852 /**
1853 *Hands off the ZCL Occupancy Sensing dissector.
1854 *
1855 */
1856 void
1857 proto_reg_handoff_zbee_zcl_occ_sen(void)
1858 {
1859 zbee_zcl_init_cluster( ZBEE_PROTOABBREV_ZCL_OCCSEN,
1860 proto_zbee_zcl_occ_sen,
1861 ett_zbee_zcl_occ_sen,
1862 ZBEE_ZCL_CID_OCCUPANCY_SENSING,
1863 ZBEE_MFG_CODE_NONE,
1864 hf_zbee_zcl_occ_sen_attr_id,
1865 hf_zbee_zcl_occ_sen_attr_id,
1866 -1, -1,
1867 (zbee_zcl_fn_attr_data)dissect_zcl_occ_sen_attr_data
1868 );
1869 } /*proto_reg_handoff_zbee_zcl_occ_sen*/
1870
1871 /* ########################################################################## */
1872 /* #### (0x0b04) ELECTRICAL MEASUREMENT CLUSTER ############################# */
1873 /* ########################################################################## */
1874
1875 /*************************/
1876 /* Defines */
1877 /*************************/
1878
1879 #define ZBEE_ZCL_ELEC_MES_NUM_ETT 1
1880
1881 /* Attributes */
1882 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_MEASUREMENT_TYPE 0x0000
1883 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_DC_VOLTAGE 0x0100
1884 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_DC_VOLTAGE_MIN 0x0101
1885 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_DC_VOLTAGE_MAX 0x0102
1886 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_DC_CURRENT 0x0103
1887 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_DC_CURRENT_MIN 0x0104
1888 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_DC_CURRENT_MAX 0x0105
1889 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_DC_POWER 0x0106
1890 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_DC_POWER_MIN 0x0107
1891 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_DC_POWER_MAX 0x0108
1892 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_DC_VOLTAGE_MULTIPLIER 0x0200
1893 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_DC_VOLTAGE_DIVISOR 0x0201
1894 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_DC_CURRENT_MULTIPLIER 0x0202
1895 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_DC_CURRENT_DIVISOR 0x0203
1896 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_DC_POWER_MULTIPLIER 0x0204
1897 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_DC_POWER_DIVISOR 0x0205
1898 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_AC_FREQUENCY 0x0300
1899 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_AC_FREQUENCY_MIN 0x0301
1900 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_AC_FREQUENCY_MAX 0x0302
1901 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_NEUTRAL_CURRENT 0x0303
1902 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_TOTAL_ACTIVE_POWER 0x0304
1903 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_TOTAL_REACTIVE_POWER 0x0305
1904 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_TOTAL_APPARENT_POWER 0x0306
1905 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_MEASURED_1ST_HARMONIC_CURRENT 0x0307
1906 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_MEASURED_3RD_HARMONIC_CURRENT 0x0308
1907 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_MEASURED_5TH_HARMONIC_CURRENT 0x0309
1908 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_MEASURED_7TH_HARMONIC_CURRENT 0x030A
1909 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_MEASURED_9TH_HARMONIC_CURRENT 0x030B
1910 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_MEASURED_11TH_HARMONIC_CURRENT 0x030C
1911 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_MEASURED_PHASE_1ST_HARMONIC_CURRENT 0x030D
1912 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_MEASURED_PHASE_3RD_HARMONIC_CURRENT 0x030E
1913 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_MEASURED_PHASE_5TH_HARMONIC_CURRENT 0x030F
1914 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_MEASURED_PHASE_7TH_HARMONIC_CURRENT 0x0310
1915 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_MEASURED_PHASE_9TH_HARMONIC_CURRENT 0x0311
1916 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_MEASURED_PHASE_11TH_HARMONIC_CURRENT 0x0312
1917 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_AC_FREQUENCY_MULTIPLIER 0x0400
1918 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_AC_FREQUENCY_DIVISOR 0x0401
1919 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_POWER_MULTIPLIER 0x0402
1920 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_POWER_DIVISOR 0x0403
1921 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_HARMONIC_CURRENT_MULTIPLIER 0x0404
1922 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_PHASE_HARMONIC_CURRENT_MULTIPLIER 0x0405
1923 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_LINE_CURRENT 0x0501
1924 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_ACTIVE_CURRENT 0x0502
1925 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_REACTIVE_CURRENT 0x0503
1926 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_RMS_VOLTAGE 0x0505
1927 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_RMS_VOLTAGE_MIN 0x0506
1928 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_RMS_VOLTAGE_MAX 0x0507
1929 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_RMS_CURRENT 0x0508
1930 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_RMS_CURRENT_MIN 0x0509
1931 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_RMS_CURRENT_MAX 0x050A
1932 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_ACTIVE_POWER 0x050B
1933 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_ACTIVE_POWER_MIN 0x050C
1934 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_ACTIVE_POWER_MAX 0x050D
1935 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_REACTIVE_POWER 0x050E
1936 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_APPARENT_POWER 0x050F
1937 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_POWER_FACTOR 0x0510
1938 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_AVERAGE_RMS_VOLTAGE_MEASUREMENT_PERIOD 0x0511
1939 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_AVERAGE_RMS_OVER_VOLTAGE_COUNTER 0x0512
1940 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_AVERAGE_RMS_UNDER_VOLTAGE_COUNTER 0x0513
1941 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_RMS_EXTREME_OVER_VOLTAGE_PERIOD 0x0514
1942 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_RMS_EXTREME_UNDER_VOLTAGE_PERIOD 0x0515
1943 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_RMS_VOLTAGE_SAG_PERIOD 0x0516
1944 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_RMS_VOLTAGE_SWELL_PERIOD 0x0517
1945 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_AC_VOLTAGE_MULTIPLIER 0x0600
1946 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_AC_VOLTAGE_DIVISOR 0x0601
1947 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_AC_CURRENT_MULTIPLIER 0x0602
1948 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_AC_CURRENT_DIVISOR 0x0603
1949 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_AC_POWER_MULTIPLIER 0x0604
1950 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_AC_POWER_DIVISOR 0x0605
1951 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_DC_OVERLOAD_ALARMS_MASK 0x0700
1952 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_DC_VOLTAGE_OVERLOAD 0x0701
1953 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_DC_CURRENT_OVERLOAD 0x0702
1954 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_AC_ALARMS_MASK 0x0800
1955 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_AC_VOLTAGE_OVERLOAD 0x0801
1956 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_AC_CURRENT_OVERLOAD 0x0802
1957 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_AC_ACTIVE_POWER_OVERLOAD 0x0803
1958 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_AC_REACTIVE_POWER_OVERLOAD 0x0804
1959 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_AVERAGE_RMS_OVER_VOLTAGE 0x0805
1960 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_AVERAGE_RMS_UNDER_VOLTAGE 0x0806
1961 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_RMS_EXTREME_OVER_VOLTAGE 0x0807
1962 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_RMS_EXTREME_UNDER_VOLTAGE 0x0808
1963 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_RMS_VOLTAGE_SAG 0x0809
1964 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_RMS_VOLTAGE_SWELL 0x080A
1965 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_LINE_CURRENT_PH_B 0x0901
1966 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_ACTIVE_CURRENT_PH_B 0x0902
1967 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_REACTIVE_CURRENT_PH_B 0x0903
1968 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_RMS_VOLTAGE_PH_B 0x0905
1969 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_RMS_VOLTAGE_MIN_PH_B 0x0906
1970 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_RMS_VOLTAGE_MAX_PH_B 0x0907
1971 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_RMS_CURRENT_PH_B 0x0908
1972 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_RMS_CURRENT_MIN_PH_B 0x0909
1973 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_RMS_CURRENT_MAX_PH_B 0x090A
1974 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_ACTIVE_POWER_PH_B 0x090B
1975 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_ACTIVE_POWER_MIN_PH_B 0x090C
1976 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_ACTIVE_POWER_MAX_PH_B 0x090D
1977 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_REACTIVE_POWER_PH_B 0x090E
1978 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_APPARENT_POWER_PH_B 0x090F
1979 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_POWER_FACTOR_PH_B 0x0910
1980 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_AVERAGE_RMS_VOLTAGE_MEASUREMENT_PERIOD_PH_B 0x0911
1981 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_AVERAGE_RMS_OVER_VOLTAGE_COUNTER_PH_B 0x0912
1982 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_AVERAGE_RMS_UNDER_VOLTAGE_COUNTER_PH_B 0x0913
1983 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_RMS_EXTREME_OVER_VOLTAGE_PERIOD_PH_B 0x0914
1984 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_RMS_EXTREME_UNDER_VOLTAGE_PERIOD_PH_B 0x0915
1985 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_RMS_VOLTAGE_SAG_PERIOD_PH_B 0x0916
1986 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_RMS_VOLTAGE_SWELL_PERIOD_PH_B 0x0917
1987 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_LINE_CURRENT_PH_C 0x0A01
1988 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_REACTIVE_CURRENT_PH_C 0x0A03
1989 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_RMS_VOLTAGE_PH_C 0x0A05
1990 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_RMS_VOLTAGE_MIN_PH_C 0x0A06
1991 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_RMS_VOLTAGE_MAX_PH_C 0x0A07
1992 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_RMS_CURRENT_PH_C 0x0A08
1993 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_RMS_CURRENT_MIN_PH_C 0x0A09
1994 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_RMS_CURRENT_MAX_PH_C 0x0A0A
1995 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_ACTIVE_POWER_PH_C 0x0A0B
1996 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_ACTIVE_POWER_MIN_PH_C 0x0A0C
1997 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_ACTIVE_POWER_MAX_PH_C 0x0A0D
1998 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_REACTIVE_POWER_PH_C 0x0A0E
1999 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_APPARENT_POWER_PH_C 0x0A0F
2000 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_POWER_FACTOR_PH_C 0x0A10
2001 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_AVERAGE_RMS_VOLTAGE_MEASUREMENT_PERIOD_PH_C 0x0A11
2002 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_AVERAGE_RMS_OVER_VOLTAGE_COUNTER_PH_C 0x0A12
2003 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_AVERAGE_RMS_UNDER_VOLTAGE_COUNTER_PH_C 0x0A13
2004 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_RMS_EXTREME_OVER_VOLTAGE_PERIOD_PH_C 0x0A14
2005 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_RMS_EXTREME_UNDER_VOLTAGE_PERIOD_PH_C 0x0A15
2006 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_RMS_VOLTAGE_SAG_PERIOD_PH_C 0x0A16
2007 #define ZBEE_ZCL_ATTR_ID_ELEC_MES_RMS_VOLTAGE_SWELL_PERIOD_PH_C 0x0A17
2008
2009 /* Server Commands Received */
2010 #define ZBEE_ZCL_CMD_GET_PROFILE_INFO 0x00
2011 #define ZBEE_ZCL_CMD_GET_MEASUREMENT_PROFILE_INFO 0x01
2012
2013 /* Server Commands Generated */
2014 #define ZBEE_ZCL_CMD_GET_PROFILE_INFO_RESPONSE 0x00
2015 #define ZBEE_ZCL_CMD_GET_MEASUREMENT_PROFILE_INFO_RESPONSE 0x01
2016
2017 /* Profile Interval Period */
2018 #define ZBEE_ZCL_ELEC_MES_PROFILE_INTERVAL_PERIOD_DAILY 0
2019 #define ZBEE_ZCL_ELEC_MES_PROFILE_INTERVAL_PERIOD_60_MINUTES 1
2020 #define ZBEE_ZCL_ELEC_MES_PROFILE_INTERVAL_PERIOD_30_MINUTES 2
2021 #define ZBEE_ZCL_ELEC_MES_PROFILE_INTERVAL_PERIOD_15_MINUTES 3
2022 #define ZBEE_ZCL_ELEC_MES_PROFILE_INTERVAL_PERIOD_10_MINUTES 4
2023 #define ZBEE_ZCL_ELEC_MES_PROFILE_INTERVAL_PERIOD_7_5_MINUTES 5
2024 #define ZBEE_ZCL_ELEC_MES_PROFILE_INTERVAL_PERIOD_5_MINUTES 6
2025 #define ZBEE_ZCL_ELEC_MES_PROFILE_INTERVAL_PERIOD_2_5_MINUTES 7
2026
2027 /* List of Status Valid Values */
2028 #define ZBEE_ZCL_ELEC_MES_STATUS_SUCCESS 0x00
2029 #define ZBEE_ZCL_ELEC_MES_STATUS_ATTRIBUTE_PROFILE_NOT_SUPPORTED 0x01
2030 #define ZBEE_ZCL_ELEC_MES_STATUS_INVALID_START_TIME 0x02
2031 #define ZBEE_ZCL_ELEC_MES_STATUS_MORE_INTERVALS_REQUESTED_THAN_CAN_BE_RET 0x03
2032 #define ZBEE_ZCL_ELEC_MES_STATUS_NO_INTERVALS_AVAILABLE_FOR_THE_REQ_TIME 0x04
2033
2034 /*************************/
2035 /* Function Declarations */
2036 /*************************/
2037
2038 void proto_register_zbee_zcl_elec_mes(void);
2039 void proto_reg_handoff_zbee_zcl_elec_mes(void);
2040
2041 /* Command Dissector Helpers */
2042 static void dissect_zcl_elec_mes_attr_data (proto_tree *tree, tvbuff_t *tvb, unsigned *offset, uint16_t attr_id, unsigned data_type, bool client_attr);
2043 static void dissect_zcl_elec_mes_get_measurement_profile_info (tvbuff_t *tvb, proto_tree *tree, unsigned *offset);
2044 static void dissect_zcl_elec_mes_get_profile_info_response (tvbuff_t *tvb, proto_tree *tree, unsigned *offset);
2045 static void dissect_zcl_elec_mes_get_measurement_profile_info_response (tvbuff_t *tvb, proto_tree *tree, unsigned *offset);
2046
2047 /*************************/
2048 /* Global Variables */
2049 /*************************/
2050
2051 /* Initialize the protocol and registered fields */
2052 static int proto_zbee_zcl_elec_mes;
2053
2054 static int hf_zbee_zcl_elec_mes_srv_tx_cmd_id;
2055 static int hf_zbee_zcl_elec_mes_srv_rx_cmd_id;
2056 static int hf_zbee_zcl_elec_mes_attr_id;
2057 static int hf_zbee_zcl_elec_mes_start_time;
2058 static int hf_zbee_zcl_elec_mes_number_of_intervals;
2059 static int hf_zbee_zcl_elec_mes_profile_count;
2060 static int hf_zbee_zcl_elec_mes_profile_interval_period;
2061 static int hf_zbee_zcl_elec_mes_max_number_of_intervals;
2062 static int hf_zbee_zcl_elec_mes_status;
2063 static int hf_zbee_zcl_elec_mes_number_of_intervals_delivered;
2064 static int hf_zbee_zcl_elec_mes_intervals;
2065
2066 /* Initialize the subtree pointers */
2067 static int ett_zbee_zcl_elec_mes;
2068
2069 /* Attributes */
2070 static const value_string zbee_zcl_elec_mes_attr_names[] = {
2071 { ZBEE_ZCL_ATTR_ID_ELEC_MES_MEASUREMENT_TYPE, "Measurement Type" },
2072 { ZBEE_ZCL_ATTR_ID_ELEC_MES_DC_VOLTAGE, "DC Voltage" },
2073 { ZBEE_ZCL_ATTR_ID_ELEC_MES_DC_VOLTAGE_MIN, "DC Voltage Min" },
2074 { ZBEE_ZCL_ATTR_ID_ELEC_MES_DC_VOLTAGE_MAX, "DC Voltage Max" },
2075 { ZBEE_ZCL_ATTR_ID_ELEC_MES_DC_CURRENT, "DC Current" },
2076 { ZBEE_ZCL_ATTR_ID_ELEC_MES_DC_CURRENT_MIN, "DC Current Min" },
2077 { ZBEE_ZCL_ATTR_ID_ELEC_MES_DC_CURRENT_MAX, "DC Current Max" },
2078 { ZBEE_ZCL_ATTR_ID_ELEC_MES_DC_POWER, "DC Power" },
2079 { ZBEE_ZCL_ATTR_ID_ELEC_MES_DC_POWER_MIN, "DC Power Min" },
2080 { ZBEE_ZCL_ATTR_ID_ELEC_MES_DC_POWER_MAX, "DC Power Max" },
2081 { ZBEE_ZCL_ATTR_ID_ELEC_MES_DC_VOLTAGE_MULTIPLIER, "DC Voltage Multiplier" },
2082 { ZBEE_ZCL_ATTR_ID_ELEC_MES_DC_VOLTAGE_DIVISOR, "DC Voltage Divisor" },
2083 { ZBEE_ZCL_ATTR_ID_ELEC_MES_DC_CURRENT_MULTIPLIER, "DC Current Multiplier" },
2084 { ZBEE_ZCL_ATTR_ID_ELEC_MES_DC_CURRENT_DIVISOR, "DC Current Divisor" },
2085 { ZBEE_ZCL_ATTR_ID_ELEC_MES_DC_POWER_MULTIPLIER, "DC Power Multiplier" },
2086 { ZBEE_ZCL_ATTR_ID_ELEC_MES_DC_POWER_DIVISOR, "DC Power Divisor" },
2087 { ZBEE_ZCL_ATTR_ID_ELEC_MES_AC_FREQUENCY, "AC Frequency" },
2088 { ZBEE_ZCL_ATTR_ID_ELEC_MES_AC_FREQUENCY_MIN, "AC Frequency Min" },
2089 { ZBEE_ZCL_ATTR_ID_ELEC_MES_AC_FREQUENCY_MAX, "AC Frequency Max" },
2090 { ZBEE_ZCL_ATTR_ID_ELEC_MES_NEUTRAL_CURRENT, "Neutral Current" },
2091 { ZBEE_ZCL_ATTR_ID_ELEC_MES_TOTAL_ACTIVE_POWER, "Total Active Power" },
2092 { ZBEE_ZCL_ATTR_ID_ELEC_MES_TOTAL_REACTIVE_POWER, "Total Reactive Power" },
2093 { ZBEE_ZCL_ATTR_ID_ELEC_MES_TOTAL_APPARENT_POWER, "Total Apparent Power" },
2094 { ZBEE_ZCL_ATTR_ID_ELEC_MES_MEASURED_1ST_HARMONIC_CURRENT, "Measured 1st Harmonic Current" },
2095 { ZBEE_ZCL_ATTR_ID_ELEC_MES_MEASURED_3RD_HARMONIC_CURRENT, "Measured 3rd Harmonic Current" },
2096 { ZBEE_ZCL_ATTR_ID_ELEC_MES_MEASURED_5TH_HARMONIC_CURRENT, "Measured 5th Harmonic Current" },
2097 { ZBEE_ZCL_ATTR_ID_ELEC_MES_MEASURED_7TH_HARMONIC_CURRENT, "Measured 7th Harmonic Current" },
2098 { ZBEE_ZCL_ATTR_ID_ELEC_MES_MEASURED_9TH_HARMONIC_CURRENT, "Measured 9th Harmonic Current" },
2099 { ZBEE_ZCL_ATTR_ID_ELEC_MES_MEASURED_11TH_HARMONIC_CURRENT, "Measured 11th Harmonic Current" },
2100 { ZBEE_ZCL_ATTR_ID_ELEC_MES_MEASURED_PHASE_1ST_HARMONIC_CURRENT, "Measured Phase 1st Harmonic Current" },
2101 { ZBEE_ZCL_ATTR_ID_ELEC_MES_MEASURED_PHASE_3RD_HARMONIC_CURRENT, "Measured Phase 3rd Harmonic Current" },
2102 { ZBEE_ZCL_ATTR_ID_ELEC_MES_MEASURED_PHASE_5TH_HARMONIC_CURRENT, "Measured Phase 5th Harmonic Current" },
2103 { ZBEE_ZCL_ATTR_ID_ELEC_MES_MEASURED_PHASE_7TH_HARMONIC_CURRENT, "Measured Phase 7th Harmonic Current" },
2104 { ZBEE_ZCL_ATTR_ID_ELEC_MES_MEASURED_PHASE_9TH_HARMONIC_CURRENT, "Measured Phase 9th Harmonic Current" },
2105 { ZBEE_ZCL_ATTR_ID_ELEC_MES_MEASURED_PHASE_11TH_HARMONIC_CURRENT, "Measured Phase 11th Harmonic Current" },
2106 { ZBEE_ZCL_ATTR_ID_ELEC_MES_AC_FREQUENCY_MULTIPLIER, "AC Frequency Multiplier" },
2107 { ZBEE_ZCL_ATTR_ID_ELEC_MES_AC_FREQUENCY_DIVISOR, "AC Frequency Divisor" },
2108 { ZBEE_ZCL_ATTR_ID_ELEC_MES_POWER_MULTIPLIER, "Power Multiplier" },
2109 { ZBEE_ZCL_ATTR_ID_ELEC_MES_POWER_DIVISOR, "Power Divisor" },
2110 { ZBEE_ZCL_ATTR_ID_ELEC_MES_HARMONIC_CURRENT_MULTIPLIER, "Harmonic Current Multiplier" },
2111 { ZBEE_ZCL_ATTR_ID_ELEC_MES_PHASE_HARMONIC_CURRENT_MULTIPLIER, "Phase Harmonic Current Multiplier" },
2112 { ZBEE_ZCL_ATTR_ID_ELEC_MES_LINE_CURRENT, "Line Current" },
2113 { ZBEE_ZCL_ATTR_ID_ELEC_MES_ACTIVE_CURRENT, "Active Current" },
2114 { ZBEE_ZCL_ATTR_ID_ELEC_MES_REACTIVE_CURRENT, "Reactive Current" },
2115 { ZBEE_ZCL_ATTR_ID_ELEC_MES_RMS_VOLTAGE, "RMS Voltage" },
2116 { ZBEE_ZCL_ATTR_ID_ELEC_MES_RMS_VOLTAGE_MIN, "RMS Voltage Min" },
2117 { ZBEE_ZCL_ATTR_ID_ELEC_MES_RMS_VOLTAGE_MAX, "RMS Voltage Max" },
2118 { ZBEE_ZCL_ATTR_ID_ELEC_MES_RMS_CURRENT, "RMS Current" },
2119 { ZBEE_ZCL_ATTR_ID_ELEC_MES_RMS_CURRENT_MIN, "RMS Current Min" },
2120 { ZBEE_ZCL_ATTR_ID_ELEC_MES_RMS_CURRENT_MAX, "RMS Current Max" },
2121 { ZBEE_ZCL_ATTR_ID_ELEC_MES_ACTIVE_POWER, "Active Power" },
2122 { ZBEE_ZCL_ATTR_ID_ELEC_MES_ACTIVE_POWER_MIN, "Active Power Min" },
2123 { ZBEE_ZCL_ATTR_ID_ELEC_MES_ACTIVE_POWER_MAX, "Active Power Max" },
2124 { ZBEE_ZCL_ATTR_ID_ELEC_MES_REACTIVE_POWER, "Reactive Power" },
2125 { ZBEE_ZCL_ATTR_ID_ELEC_MES_APPARENT_POWER, "Apparent Power" },
2126 { ZBEE_ZCL_ATTR_ID_ELEC_MES_POWER_FACTOR, "Power Factor" },
2127 { ZBEE_ZCL_ATTR_ID_ELEC_MES_AVERAGE_RMS_VOLTAGE_MEASUREMENT_PERIOD, "Average RMS Voltage Measurement Period" },
2128 { ZBEE_ZCL_ATTR_ID_ELEC_MES_AVERAGE_RMS_OVER_VOLTAGE_COUNTER, "Average RMS Over Voltage Counter" },
2129 { ZBEE_ZCL_ATTR_ID_ELEC_MES_AVERAGE_RMS_UNDER_VOLTAGE_COUNTER, "Average RMS Under Voltage Counter" },
2130 { ZBEE_ZCL_ATTR_ID_ELEC_MES_RMS_EXTREME_OVER_VOLTAGE_PERIOD, "RMS Extreme Over Voltage Period" },
2131 { ZBEE_ZCL_ATTR_ID_ELEC_MES_RMS_EXTREME_UNDER_VOLTAGE_PERIOD, "RMS Extreme Under Voltage Period" },
2132 { ZBEE_ZCL_ATTR_ID_ELEC_MES_RMS_VOLTAGE_SAG_PERIOD, "RMS Voltage Sag Period" },
2133 { ZBEE_ZCL_ATTR_ID_ELEC_MES_RMS_VOLTAGE_SWELL_PERIOD, "RMS Voltage Swell Period" },
2134 { ZBEE_ZCL_ATTR_ID_ELEC_MES_AC_VOLTAGE_MULTIPLIER, "AC Voltage Multiplier" },
2135 { ZBEE_ZCL_ATTR_ID_ELEC_MES_AC_VOLTAGE_DIVISOR, "AC Voltage Divisor" },
2136 { ZBEE_ZCL_ATTR_ID_ELEC_MES_AC_CURRENT_MULTIPLIER, "AC Current Multiplier" },
2137 { ZBEE_ZCL_ATTR_ID_ELEC_MES_AC_CURRENT_DIVISOR, "AC Current Divisor" },
2138 { ZBEE_ZCL_ATTR_ID_ELEC_MES_AC_POWER_MULTIPLIER, "AC Power Multiplier" },
2139 { ZBEE_ZCL_ATTR_ID_ELEC_MES_AC_POWER_DIVISOR, "AC Power Divisor" },
2140 { ZBEE_ZCL_ATTR_ID_ELEC_MES_DC_OVERLOAD_ALARMS_MASK, "DC Overload Alarms Mask" },
2141 { ZBEE_ZCL_ATTR_ID_ELEC_MES_DC_VOLTAGE_OVERLOAD, "DC Voltage Overload" },
2142 { ZBEE_ZCL_ATTR_ID_ELEC_MES_DC_CURRENT_OVERLOAD, "DC Current Overload" },
2143 { ZBEE_ZCL_ATTR_ID_ELEC_MES_AC_ALARMS_MASK, "AC Alarms Mask" },
2144 { ZBEE_ZCL_ATTR_ID_ELEC_MES_AC_VOLTAGE_OVERLOAD, "AC Voltage Overload" },
2145 { ZBEE_ZCL_ATTR_ID_ELEC_MES_AC_CURRENT_OVERLOAD, "AC Current Overload" },
2146 { ZBEE_ZCL_ATTR_ID_ELEC_MES_AC_ACTIVE_POWER_OVERLOAD, "AC Active Power Overload" },
2147 { ZBEE_ZCL_ATTR_ID_ELEC_MES_AC_REACTIVE_POWER_OVERLOAD, "AC Reactive Power Overload" },
2148 { ZBEE_ZCL_ATTR_ID_ELEC_MES_AVERAGE_RMS_OVER_VOLTAGE, "Average RMS Over Voltage" },
2149 { ZBEE_ZCL_ATTR_ID_ELEC_MES_AVERAGE_RMS_UNDER_VOLTAGE, "Average RMS Under Voltage" },
2150 { ZBEE_ZCL_ATTR_ID_ELEC_MES_RMS_EXTREME_OVER_VOLTAGE, "RMS Extreme Over Voltage" },
2151 { ZBEE_ZCL_ATTR_ID_ELEC_MES_RMS_EXTREME_UNDER_VOLTAGE, "RMS Extreme Under Voltage" },
2152 { ZBEE_ZCL_ATTR_ID_ELEC_MES_RMS_VOLTAGE_SAG, "RMS Voltage Sag" },
2153 { ZBEE_ZCL_ATTR_ID_ELEC_MES_RMS_VOLTAGE_SWELL, "RMS Voltage Swell" },
2154 { ZBEE_ZCL_ATTR_ID_ELEC_MES_LINE_CURRENT_PH_B, "Line Current Ph B" },
2155 { ZBEE_ZCL_ATTR_ID_ELEC_MES_ACTIVE_CURRENT_PH_B, "Active Current Ph B" },
2156 { ZBEE_ZCL_ATTR_ID_ELEC_MES_REACTIVE_CURRENT_PH_B, "Reactive Current Ph B" },
2157 { ZBEE_ZCL_ATTR_ID_ELEC_MES_RMS_VOLTAGE_PH_B, "RMS Voltage Ph B" },
2158 { ZBEE_ZCL_ATTR_ID_ELEC_MES_RMS_VOLTAGE_MIN_PH_B, "RMS Voltage Min Ph B" },
2159 { ZBEE_ZCL_ATTR_ID_ELEC_MES_RMS_VOLTAGE_MAX_PH_B, "RMS Voltage Max Ph B" },
2160 { ZBEE_ZCL_ATTR_ID_ELEC_MES_RMS_CURRENT_PH_B, "RMS Current Ph B" },
2161 { ZBEE_ZCL_ATTR_ID_ELEC_MES_RMS_CURRENT_MIN_PH_B, "RMS Current Min Ph B" },
2162 { ZBEE_ZCL_ATTR_ID_ELEC_MES_RMS_CURRENT_MAX_PH_B, "RMS Current Max Ph B" },
2163 { ZBEE_ZCL_ATTR_ID_ELEC_MES_ACTIVE_POWER_PH_B, "Active Power Ph B" },
2164 { ZBEE_ZCL_ATTR_ID_ELEC_MES_ACTIVE_POWER_MIN_PH_B, "Active Power Min Ph B" },
2165 { ZBEE_ZCL_ATTR_ID_ELEC_MES_ACTIVE_POWER_MAX_PH_B, "Active Power Max Ph B" },
2166 { ZBEE_ZCL_ATTR_ID_ELEC_MES_REACTIVE_POWER_PH_B, "Reactive Power Ph B" },
2167 { ZBEE_ZCL_ATTR_ID_ELEC_MES_APPARENT_POWER_PH_B, "Apparent Power Ph B" },
2168 { ZBEE_ZCL_ATTR_ID_ELEC_MES_POWER_FACTOR_PH_B, "Power Factor Ph B" },
2169 { ZBEE_ZCL_ATTR_ID_ELEC_MES_AVERAGE_RMS_VOLTAGE_MEASUREMENT_PERIOD_PH_B, "Average RMS Voltage Measurement Period Ph B" },
2170 { ZBEE_ZCL_ATTR_ID_ELEC_MES_AVERAGE_RMS_OVER_VOLTAGE_COUNTER_PH_B, "Average RMS Over Voltage Counter Ph B" },
2171 { ZBEE_ZCL_ATTR_ID_ELEC_MES_AVERAGE_RMS_UNDER_VOLTAGE_COUNTER_PH_B, "Average RMS Under Voltage Counter Ph B" },
2172 { ZBEE_ZCL_ATTR_ID_ELEC_MES_RMS_EXTREME_OVER_VOLTAGE_PERIOD_PH_B, "RMS Extreme Over Voltage Period Ph B" },
2173 { ZBEE_ZCL_ATTR_ID_ELEC_MES_RMS_EXTREME_UNDER_VOLTAGE_PERIOD_PH_B, "RMS Extreme Under Voltage Period Ph B" },
2174 { ZBEE_ZCL_ATTR_ID_ELEC_MES_RMS_VOLTAGE_SAG_PERIOD_PH_B, "RMS Voltage Sag Period Ph B" },
2175 { ZBEE_ZCL_ATTR_ID_ELEC_MES_RMS_VOLTAGE_SWELL_PERIOD_PH_B, "RMS Voltage Swell Period Ph B" },
2176 { ZBEE_ZCL_ATTR_ID_ELEC_MES_LINE_CURRENT_PH_C, "Line Current Ph C" },
2177 { ZBEE_ZCL_ATTR_ID_ELEC_MES_REACTIVE_CURRENT_PH_C, "Reactive Current Ph C" },
2178 { ZBEE_ZCL_ATTR_ID_ELEC_MES_RMS_VOLTAGE_PH_C, "RMS Voltage Ph C" },
2179 { ZBEE_ZCL_ATTR_ID_ELEC_MES_RMS_VOLTAGE_MIN_PH_C, "RMS Voltage Min Ph C" },
2180 { ZBEE_ZCL_ATTR_ID_ELEC_MES_RMS_VOLTAGE_MAX_PH_C, "RMS Voltage Max Ph C" },
2181 { ZBEE_ZCL_ATTR_ID_ELEC_MES_RMS_CURRENT_PH_C, "RMS Current Ph C" },
2182 { ZBEE_ZCL_ATTR_ID_ELEC_MES_RMS_CURRENT_MIN_PH_C, "RMS Current Min Ph C" },
2183 { ZBEE_ZCL_ATTR_ID_ELEC_MES_RMS_CURRENT_MAX_PH_C, "RMS Current Max Ph C" },
2184 { ZBEE_ZCL_ATTR_ID_ELEC_MES_ACTIVE_POWER_PH_C, "Active Power Ph C" },
2185 { ZBEE_ZCL_ATTR_ID_ELEC_MES_ACTIVE_POWER_MIN_PH_C, "Active Power Min Ph C" },
2186 { ZBEE_ZCL_ATTR_ID_ELEC_MES_ACTIVE_POWER_MAX_PH_C, "Active Power Max Ph C" },
2187 { ZBEE_ZCL_ATTR_ID_ELEC_MES_REACTIVE_POWER_PH_C, "Reactive Power Ph C" },
2188 { ZBEE_ZCL_ATTR_ID_ELEC_MES_APPARENT_POWER_PH_C, "Apparent Power Ph C" },
2189 { ZBEE_ZCL_ATTR_ID_ELEC_MES_POWER_FACTOR_PH_C, "Power Factor Ph C" },
2190 { ZBEE_ZCL_ATTR_ID_ELEC_MES_AVERAGE_RMS_VOLTAGE_MEASUREMENT_PERIOD_PH_C, "Average RMS Voltage Measurement Period Ph C" },
2191 { ZBEE_ZCL_ATTR_ID_ELEC_MES_AVERAGE_RMS_OVER_VOLTAGE_COUNTER_PH_C, "Average RMS Over Voltage Counter Ph C" },
2192 { ZBEE_ZCL_ATTR_ID_ELEC_MES_AVERAGE_RMS_UNDER_VOLTAGE_COUNTER_PH_C, "Average RMS Under Voltage Counter Ph C" },
2193 { ZBEE_ZCL_ATTR_ID_ELEC_MES_RMS_EXTREME_OVER_VOLTAGE_PERIOD_PH_C, "RMS Extreme Over Voltage Period Ph C" },
2194 { ZBEE_ZCL_ATTR_ID_ELEC_MES_RMS_EXTREME_UNDER_VOLTAGE_PERIOD_PH_C, "RMS Extreme Under Voltage Period Ph C" },
2195 { ZBEE_ZCL_ATTR_ID_ELEC_MES_RMS_VOLTAGE_SAG_PERIOD_PH_C, "RMS Voltage Sag Period Ph C" },
2196 { ZBEE_ZCL_ATTR_ID_ELEC_MES_RMS_VOLTAGE_SWELL_PERIOD_PH_C, "RMS Voltage Swell Period Ph C" },
2197 { 0, NULL }
2198 };
2199 static value_string_ext zbee_zcl_elec_mes_attr_names_ext = VALUE_STRING_EXT_INIT(zbee_zcl_elec_mes_attr_names);
2200
2201 /* Server Commands Received */
2202 static const value_string zbee_zcl_elec_mes_srv_rx_cmd_names[] = {
2203 { ZBEE_ZCL_CMD_GET_PROFILE_INFO, "Get Profile Info", },
2204 { ZBEE_ZCL_CMD_GET_MEASUREMENT_PROFILE_INFO, "Get Measurement Profile", },
2205 { 0, NULL }
2206 };
2207
2208 /* Server Commands Generated */
2209 static const value_string zbee_zcl_elec_mes_srv_tx_cmd_names[] = {
2210 { ZBEE_ZCL_CMD_GET_PROFILE_INFO_RESPONSE, "Get Profile Info Response", },
2211 { ZBEE_ZCL_CMD_GET_MEASUREMENT_PROFILE_INFO_RESPONSE, "Get Measurement Profile Response", },
2212 { 0, NULL }
2213 };
2214
2215 /* Profile Interval Period */
2216 static const value_string zbee_zcl_elec_mes_profile_interval_period_names[] = {
2217 { ZBEE_ZCL_ELEC_MES_PROFILE_INTERVAL_PERIOD_DAILY, "Daily", },
2218 { ZBEE_ZCL_ELEC_MES_PROFILE_INTERVAL_PERIOD_60_MINUTES, "60 Minutes", },
2219 { ZBEE_ZCL_ELEC_MES_PROFILE_INTERVAL_PERIOD_30_MINUTES, "30 Minutes", },
2220 { ZBEE_ZCL_ELEC_MES_PROFILE_INTERVAL_PERIOD_15_MINUTES, "15 Minutes", },
2221 { ZBEE_ZCL_ELEC_MES_PROFILE_INTERVAL_PERIOD_10_MINUTES, "10 Minutes", },
2222 { ZBEE_ZCL_ELEC_MES_PROFILE_INTERVAL_PERIOD_7_5_MINUTES, "7.5 Minutes", },
2223 { ZBEE_ZCL_ELEC_MES_PROFILE_INTERVAL_PERIOD_5_MINUTES, "5 Minutes", },
2224 { ZBEE_ZCL_ELEC_MES_PROFILE_INTERVAL_PERIOD_2_5_MINUTES, "2.5 Minutes", },
2225 { 0, NULL }
2226 };
2227
2228 /* List of Status Valid Values */
2229 static const value_string zbee_zcl_elec_mes_status_names[] = {
2230 { ZBEE_ZCL_ELEC_MES_STATUS_SUCCESS, "Success", },
2231 { ZBEE_ZCL_ELEC_MES_STATUS_ATTRIBUTE_PROFILE_NOT_SUPPORTED, "Attribute Profile not supported", },
2232 { ZBEE_ZCL_ELEC_MES_STATUS_INVALID_START_TIME, "Invalid Start Time", },
2233 { ZBEE_ZCL_ELEC_MES_STATUS_MORE_INTERVALS_REQUESTED_THAN_CAN_BE_RET, "More intervals requested than can be returned", },
2234 { ZBEE_ZCL_ELEC_MES_STATUS_NO_INTERVALS_AVAILABLE_FOR_THE_REQ_TIME, "No intervals available for the requested time", },
2235 { 0, NULL }
2236 };
2237
2238 /*************************/
2239 /* Function Bodies */
2240 /*************************/
2241
2242 /**
2243 *ZigBee ZCL Electrical Measurement cluster dissector for wireshark.
2244 *
2245 *@param tvb pointer to buffer containing raw packet.
2246 *@param pinfo pointer to packet information fields
2247 *@param tree pointer to data tree Wireshark uses to display packet.
2248 */
2249 static int
2250 dissect_zbee_zcl_elec_mes(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data)
2251 {
2252 proto_tree *payload_tree;
2253 zbee_zcl_packet *zcl;
2254 unsigned offset = 0;
2255 uint8_t cmd_id;
2256 int rem_len;
2257
2258 /* Reject the packet if data is NULL */
2259 if (data == NULL)
2260 return 0;
2261 zcl = (zbee_zcl_packet *)data;
2262 cmd_id = zcl->cmd_id;
2263
2264 /* Create a subtree for the ZCL Command frame, and add the command ID to it. */
2265 if (zcl->direction == ZBEE_ZCL_FCF_TO_SERVER) {
2266 /* Append the command name to the info column. */
2267 col_append_fstr(pinfo->cinfo, COL_INFO, "%s, Seq: %u",
2268 val_to_str_const(cmd_id, zbee_zcl_elec_mes_srv_rx_cmd_names, "Unknown Command"),
2269 zcl->tran_seqno);
2270
2271 /* Add the command ID. */
2272 proto_tree_add_uint(tree, hf_zbee_zcl_elec_mes_srv_rx_cmd_id, tvb, offset, 1, cmd_id);
2273
2274 /* Check is this command has a payload, than add the payload tree */
2275 rem_len = tvb_reported_length_remaining(tvb, ++offset);
2276 if (rem_len > 0) {
2277 payload_tree = proto_tree_add_subtree(tree, tvb, offset, rem_len, ett_zbee_zcl_elec_mes, NULL, "Payload");
2278
2279 /* Call the appropriate command dissector */
2280 switch (cmd_id) {
2281
2282 case ZBEE_ZCL_CMD_GET_PROFILE_INFO:
2283 /* No Payload */
2284 break;
2285
2286 case ZBEE_ZCL_CMD_GET_MEASUREMENT_PROFILE_INFO:
2287 dissect_zcl_elec_mes_get_measurement_profile_info(tvb, payload_tree, &offset);
2288 break;
2289
2290 default:
2291 break;
2292 }
2293 }
2294 }
2295 else { /* ZBEE_ZCL_FCF_TO_CLIENT */
2296 /* Append the command name to the info column. */
2297 col_append_fstr(pinfo->cinfo, COL_INFO, "%s, Seq: %u",
2298 val_to_str_const(cmd_id, zbee_zcl_elec_mes_srv_tx_cmd_names, "Unknown Command"),
2299 zcl->tran_seqno);
2300
2301 /* Add the command ID. */
2302 proto_tree_add_uint(tree, hf_zbee_zcl_elec_mes_srv_tx_cmd_id, tvb, offset, 1, cmd_id);
2303
2304 /* Check is this command has a payload, than add the payload tree */
2305 rem_len = tvb_reported_length_remaining(tvb, ++offset);
2306 if (rem_len > 0) {
2307 payload_tree = proto_tree_add_subtree(tree, tvb, offset, rem_len, ett_zbee_zcl_elec_mes, NULL, "Payload");
2308
2309 /* Call the appropriate command dissector */
2310 switch (cmd_id) {
2311
2312 case ZBEE_ZCL_CMD_GET_PROFILE_INFO_RESPONSE:
2313 dissect_zcl_elec_mes_get_profile_info_response(tvb, payload_tree, &offset);
2314 break;
2315
2316 case ZBEE_ZCL_CMD_GET_MEASUREMENT_PROFILE_INFO_RESPONSE:
2317 dissect_zcl_elec_mes_get_measurement_profile_info_response(tvb, payload_tree, &offset);
2318 break;
2319
2320 default:
2321 break;
2322 }
2323 }
2324 }
2325
2326 return tvb_captured_length(tvb);
2327 } /*dissect_zbee_zcl_elec_mes*/
2328
2329 /**
2330 *This function is called by ZCL foundation dissector in order to decode
2331 *
2332 *@param tree pointer to data tree Wireshark uses to display packet.
2333 *@param tvb pointer to buffer containing raw packet.
2334 *@param offset pointer to buffer offset
2335 *@param attr_id attribute identifier
2336 *@param data_type attribute data type
2337 *@param client_attr ZCL client
2338 */
2339 static void
2340 dissect_zcl_elec_mes_attr_data(proto_tree *tree, tvbuff_t *tvb, unsigned *offset, uint16_t attr_id, unsigned data_type, bool client_attr)
2341 {
2342 /* Dissect attribute data type and data */
2343 switch ( attr_id ) {
2344 default:
2345 dissect_zcl_attr_data(tvb, tree, offset, data_type, client_attr);
2346 break;
2347 }
2348 } /*dissect_zcl_elec_mes_attr_data*/
2349
2350 /**
2351 *This function manages the Get Measurement Profile Info payload
2352 *
2353 *@param tvb pointer to buffer containing raw packet.
2354 *@param tree pointer to data tree Wireshark uses to display packet.
2355 *@param offset pointer to offset from caller
2356 */
2357 static void dissect_zcl_elec_mes_get_measurement_profile_info(tvbuff_t *tvb, proto_tree *tree, unsigned *offset)
2358 {
2359 proto_tree_add_item(tree, hf_zbee_zcl_elec_mes_attr_id, tvb, *offset, 2, ENC_LITTLE_ENDIAN);
2360 *offset += 2;
2361
2362 proto_tree_add_item(tree, hf_zbee_zcl_elec_mes_start_time, tvb, *offset, 4, ENC_TIME_ZBEE_ZCL|ENC_LITTLE_ENDIAN);
2363 *offset += 4;
2364
2365 proto_tree_add_item(tree, hf_zbee_zcl_elec_mes_number_of_intervals, tvb, *offset, 1, ENC_NA);
2366 *offset += 1;
2367 }
2368
2369 /**
2370 *This function manages the Get Profile Info Response payload
2371 *
2372 *@param tvb pointer to buffer containing raw packet.
2373 *@param tree pointer to data tree Wireshark uses to display packet.
2374 *@param offset pointer to offset from caller
2375 */
2376 static void dissect_zcl_elec_mes_get_profile_info_response(tvbuff_t *tvb, proto_tree *tree, unsigned *offset)
2377 {
2378 proto_tree_add_item(tree, hf_zbee_zcl_elec_mes_profile_count, tvb, *offset, 1, ENC_NA);
2379 *offset += 1;
2380
2381 proto_tree_add_item(tree, hf_zbee_zcl_elec_mes_profile_interval_period, tvb, *offset, 1, ENC_NA);
2382 *offset += 1;
2383
2384 proto_tree_add_item(tree, hf_zbee_zcl_elec_mes_max_number_of_intervals, tvb, *offset, 1, ENC_NA);
2385 *offset += 1;
2386
2387 while (tvb_reported_length_remaining(tvb, *offset) > 0) {
2388 proto_tree_add_item(tree, hf_zbee_zcl_elec_mes_attr_id, tvb, *offset, 2, ENC_LITTLE_ENDIAN);
2389 *offset += 2;
2390 }
2391 }
2392
2393 /**
2394 *This function manages the Get Measurement Profile Info Response payload
2395 *
2396 *@param tvb pointer to buffer containing raw packet.
2397 *@param tree pointer to data tree Wireshark uses to display packet.
2398 *@param offset pointer to offset from caller
2399 */
2400 static void dissect_zcl_elec_mes_get_measurement_profile_info_response(tvbuff_t *tvb, proto_tree *tree, unsigned *offset)
2401 {
2402 unsigned rem_len;
2403
2404 proto_tree_add_item(tree, hf_zbee_zcl_elec_mes_start_time, tvb, *offset, 4, ENC_TIME_ZBEE_ZCL|ENC_LITTLE_ENDIAN);
2405 *offset += 4;
2406
2407 proto_tree_add_item(tree, hf_zbee_zcl_elec_mes_status, tvb, *offset, 1, ENC_NA);
2408 *offset += 1;
2409
2410 proto_tree_add_item(tree, hf_zbee_zcl_elec_mes_profile_interval_period, tvb, *offset, 1, ENC_NA);
2411 *offset += 1;
2412
2413 proto_tree_add_item(tree, hf_zbee_zcl_elec_mes_number_of_intervals_delivered, tvb, *offset, 1, ENC_NA);
2414 *offset += 1;
2415
2416 proto_tree_add_item(tree, hf_zbee_zcl_elec_mes_attr_id, tvb, *offset, 2, ENC_LITTLE_ENDIAN);
2417 *offset += 2;
2418
2419 rem_len = tvb_reported_length_remaining(tvb, *offset);
2420 proto_tree_add_item(tree, hf_zbee_zcl_elec_mes_intervals, tvb, *offset, rem_len, ENC_NA);
2421 *offset += rem_len;
2422 }
2423
2424 /**
2425 *This function registers the ZCL Occupancy Sensing dissector
2426 *
2427 */
2428 void
2429 proto_register_zbee_zcl_elec_mes(void)
2430 {
2431 static hf_register_info hf[] = {
2432
2433 { &hf_zbee_zcl_elec_mes_srv_tx_cmd_id,
2434 { "Command", "zbee_zcl_meas_sensing.elecmes.cmd.srv_tx.id", FT_UINT8, BASE_HEX, VALS(zbee_zcl_elec_mes_srv_tx_cmd_names),
2435 0x0, NULL, HFILL } },
2436
2437 { &hf_zbee_zcl_elec_mes_srv_rx_cmd_id,
2438 { "Command", "zbee_zcl_meas_sensing.elecmes.cmd.srv_rx.id", FT_UINT8, BASE_HEX, VALS(zbee_zcl_elec_mes_srv_rx_cmd_names),
2439 0x0, NULL, HFILL } },
2440
2441 { &hf_zbee_zcl_elec_mes_attr_id,
2442 { "Attribute", "zbee_zcl_meas_sensing.elecmes.attr_id", FT_UINT16, BASE_HEX | BASE_EXT_STRING, &zbee_zcl_elec_mes_attr_names_ext,
2443 0x0, NULL, HFILL } },
2444
2445 { &hf_zbee_zcl_elec_mes_start_time,
2446 { "Start Time", "zbee_zcl_meas_sensing.elecmes.start_time", FT_ABSOLUTE_TIME, ABSOLUTE_TIME_UTC, NULL,
2447 0x0, NULL, HFILL } },
2448
2449 { &hf_zbee_zcl_elec_mes_number_of_intervals,
2450 { "Number of Intervals", "zbee_zcl_meas_sensing.elecmes.number_of_intervals", FT_UINT8, BASE_DEC, NULL,
2451 0x0, NULL, HFILL } },
2452
2453 { &hf_zbee_zcl_elec_mes_profile_count,
2454 { "Profile Count", "zbee_zcl_meas_sensing.elecmes.profile_count", FT_UINT8, BASE_DEC, NULL,
2455 0x0, NULL, HFILL } },
2456
2457 { &hf_zbee_zcl_elec_mes_profile_interval_period,
2458 { "Profile Interval Period", "zbee_zcl_meas_sensing.elecmes.profile_interval_period", FT_UINT8, BASE_DEC, NULL,
2459 0x0, NULL, HFILL } },
2460
2461 { &hf_zbee_zcl_elec_mes_max_number_of_intervals,
2462 { "Max Number of Intervals", "zbee_zcl_meas_sensing.elecmes.max_number_of_intervals", FT_UINT8, BASE_DEC, VALS(zbee_zcl_elec_mes_profile_interval_period_names),
2463 0x0, NULL, HFILL } },
2464
2465 { &hf_zbee_zcl_elec_mes_status,
2466 { "Status", "zbee_zcl_meas_sensing.elecmes.status", FT_UINT8, BASE_HEX, VALS(zbee_zcl_elec_mes_status_names),
2467 0x0, NULL, HFILL } },
2468
2469 { &hf_zbee_zcl_elec_mes_number_of_intervals_delivered,
2470 { "Number of Intervals Delivered", "zbee_zcl_meas_sensing.elecmes.number_of_intervals_delivered", FT_UINT8, BASE_DEC, NULL,
2471 0x0, NULL, HFILL } },
2472
2473 { &hf_zbee_zcl_elec_mes_intervals,
2474 { "Intervals", "zbee_zcl_meas_sensing.elecmes.intervals", FT_BYTES, BASE_NONE, NULL,
2475 0x0, NULL, HFILL } }
2476 };
2477
2478 /* ZCL Electrical Measurement subtrees */
2479 static int *ett[ZBEE_ZCL_ELEC_MES_NUM_ETT];
2480 ett[0] = &ett_zbee_zcl_elec_mes;
2481
2482 /* Register the ZigBee ZCL Electrical Measurement cluster protocol name and description */
2483 proto_zbee_zcl_elec_mes = proto_register_protocol("ZigBee ZCL Electrical Measurement", "ZCL Electrical Measurement", ZBEE_PROTOABBREV_ZCL_ELECMES);
2484 proto_register_field_array(proto_zbee_zcl_elec_mes, hf, array_length(hf));
2485 proto_register_subtree_array(ett, array_length(ett));
2486
2487 /* Register the ZigBee ZCL Electrical Measurement dissector. */
2488 register_dissector(ZBEE_PROTOABBREV_ZCL_ELECMES, dissect_zbee_zcl_elec_mes, proto_zbee_zcl_elec_mes);
2489
2490 } /*proto_register_zbee_zcl_elec_mes*/
2491
2492
2493 /**
2494 *Hands off the ZCL Electrical Measurement dissector.
2495 *
2496 */
2497 void
2498 proto_reg_handoff_zbee_zcl_elec_mes(void)
2499 {
2500 zbee_zcl_init_cluster( ZBEE_PROTOABBREV_ZCL_ELECMES,
2501 proto_zbee_zcl_elec_mes,
2502 ett_zbee_zcl_elec_mes,
2503 ZBEE_ZCL_CID_ELECTRICAL_MEASUREMENT,
2504 ZBEE_MFG_CODE_NONE,
2505 hf_zbee_zcl_elec_mes_attr_id,
2506 -1,
2507 hf_zbee_zcl_elec_mes_srv_rx_cmd_id,
2508 hf_zbee_zcl_elec_mes_srv_tx_cmd_id,
2509 (zbee_zcl_fn_attr_data)dissect_zcl_elec_mes_attr_data
2510 );
2511 } /*proto_reg_handoff_zbee_zcl_elec_mes*/
2512
2513 /*
2514 * Editor modelines - https://www.wireshark.org/tools/modelines.html
2515 *
2516 * Local variables:
2517 * c-basic-offset: 4
2518 * tab-width: 8
2519 * indent-tabs-mode: nil
2520 * End:
2521 *
2522 * vi: set shiftwidth=4 tabstop=8 expandtab:
2523 * :indentSize=4:tabSize=8:noTabs=true:
2524 */
Metzes wireshark repo