Added RDMnet protocol

Transmit RDM packet over Ethernet using ACN protocol.
http://rdmprotocol.org/rdm/rdmnet/

Change-Id: I5bc1819e05b0d7a3c207b57cf2d86dc08aa9d1c3
Reviewed-on: https://code.wireshark.org/review/36194
Petri-Dish: Alexis La Goutte <alexis.lagoutte@gmail.com>
Tested-by: Petri Dish Buildbot
Reviewed-by: Anders Broman <a.broman58@gmail.com>

2 files changed, 9252 insertions, 2932 deletions

diff --git a/epan/dissectors/packet-acn.c b/epan/dissectors/packet-acn.c
index e91d9a4fb3..3d92c98f08 100644
--- a/epan/dissectors/packet-acn.c
+++ b/epan/dissectors/packet-acn.c
@@ -33,6 +33,9 @@
 #include <epan/to_str.h>
 #include <epan/expert.h>
 
+#include "packet-rdm.h"
+#include "packet-tcp.h"
+
 /* Forward declarations */
 void proto_register_acn(void);
 void proto_reg_handoff_acn(void);
@@ -74,17 +77,21 @@ void proto_reg_handoff_acn(void);
 #define ACN_DMP_ADT_A_4         2
 #define ACN_DMP_ADT_A_R         3
 
-#define ACN_PROTOCOL_ID_SDT           1
-#define ACN_PROTOCOL_ID_DMP           2
-#define ACN_PROTOCOL_ID_DMX           3
-#define ACN_PROTOCOL_ID_DMX_2         4
+#define ACN_PROTOCOL_ID_SDT           0x00000001
+#define ACN_PROTOCOL_ID_DMP           0x00000002
+#define ACN_PROTOCOL_ID_DMX           0x00000003
+#define ACN_PROTOCOL_ID_DMX_2         0x00000004
+#define ACN_PROTOCOL_ID_RPT           0x00000005
+#define ACN_PROTOCOL_ID_BROKER        0x00000009
+#define ACN_PROTOCOL_ID_LLRP          0x0000000A
+#define ACN_PROTOCOL_ID_EPT           0x0000000B
 
 #define ACN_ADDR_NULL                 0
 #define ACN_ADDR_IPV4                 1
 #define ACN_ADDR_IPV6                 2
 #define ACN_ADDR_IPPORT               3
 
-/* STD Messages */
+/* SDT Messages */
 #define ACN_SDT_VECTOR_UNKNOWN          0
 #define ACN_SDT_VECTOR_REL_WRAP         1
 #define ACN_SDT_VECTOR_UNREL_WRAP       2
@@ -173,6 +180,9 @@ void proto_reg_handoff_acn(void);
 #define ACN_BLOB_DHCP_CONFIG_STATIC_ROUTE           28
 #define ACN_BLOB_ENERGY_MANAGEMENT                  29
 #define ACN_BLOB_TIME3                              30
+#define ACN_BLOB_ENERGY_COST                        31
+#define ACN_BLOB_SEQUENCE_OPERATIONS                32
+#define ACN_BLOB_SEQUENCE_STEP_PROPERTIES           33
 
 #define ACN_BLOB_PRESET_PROPERTIES                  250
 
@@ -240,13 +250,173 @@ void proto_reg_handoff_acn(void);
 #define V2_CMD_PHYSICAL_BEACON_BY_CID      12
 #define V2_CMD_NET2_DOWNLOAD           110163
 
-#define MAGIC_SWITCH_TO_DYNAMIC_RESET_LEASE    0
-#define MAGIC_SWITCH_TO_DYNAMIC_MAINTAIN_LEASE 1
+#define MAGIC_SWITCH_TO_DYNAMIC_MAINTAIN_LEASE 0
+#define MAGIC_SWITCH_TO_DYNAMIC_RESET_LEASE    1
 
 #define MAGIC_DYNAMIC_IP_MAINTAIN_LEASE 0
 #define MAGIC_DYNAMIC_IP_RESET_LEASE    1
 #define MAGIC_STATIC_IP                 2
 
+/* E1.33 Table A-1  Broadcast UID Defines */
+#define ACN_RPT_ALL_CONTROLLERS                    0xFFFCFFFFFFFF
+#define ACN_RPT_ALL_DEVICES                        0xFFFDFFFFFFFF
+#define ACN_RPT_ALL_MID_DEVICES                    0xFFFDmmmmFFFF /*Addresses all Devices with the specific Manufacturer ID 0xmmmm*/
+
+/* E1.33 Table A-2  LLRP Constants */
+#define ACN_LLRP_MULTICAST_IPV4_ADDRESS_REQUEST    239.255.250.133
+#define ACN_LLRP_MULTICAST_IPV4_ADDRESS_RESPONSE   239.255.250.134
+#define ACN_LLRP_MULTICAST_IPV6_ADDRESS_REQUEST    ff18::85:0:0:85
+#define ACN_LLRP_MULTICAST_IPV6_ADDRESS_RESPONSE   ff18::85:0:0:86
+#define ACN_LLRP_PORT                              5569
+#define ACN_LLRP_TIMEOUT                           2  /*seconds*/
+#define ACN_LLRP_TARGET_TIMEOUT                    500 /*milliseconds*/
+#define ACN_LLRP_MAX_BACKOFF                       1.5 /*seconds*/
+#define ACN_LLRP_KNOWN_UID_SIZE                    200
+#define ACN_LLRP_BROADCAST_CID                     FBAD822C-BD0C-4D4C-BDC8-7EABEBC85AFF
+
+/* E1.33 Table A-3  Vector Defines for Root Layer PDU */
+/* (already defined above)
+ * #define ACN_PDU_VECTOR_ROOT_LLRP        0x0000000A
+ * #define ACN_PDU_VECTOR_ROOT_RPT         0x00000005
+ * #define ACN_PDU_VECTOR_ROOT_BROKER      0x00000009
+ * #define ACN_PDU_VECTOR_ROOT_EPT         0x0000000B
+ */
+
+/* E1.33 Table A-4  LLRP Messages */
+#define RDMNET_LLRP_VECTOR_PROBE_REQUEST   0x00000001
+#define RDMNET_LLRP_VECTOR_PROBE_REPLY     0x00000002
+#define RDMNET_LLRP_VECTOR_RDM_CMD         0x00000003
+
+#define RDMNET_LLRP_VECTOR_PROBE_REQUEST_CLIENT_TCP_INACTIVE  0x01
+#define RDMNET_LLRP_VECTOR_PROBE_REQUEST_BROKERS_ONLY         0x02
+
+#define RDMNET_LLRP_VECTOR_RDM_CMD_START_CODE                 0xCC
+
+/* E1.33 Table A-5  LLRP Probe Request Messages */
+#define VECTOR_PROBE_REQUEST_DATA   0x01
+
+/* E1.33 Table A-6  LLRP Probe Reply Messages */
+#define VECTOR_PROBE_REPLY_DATA     0x01
+
+/* E1.33 Table A-7  Broker Messages */
+#define RDMNET_BROKER_VECTOR_CONNECT                 0x0001
+#define RDMNET_BROKER_VECTOR_CONNECT_REPLY           0x0002
+#define RDMNET_BROKER_VECTOR_CLIENT_ENTRY_UPDATE     0x0003
+#define RDMNET_BROKER_VECTOR_REDIRECT_V4             0x0004
+#define RDMNET_BROKER_VECTOR_REDIRECT_V6             0x0005
+#define RDMNET_BROKER_VECTOR_FETCH_CLIENT_LIST       0x0006
+#define RDMNET_BROKER_VECTOR_CONNECTED_CLIENT_LIST   0x0007
+#define RDMNET_BROKER_VECTOR_CLIENT_ADD              0x0008
+#define RDMNET_BROKER_VECTOR_CLIENT_REMOVE           0x0009
+#define RDMNET_BROKER_VECTOR_CLIENT_ENTRY_CHANGE     0x000A
+#define RDMNET_BROKER_VECTOR_REQUEST_DYNAMIC_UIDS    0x000B
+#define RDMNET_BROKER_VECTOR_ASSIGNED_DYNAMIC_UIDS   0x000C
+#define RDMNET_BROKER_VECTOR_FETCH_DYNAMIC_UID_LIST  0x000D
+#define RDMNET_BROKER_VECTOR_DISCONNECT              0x000E
+#define RDMNET_BROKER_VECTOR_NULL                    0x000F
+
+#define RDMNET_BROKER_VECTOR_CONNECT_INCREMENTAL_UPDATES  0x01
+
+/* E1.33 Table A-8  RPT Messages */
+#define RDMNET_RPT_VECTOR_REQUEST        0x00000001
+#define RDMNET_RPT_VECTOR_STATUS         0x00000002
+#define RDMNET_RPT_VECTOR_NOTIFICATION   0x00000003
+
+/* E1.33 Table A-9  RPT Request PDUs */
+#define RDMNET_RPT_VECTOR_REQUEST_RDM_CMD   0x01
+
+/* E1.33 Table A-10  RPT Status PDUs */
+#define RDMNET_RPT_VECTOR_STATUS_UNKNOWN_RPT_UID         0x0001
+#define RDMNET_RPT_VECTOR_STATUS_RDM_TIMEOUT             0x0002
+#define RDMNET_RPT_VECTOR_STATUS_RDM_INVALID_RESPONSE    0x0003
+#define RDMNET_RPT_VECTOR_STATUS_UNKNOWN_RDM_UID         0x0004
+#define RDMNET_RPT_VECTOR_STATUS_UNKNOWN_ENDPOINT        0x0005
+#define RDMNET_RPT_VECTOR_STATUS_BROADCAST_COMPLETE      0x0006
+#define RDMNET_RPT_VECTOR_STATUS_UNKNOWN_VECTOR          0x0007
+#define RDMNET_RPT_VECTOR_STATUS_INVALID_MESSAGE         0x0008
+#define RDMNET_RPT_VECTOR_STATUS_INVALID_COMMAND_CLASS   0x0009
+
+/* E1.33 Table A-11  RPT Notification PDUs */
+#define RDMNET_RPT_VECTOR_NOTIFICATION_RDM_CMD   0x01
+
+/* E1.33 Table A-12  RDM Command PDUs */
+#define RDMNET_RPT_VECTOR_RDM_CMD_RD_DATA   0xCC
+
+/* E1.33 Table A-13  EPT PDUs */
+#define RDMNET_EPT_VECTOR_DATA     0x00000001
+#define RDMNET_EPT_VECTOR_STATUS   0x00000002
+
+/* E1.33 Table A-14  EPT Status PDUs */
+#define RDMNET_EPT_VECTOR_UNKNOWN_CID      0x0001
+#define RDMNET_EPT_VECTOR_UNKNOWN_VECTOR   0x0002
+
+/* E1.33 Table A-15  RDM Parameter IDs (only used in packet-rdm.c) */
+
+/* E1.33 Table A-16  RDM NACK Reason Codes (only used in packet-rdm.c) */
+
+/* E1.33 Table A-17 Static Config Types for Component Scope Messages (only used in packet-rdm.c) */
+
+/* E1.33 Table A-18 Broker States for Broker Status Messages (only used in packet-rdm.c) */
+
+/* E1.33 Table A-19 Connection Status Codes for Broker Connect */
+#define RDMNET_BROKER_CONNECT_OK                     0x0000
+#define RDMNET_BROKER_CONNECT_SCOPE_MISMATCH         0x0001
+#define RDMNET_BROKER_CONNECT_CAPACITY_EXCEEDED      0x0002
+#define RDMNET_BROKER_CONNECT_DUPLICATE_UID          0x0003
+#define RDMNET_BROKER_CONNECT_INVALID_CLIENT_ENTRY   0x0004
+#define RDMNET_BROKER_CONNECT_INVALID_UID            0x0005
+
+/* E1.33 Table A-20 Status Codes for Dynamic UID Mapping*/
+#define RDMNET_DYNAMIC_UID_STATUS_OK                  0x0000
+#define RDMNET_DYNAMIC_UID_STATUS_INVALID_REQUEST     0x0001
+#define RDMNET_DYNAMIC_UID_STATUS_UID_NOT_FOUND       0x0002
+#define RDMNET_DYNAMIC_UID_STATUS_DUPLICATE_RID       0x0003
+#define RDMNET_DYNAMIC_UID_STATUS_CAPACITY_EXHAUSTED  0x0004
+
+/* E1.33 Table A-21 Client Protocol Codes */
+#define RDMNET_CLIENT_PROTOCOL_RPT          0x00000005
+#define RDMNET_CLIENT_PROTOCOL_EPT          0x0000000B
+
+/* E1.33 Table A-22 RPT Client Type Codes */
+#define RDMNET_RPT_CLIENT_TYPE_DEVICE       0x00
+#define RDMNET_RPT_CLIENT_TYPE_CONTROLLER   0x01
+
+/* E1.33 Table A-23 LLRP Component Type Codes - LLRP TARGETS */
+#define RDMNET_LLRP_COMPONENT_TYPE_RPT_DEVICE       0x00 /* Target is a Device */
+#define RDMNET_LLRP_COMPONENT_TYPE_RPT_CONTROLLER   0x01 /* Target is a Controller */
+#define RDMNET_LLRP_COMPONENT_TYPE_BROKER           0x02 /* Target is a Broker */
+#define RDMNET_LLRP_COMPONENT_TYPE_NON_RDMNET       0xFF /* Target does not implement RDMnet other than LLRP */
+
+/* E1.33 Table A-24 RPT Client Disconnect Reason Codes */
+#define RDMNET_RPT_DISCONNECT_SHUTDOWN                   0x0000  /* Sent by Components to indicate that they are  */
+                                                                 /* about to shut down.                           */
+#define RDMNET_RPT_DISCONNECT_CAPACITY_EXHAUSTED         0x0001  /* Sent by Components when they do not           */
+                                                                 /* have the ability to support this connection.  */
+                                                                 /* Note that a Component must reserve certain    */
+                                                                 /* resources to be able to send this message     */
+                                                                 /* when it is in such a state.                   */
+#define RDMNET_RPT_DISCONNECT_HARDWARE_FAULT             0x0002  /* Sent by Components which must terminate a     */
+                                                                 /* connection due to an internal hardware fault  */
+#define RDMNET_RPT_DISCONNECT_SOFTWARE_FAULT             0x0003  /* Sent by Components which must terminate a     */
+                                                                 /* connection due to a software fault.           */
+#define RDMNET_RPT_DISCONNECT_SOFTWARE_RESET             0x0004  /* Sent by Components which must terminate a     */
+                                                                 /* connection because of a software reset.       */
+                                                                 /* This message should not be sent in the case   */
+                                                                 /* of a reboot, as the Shutdown message          */
+                                                                 /* is preferred.                                 */
+#define RDMNET_RPT_DISCONNECT_INCORRECT_SCOPE            0x0005  /* Sent by Brokers that are not on the           */
+                                                                 /* desired Scope.                                */
+#define RDMNET_RPT_DISCONNECT_RPT_RECONFIGURE            0x0006  /* Sent by components which must terminate a     */
+                                                                 /* connection because they were reconfigured     */
+                                                                 /* using RPT                                     */
+#define RDMNET_RPT_DISCONNECT_LLRP_RECONFIGURE           0x0007  /* Sent by Components which must terminate a     */
+                                                                 /* connection because they were reconfigured     */
+                                                                 /* using LLRP.                                   */
+#define RDMNET_RPT_DISCONNECT_USER_RECONFIGURE           0x0008  /* Sent by Components which must terminate a     */
+                                                                 /* connection because they were reconfigured     */
+                                                                 /* through some means outside the scope of this  */
+                                                                 /* standard (i.e. front panel configuration)     */
+
 typedef struct
 {
   guint32 start;
@@ -270,12 +440,14 @@ typedef struct
  * See
  * ANSI BSR E1.17 Architecture for Control Networks
  * ANSI BSR E1.31
+ * ANSI BSR E1.33 RDMnet
  */
 
 #define ACTUAL_ADDRESS  0
 /* forward reference */
 static guint32 acn_add_address(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *tree, int offset, const char *label);
 static int     dissect_acn(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree);
+static int     dissect_rdmnet(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 data_offset, gboolean is_udp);
 
 /* Global variables */
 static int proto_acn = -1;
@@ -292,11 +464,35 @@ static gint ett_acn_sdt_pdu = -1;
 static gint ett_acn_sdt_client_pdu = -1;
 static gint ett_acn_sdt_base_pdu = -1;
 static gint ett_acn_root_pdu = -1;
+
 static gint ett_acn_dmx_address = -1;
 static gint ett_acn_dmx_2_options = -1;
 static gint ett_acn_dmx_data_pdu = -1;
 static gint ett_acn_dmx_pdu = -1;
 
+static gint ett_rdmnet_pdu_flags = -1;
+static gint ett_rdmnet_llrp_base_pdu = -1;
+static gint ett_rdmnet_llrp_probe_request_pdu = -1;
+static gint ett_rdmnet_llrp_probe_request_filter_flags = -1;
+static gint ett_rdmnet_llrp_probe_reply_pdu = -1;
+static gint ett_rdmnet_llrp_rdm_command_pdu = -1;
+
+static gint ett_rdmnet_broker_base_pdu = -1;
+static gint ett_rdmnet_broker_client_entry_pdu = -1;
+static gint ett_rdmnet_broker_client_entry_manufacturer_protocol_ids = -1;
+static gint ett_rdmnet_broker_connect_connection_flags = -1;
+static gint ett_rdmnet_broker_client_entry_update_connection_flags = -1;
+
+static gint ett_rdmnet_rpt_base_pdu = -1;
+static gint ett_rdmnet_rpt_request_pdu = -1;
+static gint ett_rdmnet_rpt_status_pdu = -1;
+static gint ett_rdmnet_rpt_notification_pdu = -1;
+
+static gint ett_rdmnet_ept_base_pdu = -1;
+static gint ett_rdmnet_ept_data_pdu = -1;
+static gint ett_rdmnet_ept_data_vector_pdu = -1;
+static gint ett_rdmnet_ept_status_pdu = -1;
+
 /*  Register fields */
 /* In alphabetical order */
 static int hf_acn_association = -1;
@@ -379,6 +575,7 @@ static int hf_acn_reliable_sequence_number = -1;
 static int hf_acn_adhoc_expiry = -1;
 /* static int hf_acn_sdt_pdu = -1; */
 static int hf_acn_sdt_vector = -1;
+
 static int hf_acn_dmx_vector = -1;
 /* static int hf_acn_session_count = -1; */
 static int hf_acn_total_sequence_number = -1;
@@ -407,7 +604,6 @@ static gint     global_acn_dmx_display_line_format = 0;
 static gboolean global_acn_dmx_display_zeros = FALSE;
 static gboolean global_acn_dmx_display_leading_zeros = FALSE;
 
-
 static int proto_magic = -1;
 static gint ett_magic = -1;
 
@@ -443,11 +639,119 @@ static int hf_magic_reply_dcid = -1;
 
 static expert_field ei_magic_reply_invalid_type = EI_INIT;
 
+
+static int proto_rdmnet = -1;
+static gint ett_rdmnet = -1;
+
+/* Register fields */
+static int hf_rdmnet_cid = -1;
+static int hf_rdmnet_packet_identifier = -1;
+static int hf_rdmnet_pdu = -1;
+static int hf_rdmnet_pdu_flag_d = -1;
+static int hf_rdmnet_pdu_flag_h = -1;
+static int hf_rdmnet_pdu_flag_l = -1;
+static int hf_rdmnet_pdu_flag_v = -1;
+static int hf_rdmnet_pdu_flags = -1;
+static int hf_rdmnet_pdu_length = -1;
+static int hf_rdmnet_postamble_size = -1;
+static int hf_rdmnet_preamble_size = -1;
+static int hf_rdmnet_protocol_id = -1;
+static int hf_rdmnet_tcp_length = -1;
+
+static int hf_rdmnet_llrp_vector = -1;
+static int hf_rdmnet_llrp_destination_cid = -1;
+static int hf_rdmnet_llrp_transaction_number = -1;
+static int hf_rdmnet_llrp_probe_request_vector = -1;
+static int hf_rdmnet_llrp_probe_request_pdu_length = -1;
+static int hf_rdmnet_llrp_probe_request_lower_uid = -1;
+static int hf_rdmnet_llrp_probe_request_upper_uid = -1;
+static int hf_rdmnet_llrp_probe_request_filter = -1;
+static int hf_rdmnet_llrp_probe_request_filter_client_tcp_inactive = -1;
+static int hf_rdmnet_llrp_probe_request_filter_brokers_only = -1;
+static int hf_rdmnet_llrp_probe_request_known_uid = -1;
+
+static int hf_rdmnet_llrp_probe_reply_vector = -1;
+static int hf_rdmnet_llrp_probe_reply_uid = -1;
+static int hf_rdmnet_llrp_probe_reply_hardware_address = -1;
+static int hf_rdmnet_llrp_probe_reply_component_type = -1;
+static int hf_rdmnet_llrp_rdm_command_start_code = -1;
+
+static int hf_rdmnet_rpt_vector = -1;
+static int hf_rdmnet_rpt_source_uid = -1;
+static int hf_rdmnet_rpt_source_endpoint_id = -1;
+static int hf_rdmnet_rpt_destination_uid = -1;
+static int hf_rdmnet_rpt_destination_endpoint_id = -1;
+static int hf_rdmnet_rpt_sequence_number = -1;
+static int hf_rdmnet_rpt_reserved = -1;
+static int hf_rdmnet_rpt_request_vector = -1;
+static int hf_rdmnet_rpt_request_rdm_command = -1;
+static int hf_rdmnet_rpt_status_vector = -1;
+static int hf_rdmnet_rpt_status_unknown_rpt_uid_string = -1;
+static int hf_rdmnet_rpt_status_rdm_timeout_string = -1;
+static int hf_rdmnet_rpt_status_rdm_invalid_response_string = -1;
+static int hf_rdmnet_rpt_status_unknown_rdm_uid_string = -1;
+static int hf_rdmnet_rpt_status_unknown_endpoint_string = -1;
+static int hf_rdmnet_rpt_status_broadcast_complete_string = -1;
+static int hf_rdmnet_rpt_status_unknown_vector_string = -1;
+static int hf_rdmnet_rpt_notification_vector = -1;
+static int hf_rdmnet_rpt_notification_rdm_command = -1;
+
+static int hf_rdmnet_broker_vector = -1;
+static int hf_rdmnet_broker_client_protocol_vector = -1;
+static int hf_rdmnet_broker_client_protocol_cid = -1;
+static int hf_rdmnet_broker_client_rpt_client_uid = -1;
+static int hf_rdmnet_broker_client_rpt_client_type = -1;
+static int hf_rdmnet_broker_client_rpt_binding_cid = -1;
+static int hf_rdmnet_broker_client_ept_protocol_vector = -1;
+static int hf_rdmnet_broker_client_ept_protocol_manufacturer_id = -1;
+static int hf_rdmnet_broker_client_ept_protocol_protocol_id = -1;
+static int hf_rdmnet_broker_client_ept_protocol_string = -1;
+static int hf_rdmnet_broker_connect_client_scope = -1;
+static int hf_rdmnet_broker_connect_e133_version = -1;
+static int hf_rdmnet_broker_connect_search_domain = -1;
+static int hf_rdmnet_broker_connect_connection_flags = -1;
+static int hf_rdmnet_broker_connect_connection_flags_incremental_updates = -1;
+static int hf_rdmnet_broker_connect_reply_connection_code = -1;
+static int hf_rdmnet_broker_connect_reply_e133_version = -1;
+static int hf_rdmnet_broker_connect_reply_broker_uid = -1;
+static int hf_rdmnet_broker_connect_reply_client_uid = -1;
+static int hf_rdmnet_broker_client_entry_update_connection_flags = -1;
+static int hf_rdmnet_broker_client_entry_update_connection_flags_incremental_updates = -1;
+static int hf_rdmnet_broker_redirect_ipv4_address = -1;
+static int hf_rdmnet_broker_redirect_ipv4_tcp_port = -1;
+static int hf_rdmnet_broker_redirect_ipv6_address = -1;
+static int hf_rdmnet_broker_redirect_ipv6_tcp_port = -1;
+static int hf_rdmnet_broker_disconnect_reason = -1;
+static int hf_rdmnet_broker_dynamic_uid_request = -1;
+static int hf_rdmnet_broker_rid = -1;
+static int hf_rdmnet_broker_assigned_dynamic_uid = -1;
+static int hf_rdmnet_broker_assigned_rid = -1;
+static int hf_rdmnet_broker_assigned_status_code = -1;
+static int hf_rdmnet_broker_fetch_dynamic_uid = -1;
+
+static int hf_rdmnet_ept_vector = -1;
+static int hf_rdmnet_ept_destination_cid = -1;
+static int hf_rdmnet_ept_data_pdu_length = -1;
+static int hf_rdmnet_ept_data_vector = -1;
+static int hf_rdmnet_ept_data_vector_manfacturer_id = -1;
+static int hf_rdmnet_ept_data_vector_protocol_id = -1;
+static int hf_rdmnet_ept_data_opaque_data = -1;
+static int hf_rdmnet_ept_status_pdu_length = -1;
+static int hf_rdmnet_ept_status_vector = -1;
+static int hf_rdmnet_ept_status_unknown_cid = -1;
+static int hf_rdmnet_ept_status_status_string = -1;
+static int hf_rdmnet_ept_status_unknown_vector = -1;
+static int hf_rdmnet_ept_status_vector_string = -1;
+
 static const value_string acn_protocol_id_vals[] = {
-  { ACN_PROTOCOL_ID_SDT,   "SDT Protocol" },
-  { ACN_PROTOCOL_ID_DMP,   "DMP Protocol" },
-  { ACN_PROTOCOL_ID_DMX,   "DMX Protocol" },
-  { ACN_PROTOCOL_ID_DMX_2, "Ratified DMX Protocol" },
+  { ACN_PROTOCOL_ID_SDT,    "SDT Protocol" },
+  { ACN_PROTOCOL_ID_DMP,    "DMP Protocol" },
+  { ACN_PROTOCOL_ID_DMX,    "DMX Protocol" },
+  { ACN_PROTOCOL_ID_DMX_2,  "Ratified DMX Protocol" },
+  { ACN_PROTOCOL_ID_RPT,    "RDM Packet Transport Protocol" },
+  { ACN_PROTOCOL_ID_BROKER, "Broker Protocol" },
+  { ACN_PROTOCOL_ID_LLRP,   "Low Level Recovery Protocol" },
+  { ACN_PROTOCOL_ID_EPT,    "Etensible Packet Transport Protocol" },
   { 0,       NULL },
 };
 
@@ -481,29 +785,29 @@ static const value_string acn_dmp_adt_a_vals[] = {
 
 
 static const value_string acn_sdt_vector_vals[] = {
-  {ACN_SDT_VECTOR_UNKNOWN,        "Unknown"},
-  {ACN_SDT_VECTOR_REL_WRAP,       "Reliable Wrapper"},
-  {ACN_SDT_VECTOR_UNREL_WRAP,     "Unreliable Wrapper"},
-  {ACN_SDT_VECTOR_CHANNEL_PARAMS, "Channel Parameters"},
-  {ACN_SDT_VECTOR_JOIN,           "Join"},
-  {ACN_SDT_VECTOR_JOIN_REFUSE,    "Join Refuse"},
-  {ACN_SDT_VECTOR_JOIN_ACCEPT,    "Join Accept"},
-  {ACN_SDT_VECTOR_LEAVE,          "Leave"},
-  {ACN_SDT_VECTOR_LEAVING,        "Leaving"},
-  {ACN_SDT_VECTOR_CONNECT,        "Connect"},
-  {ACN_SDT_VECTOR_CONNECT_ACCEPT, "Connect Accept"},
-  {ACN_SDT_VECTOR_CONNECT_REFUSE, "Connect Refuse"},
-  {ACN_SDT_VECTOR_DISCONNECT,     "Disconnect"},
-  {ACN_SDT_VECTOR_DISCONNECTING,  "Disconnecting"},
-  {ACN_SDT_VECTOR_ACK,            "Ack"},
-  {ACN_SDT_VECTOR_NAK,            "Nak"},
-  {ACN_SDT_VECTOR_GET_SESSION,    "Get Session"},
-  {ACN_SDT_VECTOR_SESSIONS,       "Sessions"},
+  { ACN_SDT_VECTOR_UNKNOWN,        "Unknown"},
+  { ACN_SDT_VECTOR_REL_WRAP,       "Reliable Wrapper"},
+  { ACN_SDT_VECTOR_UNREL_WRAP,     "Unreliable Wrapper"},
+  { ACN_SDT_VECTOR_CHANNEL_PARAMS, "Channel Parameters"},
+  { ACN_SDT_VECTOR_JOIN,           "Join"},
+  { ACN_SDT_VECTOR_JOIN_REFUSE,    "Join Refuse"},
+  { ACN_SDT_VECTOR_JOIN_ACCEPT,    "Join Accept"},
+  { ACN_SDT_VECTOR_LEAVE,          "Leave"},
+  { ACN_SDT_VECTOR_LEAVING,        "Leaving"},
+  { ACN_SDT_VECTOR_CONNECT,        "Connect"},
+  { ACN_SDT_VECTOR_CONNECT_ACCEPT, "Connect Accept"},
+  { ACN_SDT_VECTOR_CONNECT_REFUSE, "Connect Refuse"},
+  { ACN_SDT_VECTOR_DISCONNECT,     "Disconnect"},
+  { ACN_SDT_VECTOR_DISCONNECTING,  "Disconnecting"},
+  { ACN_SDT_VECTOR_ACK,            "Ack"},
+  { ACN_SDT_VECTOR_NAK,            "Nak"},
+  { ACN_SDT_VECTOR_GET_SESSION,    "Get Session"},
+  { ACN_SDT_VECTOR_SESSIONS,       "Sessions"},
   { 0,       NULL },
 };
 
 static const value_string acn_dmx_vector_vals[] = {
-  {ACN_DMX_VECTOR,  "Streaming DMX"},
+  { ACN_DMX_VECTOR,  "Streaming DMX"},
   { 0,       NULL },
 };
 
@@ -613,8 +917,8 @@ static const value_string acn_blob_dimmer_properties2_field_name[] = {
   { 14, "Dimmer Mode" },
   { 15, "Dimmer Control" },
   { 16, "Dimmer Curve" },
-  { 17, "On Level Percent" },
-  { 18, "Off Level Percent" },
+  { 17, "Off Level Percent" },
+  { 18, "On Level Percent" },
   { 19, "On Time(sec)" },
   { 20, "Off Time(sec)" },
   { 21, "Dimmer AF Enabled" },
@@ -635,19 +939,20 @@ static const value_string acn_blob_dimmer_properties2_field_name[] = {
   { 36, "Allow In Preset" },
   { 37, "Allow In Panic" },
   { 38, "Allow In Panic DD" },
-  { 39, "Loads Reporting Mode" },
-  { 40, "New Dimmer Space Number" },
-  { 41, "New Dimmer Number" },
-  { 42, "DMX A Patch" },
-  { 43, "DMX B Patch" },
-  { 44, "sACN Patch" },
-  { 45, "DMX A Patch DD" },
-  { 46, "DMX B Patch DD" },
-  { 47, "sACN Patch DD" },
-  { 48, "DMX A 16-bit Enable" },
-  { 49, "DMX B 16-bit Enable" },
-  { 50, "sACN 16-bit Enable" },
-  { 51, "Dimmer Zone" },
+  { 39, "Report No Loads" },
+  { 40, "Loads Error Reporting Enabled" },
+  { 41, "New Dimmer Space Number" },
+  { 42, "New Dimmer Number" },
+  { 43, "DMX A Patch" },
+  { 44, "DMX B Patch" },
+  { 45, "sACN Patch" },
+  { 46, "DMX A Patch DD" },
+  { 47, "DMX B Patch DD" },
+  { 48, "sACN Patch DD" },
+  { 49, "DMX A 16-bit Enable" },
+  { 40, "DMX B 16-bit Enable" },
+  { 51, "sACN 16-bit Enable" },
+  { 52, "Dimmer Zone" },
   { 0, NULL }
 };
 static value_string_ext acn_blob_dimmer_properties2_field_name_ext = VALUE_STRING_EXT_INIT(acn_blob_dimmer_properties2_field_name);
@@ -681,31 +986,33 @@ static const value_string acn_blob_dimmer_rack_properties2_field_name[] = {
   { 26, "Data Loss Fade Time sACN" },
   { 27, "Data Loss Preset DMX A" },
   { 28, "Data Loss Preset DMX B" },
-  { 29, "Data Port Priority DMX A" },
-  { 30, "Data Port Priority DMX B" },
-  { 31, "Data Port Enabled DMX A" },
-  { 32, "Data Port Enabled DMX B" },
-  { 33, "Data Port Enabled sACN" },
-  { 34, "16 Bit Enabled DMX A" },
-  { 35, "16 Bit Enabled DMX B" },
-  { 36, "16 Bit Enabled sACN" },
-  { 37, "Patch From Home Screen" },
-  { 38, "SCR Off Time" },
-  { 39, "Time Mode" },
-  { 40, "Offset from UTC" },
-  { 41, "Universal Hold Last Look Time" },
-  { 42, "Reactivate Presets On Boot" },
-  { 43, "Voltage High Warning Level" },
-  { 44, "Temperature High Warning Level" },
-  { 45, "Fan Operation Timing" },
-  { 46, "Allow Backplane Communication Errors" },
-  { 47, "Activate Presets on Boot" },
-  { 48, "SmartLink2 Power Supply Enable" },
-  { 49, "Remote Record Enable" },
-  { 50, "System Number" },
-  { 51, "Architectural Priority" },
-  { 52, "Data Loss Preset Space DMX A" },
-  { 53, "Data Loss Preset Space DMX B" },
+  { 29, "Data Loss Preset sACN" },
+  { 20, "Data Port Priority DMX A" },
+  { 31, "Data Port Priority DMX B" },
+  { 32, "Data Port Enabled DMX A" },
+  { 33, "Data Port Enabled DMX B" },
+  { 34, "Data Port Enabled sACN" },
+  { 35, "16 Bit Enabled DMX A" },
+  { 36, "16 Bit Enabled DMX B" },
+  { 37, "16 Bit Enabled sACN" },
+  { 38, "Patch From Home Screen" },
+  { 39, "SCR Off Time" },
+  { 30, "Time Mode" },
+  { 41, "Offset from UTC" },
+  { 42, "Universal Hold Last Look Time" },
+  { 43, "Reactivate Presets On Boot" },
+  { 44, "Voltage High Warning Level" },
+  { 45, "Temperature High Warning Level" },
+  { 46, "Fan Operation Timing" },
+  { 47, "Allow Backplane Communication Errors" },
+  { 48, "Activate Presets on Boot" },
+  { 49, "SmartLink2 Power Supply Enable" },
+  { 40, "Remote Record Enable" },
+  { 51, "System Number" },
+  { 52, "Architectural Priority" },
+  { 53, "Data Loss Preset Space DMX A" },
+  { 54, "Data Loss Preset Space DMX B" },
+  { 55, "Arch. Off Behavior" },
   { 0, NULL }
 };
 static value_string_ext acn_blob_dimmer_rack_properties2_field_name_ext = VALUE_STRING_EXT_INIT(acn_blob_dimmer_rack_properties2_field_name);
@@ -2118,6 +2425,233 @@ static const value_string acn_blob_time3_locality_vals[] = {
   { 0, NULL }
 };
 
+static const value_string acn_blob_energy_cost_field_name[] = {
+  { 1, "Month" },
+  { 2, "Day" },
+  { 3, "Cost per Hour" },
+  { 0, NULL }
+};
+
+static const value_string acn_blob_sequence_operation_field_name[] = {
+  { 1, "Operation Type" },
+  { 2, "Space" },
+  { 3, "Sequence Number" },
+  { 3, "Step Number" },
+  { 0, NULL }
+};
+
+static const value_string acn_blob_sequence_step_properties_field_name[] = {
+  { 1, "System" },
+  { 2, "Processor" },
+  { 3, "Rack" },
+  { 4, "Lug" },
+  { 5, "Module" },
+  { 6, "Station" },
+  { 7, "Port" },
+  { 8, "Subdevice" },
+  { 9, "Space" },
+  { 10, "UDN" },
+  { 11, "Reserved" },
+  { 12, "Sequence Number" },
+  { 13, "Step Number" },
+  { 14, "Fade Time" },
+  { 15, "Hold Time" },
+  { 16, "Level[0]" },
+  { 17, "Level[1]" },
+  { 18, "Level[2]" },
+  { 19, "Level[3]" },
+  { 20, "Level[4]" },
+  { 21, "Level[5]" },
+  { 22, "Level[6]" },
+  { 23, "Level[7]" },
+  { 24, "Level[8]" },
+  { 25, "Level[9]" },
+  { 26, "Level[10]" },
+  { 27, "Level[11]" },
+  { 28, "Level[12]" },
+  { 29, "Level[13]" },
+  { 30, "Level[14]" },
+  { 31, "Level[15]" },
+  { 32, "Level[16]" },
+  { 33, "Level[17]" },
+  { 34, "Level[18]" },
+  { 35, "Level[19]" },
+  { 36, "Level[20]" },
+  { 37, "Level[21]" },
+  { 38, "Level[22]" },
+  { 39, "Level[23]" },
+  { 40, "Level[24]" },
+  { 41, "Level[25]" },
+  { 42, "Level[26]" },
+  { 43, "Level[27]" },
+  { 44, "Level[28]" },
+  { 45, "Level[29]" },
+  { 46, "Level[30]" },
+  { 47, "Level[31]" },
+  { 48, "Level[32]" },
+  { 49, "Level[33]" },
+  { 50, "Level[34]" },
+  { 51, "Level[35]" },
+  { 52, "Level[36]" },
+  { 53, "Level[37]" },
+  { 54, "Level[38]" },
+  { 55, "Level[39]" },
+  { 56, "Level[40]" },
+  { 57, "Level[41]" },
+  { 58, "Level[42]" },
+  { 59, "Level[43]" },
+  { 60, "Level[44]" },
+  { 61, "Level[45]" },
+  { 62, "Level[46]" },
+  { 63, "Level[47]" },
+  { 64, "Level[48]" },
+  { 65, "Level[49]" },
+  { 66, "Level[50]" },
+  { 67, "Level[51]" },
+  { 68, "Level[52]" },
+  { 69, "Level[53]" },
+  { 70, "Level[54]" },
+  { 71, "Level[55]" },
+  { 72, "Level[56]" },
+  { 73, "Level[57]" },
+  { 74, "Level[58]" },
+  { 75, "Level[59]" },
+  { 76, "Level[60]" },
+  { 77, "Level[61]" },
+  { 78, "Level[62]" },
+  { 79, "Level[63]" },
+  { 80, "Level[64]" },
+  { 81, "Level[65]" },
+  { 82, "Level[66]" },
+  { 83, "Level[67]" },
+  { 84, "Level[68]" },
+  { 85, "Level[69]" },
+  { 86, "Level[70]" },
+  { 87, "Level[71]" },
+  { 88, "Level[72]" },
+  { 89, "Level[73]" },
+  { 90, "Level[74]" },
+  { 91, "Level[75]" },
+  { 92, "Level[76]" },
+  { 93, "Level[77]" },
+  { 94, "Level[78]" },
+  { 95, "Level[79]" },
+  { 96, "Level[80]" },
+  { 97, "Level[81]" },
+  { 98, "Level[82]" },
+  { 99, "Level[83]" },
+  { 100, "Level[84]" },
+  { 101, "Level[85]" },
+  { 102, "Level[86]" },
+  { 103, "Level[87]" },
+  { 104, "Level[88]" },
+  { 105, "Level[89]" },
+  { 106, "Level[90]" },
+  { 107, "Level[91]" },
+  { 108, "Level[92]" },
+  { 109, "Level[93]" },
+  { 110, "Level[94]" },
+  { 111, "Level[95]" },
+  { 112, "Level[96]" },
+  { 113, "Level[97]" },
+  { 114, "Level[98]" },
+  { 115, "Level[99]" },
+  { 116, "Level[100]" },
+  { 117, "Level[101]" },
+  { 118, "Level[102]" },
+  { 119, "Level[103]" },
+  { 120, "Level[104]" },
+  { 121, "Level[105]" },
+  { 122, "Level[106]" },
+  { 123, "Level[107]" },
+  { 124, "Level[108]" },
+  { 125, "Level[109]" },
+  { 126, "Level[110]" },
+  { 127, "Level[111]" },
+  { 128, "Level[112]" },
+  { 129, "Level[113]" },
+  { 130, "Level[114]" },
+  { 131, "Level[115]" },
+  { 132, "Level[116]" },
+  { 133, "Level[117]" },
+  { 134, "Level[118]" },
+  { 135, "Level[119]" },
+  { 136, "Level[120]" },
+  { 137, "Level[121]" },
+  { 138, "Level[122]" },
+  { 139, "Level[123]" },
+  { 140, "Level[124]" },
+  { 141, "Level[125]" },
+  { 142, "Level[126]" },
+  { 143, "Level[127]" },
+  { 144, "Level[128]" },
+  { 145, "Level[129]" },
+  { 146, "Level[130]" },
+  { 147, "Level[131]" },
+  { 148, "Level[132]" },
+  { 149, "Level[133]" },
+  { 150, "Level[134]" },
+  { 151, "Level[135]" },
+  { 152, "Level[136]" },
+  { 153, "Level[137]" },
+  { 154, "Level[138]" },
+  { 155, "Level[139]" },
+  { 156, "Level[140]" },
+  { 157, "Level[141]" },
+  { 158, "Level[142]" },
+  { 159, "Level[143]" },
+  { 160, "Level[144]" },
+  { 161, "Level[145]" },
+  { 162, "Level[146]" },
+  { 163, "Level[147]" },
+  { 164, "Level[148]" },
+  { 165, "Level[149]" },
+  { 166, "Level[150]" },
+  { 167, "Level[151]" },
+  { 168, "Level[152]" },
+  { 169, "Level[153]" },
+  { 170, "Level[154]" },
+  { 171, "Level[155]" },
+  { 172, "Level[156]" },
+  { 173, "Level[157]" },
+  { 174, "Level[158]" },
+  { 175, "Level[159]" },
+  { 176, "Level[160]" },
+  { 177, "Level[161]" },
+  { 178, "Level[162]" },
+  { 179, "Level[163]" },
+  { 180, "Level[164]" },
+  { 181, "Level[165]" },
+  { 182, "Level[166]" },
+  { 183, "Level[167]" },
+  { 184, "Level[168]" },
+  { 185, "Level[169]" },
+  { 186, "Level[170]" },
+  { 187, "Level[171]" },
+  { 188, "Level[172]" },
+  { 189, "Level[173]" },
+  { 190, "Level[174]" },
+  { 191, "Level[175]" },
+  { 192, "Level[176]" },
+  { 193, "Level[177]" },
+  { 194, "Level[178]" },
+  { 195, "Level[179]" },
+  { 196, "Level[180]" },
+  { 197, "Level[181]" },
+  { 198, "Level[182]" },
+  { 199, "Level[183]" },
+  { 200, "Level[184]" },
+  { 201, "Level[185]" },
+  { 202, "Level[186]" },
+  { 203, "Level[187]" },
+  { 204, "Level[188]" },
+  { 205, "Level[189]" },
+  { 206, "Level[190]" },
+  { 207, "Level[191]" },
+  { 0, NULL }
+};
+static value_string_ext acn_blob_sequence_step_properties_field_name_ext = VALUE_STRING_EXT_INIT(acn_blob_sequence_step_properties_field_name);
+
 static const value_string acn_blob_type_vals[] = {
   { ACN_BLOB_IPV4,                           "IPv4 Blob" },
   { ACN_BLOB_IPV6,                           "IPv6 Blob" },
@@ -2150,6 +2684,9 @@ static const value_string acn_blob_type_vals[] = {
   { ACN_BLOB_ENERGY_MANAGEMENT,              "Energy Management Blob" },
   { ACN_BLOB_PRESET_PROPERTIES,              "Preset Properties Blob" },
   { ACN_BLOB_TIME3,                          "Time Blob v2" },
+  { ACN_BLOB_ENERGY_COST,                    "Energy Cost Blob" },
+  { ACN_BLOB_SEQUENCE_OPERATIONS,            "Sequence Operations Blob" },
+  { ACN_BLOB_SEQUENCE_STEP_PROPERTIES,       "Sequence Step Properties Blob" },
   { 0, NULL }
 };
 
@@ -2267,8 +2804,8 @@ static const value_string magic_command_vals[] = {
 };
 
 static const value_string magic_reset_lease_vals[] = {
-  { MAGIC_SWITCH_TO_DYNAMIC_RESET_LEASE,    "Reset lease" },
   { MAGIC_SWITCH_TO_DYNAMIC_MAINTAIN_LEASE, "Maintain lease" },
+  { MAGIC_SWITCH_TO_DYNAMIC_RESET_LEASE,    "Reset lease" },
   { 0, NULL }
 };
 
@@ -2279,6 +2816,142 @@ static const value_string magic_ip_configuration_vals[] = {
   { 0, NULL }
 };
 
+static const value_string rdmnet_llrp_vector_vals[] = {
+  { RDMNET_LLRP_VECTOR_PROBE_REQUEST, "LLRP probe request" },
+  { RDMNET_LLRP_VECTOR_PROBE_REPLY,   "LLRP probe reply" },
+  { RDMNET_LLRP_VECTOR_RDM_CMD,       "LLRP RDM command" },
+  { 0, NULL }
+};
+
+static const value_string rdmnet_llrp_probe_request_vals[] = {
+  { VECTOR_PROBE_REQUEST_DATA, "Vector probe request data" },
+  { 0, NULL }
+};
+
+static const value_string rdmnet_llrp_probe_reply_vals[] = {
+  { VECTOR_PROBE_REPLY_DATA, "Vector probe reply data" },
+  { 0, NULL }
+};
+
+static const value_string rdmnet_llrp_probe_reply_component_type_vals[] = {
+  { RDMNET_LLRP_COMPONENT_TYPE_RPT_DEVICE,      "Device target" },
+  { RDMNET_LLRP_COMPONENT_TYPE_RPT_CONTROLLER,  "Controller target" },
+  { RDMNET_LLRP_COMPONENT_TYPE_BROKER,          "Broker target" },
+  { RDMNET_LLRP_COMPONENT_TYPE_NON_RDMNET,      "Non RDMnet target" },
+  { 0, NULL }
+};
+
+static const value_string rdmnet_llrp_rdm_command_start_code_vals[] = {
+  { RDMNET_LLRP_VECTOR_RDM_CMD_START_CODE,  "RDM Start Code" },
+  { 0, NULL }
+};
+
+static const value_string rdmnet_broker_disconnect_reason_vals[] = {
+  { RDMNET_RPT_DISCONNECT_SHUTDOWN,               "Component shut down" },
+  { RDMNET_RPT_DISCONNECT_CAPACITY_EXHAUSTED,     "Component capacity exhausted" },
+  { RDMNET_RPT_DISCONNECT_HARDWARE_FAULT,         "Component hardware fault" },
+  { RDMNET_RPT_DISCONNECT_SOFTWARE_FAULT,         "Component software fault" },
+  { RDMNET_RPT_DISCONNECT_SOFTWARE_RESET,         "Component software reset" },
+  { RDMNET_RPT_DISCONNECT_INCORRECT_SCOPE,        "Broker incorrect scope" },
+  { RDMNET_RPT_DISCONNECT_LLRP_RECONFIGURE,       "Component reconfigured by LLRP" },
+  { RDMNET_RPT_DISCONNECT_RPT_RECONFIGURE,        "Component reconfigured by RPT" },
+  { RDMNET_RPT_DISCONNECT_USER_RECONFIGURE,       "Component reconfigured by user" },
+  { 0, NULL }
+};
+
+static const value_string rdmnet_rpt_vector_vals[] = {
+  { RDMNET_RPT_VECTOR_REQUEST,       "Request" },
+  { RDMNET_RPT_VECTOR_STATUS,        "Status" },
+  { RDMNET_RPT_VECTOR_NOTIFICATION,  "Notification" },
+  { 0, NULL }
+};
+
+static const value_string rdmnet_rpt_request_vals[] = {
+  { RDMNET_RPT_VECTOR_REQUEST_RDM_CMD,  "RDM Command" },
+  { 0, NULL }
+};
+
+static const value_string rdmnet_rpt_status_vector_vals[] = {
+  { RDMNET_RPT_VECTOR_STATUS_UNKNOWN_RPT_UID,        "Unknown RPT UID" },
+  { RDMNET_RPT_VECTOR_STATUS_RDM_TIMEOUT,            "RDM Timeout" },
+  { RDMNET_RPT_VECTOR_STATUS_RDM_INVALID_RESPONSE,   "Invalid RDM Response" },
+  { RDMNET_RPT_VECTOR_STATUS_UNKNOWN_RDM_UID,        "Unknown RDM UID" },
+  { RDMNET_RPT_VECTOR_STATUS_UNKNOWN_ENDPOINT,       "Unknown Endpoint" },
+  { RDMNET_RPT_VECTOR_STATUS_BROADCAST_COMPLETE,     "Broadcast Complete" },
+  { RDMNET_RPT_VECTOR_STATUS_UNKNOWN_VECTOR,         "Unknown Vector" },
+  { RDMNET_RPT_VECTOR_STATUS_INVALID_MESSAGE,        "Invalid Message" },
+  { RDMNET_RPT_VECTOR_STATUS_INVALID_COMMAND_CLASS,  "Invalid Command Class" },
+  { 0, NULL }
+};
+
+static const value_string rdmnet_rpt_notification_vals[] = {
+  { RDMNET_RPT_VECTOR_NOTIFICATION_RDM_CMD,  "RDM Command" },
+  { 0, NULL }
+};
+
+static const value_string rdmnet_rpt_request_rdm_command_start_code_vals[] = {
+  { RDMNET_RPT_VECTOR_RDM_CMD_RD_DATA,  "RDM Start Code" },
+  { 0, NULL }
+};
+
+static const value_string rdmnet_broker_vector_vals[] = {
+  { RDMNET_BROKER_VECTOR_FETCH_CLIENT_LIST,       "Fetch client list" },
+  { RDMNET_BROKER_VECTOR_CONNECTED_CLIENT_LIST,   "Connected client list" },
+  { RDMNET_BROKER_VECTOR_CLIENT_ADD,              "Add client" },
+  { RDMNET_BROKER_VECTOR_CLIENT_REMOVE,           "Remove client" },
+  { RDMNET_BROKER_VECTOR_CLIENT_ENTRY_CHANGE,     "Change client entry" },
+  { RDMNET_BROKER_VECTOR_CONNECT,                 "Connect" },
+  { RDMNET_BROKER_VECTOR_CONNECT_REPLY,           "Connect reply" },
+  { RDMNET_BROKER_VECTOR_CLIENT_ENTRY_UPDATE,     "Update client entry" },
+  { RDMNET_BROKER_VECTOR_REDIRECT_V4,             "Redirect IP v4" },
+  { RDMNET_BROKER_VECTOR_REDIRECT_V6,             "Redirect IP v6" },
+  { RDMNET_BROKER_VECTOR_DISCONNECT,              "Disconnect" },
+  { RDMNET_BROKER_VECTOR_NULL,                    "Null" },
+  { RDMNET_BROKER_VECTOR_REQUEST_DYNAMIC_UIDS,    "Request Dynamic UIDs" },
+  { RDMNET_BROKER_VECTOR_ASSIGNED_DYNAMIC_UIDS,   "Assigned Dynamic UIDs" },
+  { RDMNET_BROKER_VECTOR_FETCH_DYNAMIC_UID_LIST,  "Fetch dynamic UID List" },
+  { 0, NULL }
+};
+
+static const value_string rdmnet_broker_status_code_vals[] = {
+  { RDMNET_BROKER_CONNECT_OK,                    "Ok" },
+  { RDMNET_BROKER_CONNECT_SCOPE_MISMATCH,        "Scope mismatch" },
+  { RDMNET_BROKER_CONNECT_CAPACITY_EXCEEDED,     "Capacity exceeded" },
+  { RDMNET_BROKER_CONNECT_DUPLICATE_UID,         "Duplicate UID" },
+  { RDMNET_BROKER_CONNECT_INVALID_CLIENT_ENTRY,  "Invalid client entry" },
+  { RDMNET_BROKER_CONNECT_INVALID_UID,           "Invalid UID" },
+  { 0, NULL }
+};
+
+static const value_string dynamic_uid_mapping_status_code_vals[] = {
+  { RDMNET_DYNAMIC_UID_STATUS_OK,                 "Dynamic UID Status Ok" },
+  { RDMNET_DYNAMIC_UID_STATUS_INVALID_REQUEST,    "Dynamic UID Status Invalid Request" },
+  { RDMNET_DYNAMIC_UID_STATUS_UID_NOT_FOUND,      "Dynamic UID Status UID Not Found" },
+  { RDMNET_DYNAMIC_UID_STATUS_DUPLICATE_RID,      "Dynamic UID Status Duplicate RID" },
+  { RDMNET_DYNAMIC_UID_STATUS_CAPACITY_EXHAUSTED, "Dynamic UID Status Capacity Exhausted" },
+  { 0, NULL }
+};
+
+static const value_string broker_client_protocol_vals[] = {
+  { RDMNET_CLIENT_PROTOCOL_RPT,  "Client Protocol RPT" },
+  { RDMNET_CLIENT_PROTOCOL_EPT,  "Client Protocol EPT" },
+  { 0, NULL }
+};
+
+static const value_string broker_client_rpt_client_type_vals[] = {
+  { RDMNET_RPT_CLIENT_TYPE_DEVICE,      "Device" },
+  { RDMNET_RPT_CLIENT_TYPE_CONTROLLER,  "Controller" },
+  { 0, NULL }
+};
+
+static const value_string rdmnet_ept_vector_vals[] = {
+  { RDMNET_EPT_VECTOR_DATA,    "Data" },
+  { RDMNET_EPT_VECTOR_STATUS,  "Status" },
+  { 0, NULL }
+};
+
+static dissector_handle_t rdm_handle;
+
 /******************************************************************************/
 /* Test to see if it is a Magic Bullet Packet                                 */
 static gboolean
@@ -2488,27 +3161,111 @@ dissect_magic(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
 }
 
 /******************************************************************************/
-/* Test to see if it is an ACN Packet                                         */
+/* Test to see if it is an ACN or an RDMnet Packet over UDP                   */
 static gboolean
-is_acn(tvbuff_t *tvb)
+is_acn_or_rdmnet_over_udp(tvbuff_t *tvb, guint32 *protocol_id)
 {
   static const char acn_packet_id[] = "ASC-E1.17\0\0\0";  /* must be 12 bytes */
+  guint32  offset;
+  guint8   pdu_flags;
 
-  if (tvb_captured_length(tvb) < (4+sizeof(acn_packet_id)))
+  if (tvb_captured_length(tvb) < (4+sizeof(acn_packet_id) + 6))
     return FALSE;
 
   /* Check the bytes in octets 4 - 16 */
   if (tvb_memeql(tvb, 4, acn_packet_id, sizeof(acn_packet_id)-1) != 0)
     return FALSE;
 
+  offset = 16;
+  pdu_flags = tvb_get_guint8(tvb, offset) & 0xf0;
+  if (pdu_flags & ACN_PDU_FLAG_L) {
+    /* length bit is set: there are three length bytes */
+    offset += 3;
+  }
+  else {
+    /* length bit is clear: there are two length bytes */
+    offset += 2;
+  }
+
+  *protocol_id = tvb_get_ntohl(tvb, offset);
   return TRUE;
 }
 
+/******************************************************************************/
+/* Test to see if it is an RDMnet Packet over TCP                             */
+static gboolean
+is_rdmnet_over_tcp(tvbuff_t *tvb)
+{
+  static const char acn_packet_id[] = "ASC-E1.17\0\0\0";  /* must be 12 bytes */
+  guint32  offset;
+  guint32  protocol_id;
+  guint8   pdu_flags;
+
+  if (tvb_captured_length(tvb) < (4+sizeof(acn_packet_id))) {
+    return FALSE;
+  }
+
+  /* Check the bytes in octets 0 - 12 */
+  if (tvb_memeql(tvb, 0, acn_packet_id, sizeof(acn_packet_id)-1) != 0) {
+    return FALSE;
+  }
+
+  offset = 16;
+  pdu_flags = tvb_get_guint8(tvb, offset) & 0xf0;
+  if (pdu_flags & ACN_PDU_FLAG_L) {
+    /* length bit is set: there are three length bytes */
+    offset += 3;
+  } else {
+    /* length bit is clear: there are two length bytes */
+    offset += 2;
+  }
+
+  protocol_id = tvb_get_ntohl(tvb, offset);
+  if ((protocol_id == ACN_PROTOCOL_ID_BROKER) ||
+      (protocol_id == ACN_PROTOCOL_ID_RPT) ||
+      (protocol_id == ACN_PROTOCOL_ID_EPT)) {
+    return TRUE;
+  }
+
+  return FALSE;
+}
+
+/******************************************************************************/
+/* Test to see if it is an ACN Packet                                         */
+static gboolean
+is_acn(tvbuff_t *tvb)
+{
+  guint32  protocol_id;
+
+  if (is_acn_or_rdmnet_over_udp(tvb, &protocol_id)) {
+    if ((protocol_id == ACN_PROTOCOL_ID_DMX) ||
+        (protocol_id == ACN_PROTOCOL_ID_DMX_2) ||
+        (protocol_id == ACN_PROTOCOL_ID_SDT))
+      return TRUE;
+  }
+
+  return FALSE;
+}
+
+/******************************************************************************/
+/* Test to see if it is an ACN Packet                                         */
+static gboolean
+is_rdmnet_over_udp(tvbuff_t *tvb)
+{
+  guint32  protocol_id;
+
+  if (is_acn_or_rdmnet_over_udp(tvb, &protocol_id) && (protocol_id == ACN_PROTOCOL_ID_LLRP)) {
+      return TRUE;
+  }
+
+  return FALSE;
+}
+
 
 /******************************************************************************/
 /* Heuristic dissector                                                        */
 static gboolean
-dissect_acn_heur( tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_ )
+dissect_acn_heur(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_)
 {
   /* This is a heuristic dissector, which means we get all the UDP
    * traffic not sent to a known dissector and not claimed by
@@ -2529,6 +3286,59 @@ dissect_acn_heur( tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *dat
   return FALSE;
 }
 
+
+/******************************************************************************/
+/* Heuristic dissector                                                        */
+static gboolean
+dissect_rdmnet_over_udp_heur(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_)
+{
+  if (!is_rdmnet_over_udp(tvb)) {
+    return FALSE;
+  }
+
+  dissect_rdmnet(tvb, pinfo, tree, 0, 1);
+  return TRUE;
+}
+
+#define RDMNET_TCP_FRAME_HEADER_LENGTH  16
+
+static int
+dissect_one_rdmnet_over_tcp_message(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_)
+{
+  if (!is_rdmnet_over_tcp(tvb)) {
+    return 0;
+  }
+
+  dissect_rdmnet(tvb, pinfo, tree, 0, 0);
+  return tvb_captured_length(tvb);
+}
+
+
+static guint
+get_rdmnet_tcp_message_length(packet_info *pinfo _U_, tvbuff_t *tvb, int offset, void *data _U_)
+{
+  return (guint)tvb_get_ntohl(tvb, offset + 12) + 16;
+}
+
+static int
+dissect_rdmnet_over_tcp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_)
+{
+  tcp_dissect_pdus(tvb, pinfo, tree, TRUE, RDMNET_TCP_FRAME_HEADER_LENGTH,
+                   get_rdmnet_tcp_message_length, dissect_one_rdmnet_over_tcp_message, data);
+  return tvb_captured_length(tvb);
+}
+
+
+/******************************************************************************/
+/* Heuristic dissector                                                        */
+static gboolean
+dissect_rdmnet_over_tcp_heur(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_)
+{
+  dissect_rdmnet_over_tcp(tvb, pinfo, tree, data);
+  return TRUE;
+}
+
+
 /******************************************************************************/
 /*  Adds tree branch for channel owner info block                             */
 static guint32
@@ -3421,6 +4231,15 @@ get_field_name(guint8 blob_type, guint16 field_number)
     case ACN_BLOB_TIME3:
       field_name = val_to_str(field_number, acn_blob_time3_field_name, "not valid (%d)");
       break;
+    case ACN_BLOB_ENERGY_COST:
+      field_name = val_to_str(field_number, acn_blob_energy_cost_field_name, "not valid (%d)");
+      break;
+    case ACN_BLOB_SEQUENCE_OPERATIONS:
+      field_name = val_to_str(field_number, acn_blob_sequence_operation_field_name, "not valid (%d)");
+      break;
+    case ACN_BLOB_SEQUENCE_STEP_PROPERTIES:
+      field_name = val_to_str_ext(field_number, &acn_blob_sequence_step_properties_field_name_ext, "not valid (%d)");
+      break;
     default:
       field_name = "Unknown field";
       break;
@@ -3922,6 +4741,133 @@ dissect_acn_blob(tvbuff_t *tvb, packet_info *pinfo _U_, proto_tree *pdu_tree, in
 }
 
 /******************************************************************************/
+/* Dissect PDU L bit flag                                                     */
+static void
+dissect_pdu_bit_flag_l(tvbuff_t *tvb, int *offset, guint8 *pdu_flags, guint32 *pdu_length, guint32 *pdu_flvh_length)
+{
+  guint8  octet;
+  guint32 length1;
+  guint32 length2;
+  guint32 length3;
+
+  /* get PDU flags and length flag */
+  octet      = tvb_get_guint8(tvb, (*offset)++);
+  *pdu_flags = octet & 0xf0;
+  length1    = octet & 0x0f;     /* bottom 4 bits only */
+  length2    = tvb_get_guint8(tvb, (*offset)++);
+
+  /* if length flag is set, then we have a 20 bit length else we have a 12 bit */
+  /* flvh = flags, length, vector, header */
+  if (*pdu_flags & ACN_PDU_FLAG_L) {
+    length3 = tvb_get_guint8(tvb, *offset);
+    *offset += 1;
+    *pdu_length = length3 | (length2 << 8) | (length1 << 16);
+    *pdu_flvh_length = 3;
+  } else {
+    *pdu_length = length2 | (length1 << 8);
+    *pdu_flvh_length = 2;
+  }
+}
+
+/******************************************************************************/
+/* Dissect PDU V bit flag                                                     */
+static void
+dissect_pdu_bit_flag_v(int *offset, guint8 pdu_flags, guint32 *vector_offset, acn_pdu_offsets *last_pdu_offsets, guint32 *pdu_flvh_length, guint8 increment)
+{
+  /* Set vector offset */
+  if (pdu_flags & ACN_PDU_FLAG_V) {
+    /* use new values */
+    *vector_offset            = *offset;
+    last_pdu_offsets->vector  = *offset;
+    *offset                   += increment;
+    *pdu_flvh_length          += increment;
+  } else {
+    /* use last values */
+    *vector_offset            = last_pdu_offsets->vector;
+  }
+}
+
+/******************************************************************************/
+/* Dissect PDU H bit flag                                                     */
+static void
+dissect_pdu_bit_flag_h(int *offset, guint8 pdu_flags, guint32 *header_offset, acn_pdu_offsets *last_pdu_offsets, guint32 *pdu_flvh_length, guint8 increment)
+{
+  /* Set header offset */
+  if (pdu_flags & ACN_PDU_FLAG_H) {
+    /* use new values */
+    *header_offset            = *offset;
+    last_pdu_offsets->header  = *offset;
+    *offset                   += increment;
+    *pdu_flvh_length          += increment;
+  } else {
+    /* use last values */
+    *header_offset            = last_pdu_offsets->header;
+  }
+}
+
+/******************************************************************************/
+/* Dissect PDU D bit flag                                                     */
+static void
+dissect_pdu_bit_flag_d(int offset, guint8 pdu_flags, guint32 pdu_length, guint32 *data_offset, guint32 *data_length, acn_pdu_offsets *last_pdu_offsets, guint32 pdu_flvh_length, gboolean set_last_value_length)
+{
+  /* Adjust data */
+  if (pdu_flags & ACN_PDU_FLAG_D) {
+    /* use new values */
+    *data_offset                  = offset;
+    *data_length                  = pdu_length - pdu_flvh_length;
+    last_pdu_offsets->data        = offset;
+    last_pdu_offsets->data_length = *data_length;
+  } else {
+    /* use last values */
+    *data_offset                  = last_pdu_offsets->data;
+    if (set_last_value_length) {
+      *data_length                = last_pdu_offsets->data_length;
+    }
+  }
+}
+
+/******************************************************************************/
+/* Add flag and flag tree                                                     */
+static void
+begin_dissect_acn_pdu(proto_tree **pdu_tree, tvbuff_t *tvb, proto_item **ti, proto_tree *tree, guint32 *pdu_start, int *offset, guint8 *pdu_flags, guint32 *pdu_length, guint32 *pdu_flvh_length, gint ett_base_pdu, gboolean is_acn)
+{
+  proto_item  *pi;
+  proto_tree  *flag_tree;
+
+  /* save start of pdu block */
+  *pdu_start        = *offset;
+
+  dissect_pdu_bit_flag_l(tvb, offset, pdu_flags, pdu_length, pdu_flvh_length);
+  /* offset should now be pointing to vector (if one exists) */
+
+  /* add pdu item and tree */
+  if (is_acn) {
+    *ti = proto_tree_add_item(tree, hf_acn_pdu, tvb, *pdu_start, *pdu_length, ENC_NA);
+  } else {
+    *ti = proto_tree_add_item(tree, hf_rdmnet_pdu, tvb, *pdu_start, *pdu_length, ENC_NA);
+  }
+  *pdu_tree = proto_item_add_subtree(*ti, ett_base_pdu);
+
+  /* add flag item and tree */
+  if (is_acn) {
+    pi        = proto_tree_add_uint(*pdu_tree, hf_acn_pdu_flags, tvb, *pdu_start, 1, *pdu_flags);
+    flag_tree = proto_item_add_subtree(pi, ett_acn_pdu_flags);
+    proto_tree_add_item(flag_tree, hf_acn_pdu_flag_l, tvb, *pdu_start, 1, ENC_BIG_ENDIAN);
+    proto_tree_add_item(flag_tree, hf_acn_pdu_flag_v, tvb, *pdu_start, 1, ENC_BIG_ENDIAN);
+    proto_tree_add_item(flag_tree, hf_acn_pdu_flag_h, tvb, *pdu_start, 1, ENC_BIG_ENDIAN);
+    proto_tree_add_item(flag_tree, hf_acn_pdu_flag_d, tvb, *pdu_start, 1, ENC_BIG_ENDIAN);
+  }
+  else {
+    pi        = proto_tree_add_uint(*pdu_tree, hf_rdmnet_pdu_flags, tvb, *pdu_start, 1, *pdu_flags);
+    flag_tree = proto_item_add_subtree(pi, ett_rdmnet_pdu_flags);
+    proto_tree_add_item(flag_tree, hf_rdmnet_pdu_flag_l, tvb, *pdu_start, 1, ENC_BIG_ENDIAN);
+    proto_tree_add_item(flag_tree, hf_rdmnet_pdu_flag_v, tvb, *pdu_start, 1, ENC_BIG_ENDIAN);
+    proto_tree_add_item(flag_tree, hf_rdmnet_pdu_flag_h, tvb, *pdu_start, 1, ENC_BIG_ENDIAN);
+    proto_tree_add_item(flag_tree, hf_rdmnet_pdu_flag_d, tvb, *pdu_start, 1, ENC_BIG_ENDIAN);
+  }
+}
+
+/******************************************************************************/
 /* Dissect wrapped SDT PDU                                                    */
 static guint32
 dissect_acn_dmp_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset, acn_pdu_offsets *last_pdu_offsets)
@@ -3933,10 +4879,6 @@ dissect_acn_dmp_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int off
   guint32           pdu_length;
   guint32           pdu_flvh_length; /* flags, length, vector, header */
   guint8            D;
-  guint8            octet;
-  guint32           length1;
-  guint32           length2;
-  guint32           length3;
   guint32           vector_offset;
   guint32           header_offset;
   guint32           data_offset;
@@ -3947,9 +4889,8 @@ dissect_acn_dmp_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int off
   guint32           blob_offset;
   guint32           blob_end_offset = 0;
 
-  proto_item       *ti, *pi;
+  proto_item       *ti;
   proto_tree       *pdu_tree  = NULL;
-  proto_tree       *flag_tree = NULL;
 
   /* this pdu */
   const gchar      *name;
@@ -3957,54 +4898,12 @@ dissect_acn_dmp_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int off
   acn_dmp_adt_type  adt2      = {0,0,0,0,0,0};
   guint32           vector;
 
-  /* save start of pdu block */
-  pdu_start = offset;
-
-  /* get PDU flags and length flag first */
-  octet     = tvb_get_guint8(tvb, offset++);
-  pdu_flags = octet & 0xf0;
-  length1   = octet & 0x0f;     /* bottom 4 bits only */
-  length2   = tvb_get_guint8(tvb, offset++);
-
-  /* if length flag is set, then we have a 20 bit length else we have a 12 bit */
-  /* flvh = flags, length, vector, header */
-  if (pdu_flags & ACN_PDU_FLAG_L) {
-    length3 = tvb_get_guint8(tvb, offset);
-    offset += 1;
-    pdu_length = length3 | (length2 << 8) | (length1 << 16);
-    pdu_flvh_length = 3;
-  } else {
-    pdu_length = length2 | (length1 << 8);
-    pdu_flvh_length = 2;
-  }
-  /* offset should now be pointing to vector (if one exists) */
-
-  /* Add pdu item and tree */
-  ti       = proto_tree_add_item(tree, hf_acn_pdu, tvb, pdu_start, pdu_length, ENC_NA);
-  pdu_tree = proto_item_add_subtree(ti, ett_acn_dmp_pdu);
-
-  /* Add flag item and tree */
-  pi        = proto_tree_add_uint(pdu_tree, hf_acn_pdu_flags, tvb, pdu_start, 1, pdu_flags);
-  flag_tree = proto_item_add_subtree(pi, ett_acn_pdu_flags);
-  proto_tree_add_item(flag_tree, hf_acn_pdu_flag_l, tvb, pdu_start, 1, ENC_BIG_ENDIAN);
-  proto_tree_add_item(flag_tree, hf_acn_pdu_flag_v, tvb, pdu_start, 1, ENC_BIG_ENDIAN);
-  proto_tree_add_item(flag_tree, hf_acn_pdu_flag_h, tvb, pdu_start, 1, ENC_BIG_ENDIAN);
-  proto_tree_add_item(flag_tree, hf_acn_pdu_flag_d, tvb, pdu_start, 1, ENC_BIG_ENDIAN);
+  begin_dissect_acn_pdu(&pdu_tree, tvb, &ti, tree, &pdu_start, &offset, &pdu_flags, &pdu_length, &pdu_flvh_length, ett_acn_dmp_pdu, 1);
 
   /* Add PDU Length item */
   proto_tree_add_uint(pdu_tree, hf_acn_pdu_length, tvb, pdu_start, pdu_flvh_length, pdu_length);
 
-  /* Set vector offset */
-  if (pdu_flags & ACN_PDU_FLAG_V) {
-    /* use new values */
-    vector_offset             = offset;
-    last_pdu_offsets->vector  = offset;
-    offset                   += 1;
-    pdu_flvh_length++;
-  } else {
-    /* use last values */
-    vector_offset             = last_pdu_offsets->vector;
-  }
+  dissect_pdu_bit_flag_v(&offset, pdu_flags, &vector_offset, last_pdu_offsets, &pdu_flvh_length, 1);
   /* offset should now be pointing to header (if one exists) */
 
   /* Add Vector item */
@@ -4016,34 +4915,13 @@ dissect_acn_dmp_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int off
   proto_item_append_text(ti, ": ");
   proto_item_append_text(ti, "%s", name);
 
-  /* Set header offset */
-  if (pdu_flags & ACN_PDU_FLAG_H) {
-    /* use new values */
-    header_offset             = offset;
-    last_pdu_offsets->header  = offset;
-    offset                   += 1;
-    pdu_flvh_length++;
-  } else {
-    /* use last values */
-    header_offset             = last_pdu_offsets->header;
-  }
+  dissect_pdu_bit_flag_h(&offset, pdu_flags, &header_offset, last_pdu_offsets, &pdu_flvh_length, 1);
   /* offset should now be pointing to data (if one exists) */
 
   /* header contains address and data type */
   acn_add_dmp_address_type(tvb, pinfo, pdu_tree, header_offset, &adt);
 
-  /* Adjust data */
-  if (pdu_flags & ACN_PDU_FLAG_D) {
-    /* use new values */
-    data_offset                   = offset;
-    data_length                   = pdu_length - pdu_flvh_length;
-    last_pdu_offsets->data        = offset;
-    last_pdu_offsets->data_length = data_length;
-  } else {
-    /* use last values */
-    data_offset                   = last_pdu_offsets->data;
-    data_length                   = last_pdu_offsets->data_length;
-  }
+  dissect_pdu_bit_flag_d(offset, pdu_flags, pdu_length, &data_offset, &data_length, last_pdu_offsets, pdu_flvh_length, 1);
   end_offset = data_offset + data_length;
 
   /* Check if blob exists, find beginning offset */
@@ -4267,74 +5145,27 @@ static guint32
 dissect_acn_sdt_wrapped_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset, acn_pdu_offsets *last_pdu_offsets)
 {
   /* common to all pdu */
-  guint8       pdu_flags;
-  guint32      pdu_start;
-  guint32      pdu_length;
-  guint32      pdu_flvh_length; /* flags, length, vector, header */
-  guint8       octet;
-  guint32      length1;
-  guint32      length2;
-  guint32      length3;
-  guint32      vector_offset;
-  guint32      data_offset;
-  guint32      data_length;
-
-  proto_item  *ti, *pi;
+  guint8           pdu_flags;
+  guint32          pdu_start;
+  guint32          pdu_length;
+  guint32          pdu_flvh_length; /* flags, length, vector, header */
+  guint32          vector_offset;
+  guint32          data_offset;
+  guint32          data_length;
+
+  proto_item  *ti;
   proto_tree  *pdu_tree  = NULL;
-  proto_tree  *flag_tree = NULL;
 
   /* this pdu */
   const gchar *name;
   guint32      vector;
 
-  /* save start of pdu block */
-  pdu_start = offset;
-
-  /* get PDU flags and length flag first */
-  octet     = tvb_get_guint8(tvb, offset++);
-  pdu_flags = octet & 0xf0;
-  length1   = octet & 0x0f;     /* bottom 4 bits only */
-  length2   = tvb_get_guint8(tvb, offset++);
-
-  /* if length flag is set, then we have a 20 bit length else we have a 12 bit */
-  /* flvh = flags, length, vector, header */
-  if (pdu_flags & ACN_PDU_FLAG_L) {
-    length3 = tvb_get_guint8(tvb, offset);
-    offset += 1;
-    pdu_length = length3 | (length2 << 8) | (length1 << 16);
-    pdu_flvh_length = 3;
-  } else {
-    pdu_length = length2 | (length1 << 8);
-    pdu_flvh_length = 2;
-  }
-  /* offset should now be pointing to vector (if one exists) */
-
-  /* Add pdu item and tree */
-  ti = proto_tree_add_item(tree, hf_acn_pdu, tvb, pdu_start, pdu_length, ENC_NA);
-  pdu_tree = proto_item_add_subtree(ti, ett_acn_sdt_pdu);
-
-  /* Add flag item and tree */
-  pi = proto_tree_add_uint(pdu_tree, hf_acn_pdu_flags, tvb, pdu_start, 1, pdu_flags);
-  flag_tree = proto_item_add_subtree(pi, ett_acn_pdu_flags);
-  proto_tree_add_item(flag_tree, hf_acn_pdu_flag_l, tvb, pdu_start, 1, ENC_BIG_ENDIAN);
-  proto_tree_add_item(flag_tree, hf_acn_pdu_flag_v, tvb, pdu_start, 1, ENC_BIG_ENDIAN);
-  proto_tree_add_item(flag_tree, hf_acn_pdu_flag_h, tvb, pdu_start, 1, ENC_BIG_ENDIAN);
-  proto_tree_add_item(flag_tree, hf_acn_pdu_flag_d, tvb, pdu_start, 1, ENC_BIG_ENDIAN);
+  begin_dissect_acn_pdu(&pdu_tree, tvb, &ti, tree, &pdu_start, &offset, &pdu_flags, &pdu_length, &pdu_flvh_length, ett_acn_sdt_pdu, 1);
 
   /* Add PDU Length item */
   proto_tree_add_uint(pdu_tree, hf_acn_pdu_length, tvb, pdu_start, pdu_flvh_length, pdu_length);
 
-  /* Set vector offset */
-  if (pdu_flags & ACN_PDU_FLAG_V) {
-    /* use new values */
-    vector_offset = offset;
-    last_pdu_offsets->vector = offset;
-    offset += 1;
-    pdu_flvh_length++;
-  } else {
-    /* use last values */
-    vector_offset = last_pdu_offsets->vector;
-  }
+  dissect_pdu_bit_flag_v(&offset, pdu_flags, &vector_offset, last_pdu_offsets, &pdu_flvh_length, 1);
   /* offset should now be pointing to header (if one exists) */
 
   /* Add Vector item */
@@ -4348,18 +5179,7 @@ dissect_acn_sdt_wrapped_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
 
   /* NO HEADER DATA ON THESE* (at least so far) */
 
-  /* Adjust data */
-  if (pdu_flags & ACN_PDU_FLAG_D) {
-    /* use new values */
-    data_offset = offset;
-    data_length = pdu_length - pdu_flvh_length;
-    last_pdu_offsets->data = offset;
-    last_pdu_offsets->data_length = data_length;
-  } else {
-    /* use last values */
-    data_offset = last_pdu_offsets->data;
-    /*data_length = last_pdu_offsets->data_length;*/
-  }
+  dissect_pdu_bit_flag_d(offset, pdu_flags, pdu_length, &data_offset, &data_length, last_pdu_offsets, pdu_flvh_length, 0);
 
   switch (vector) {
     case ACN_SDT_VECTOR_ACK:
@@ -4421,10 +5241,6 @@ dissect_acn_sdt_client_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
   guint32          pdu_length;
   guint32          pdu_flvh_length; /* flags, length, vector, header */
   acn_pdu_offsets  pdu_offsets = {0,0,0,0,0};
-  guint8           octet;
-  guint32          length1;
-  guint32          length2;
-  guint32          length3;
   guint32          vector_offset;
   guint32          header_offset;
   guint32          data_offset;
@@ -4432,9 +5248,8 @@ dissect_acn_sdt_client_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
   guint32          old_offset;
   guint32          end_offset;
 
-  proto_item      *ti, *pi;
+  proto_item      *ti;
   proto_tree      *pdu_tree    = NULL;
-  proto_tree      *flag_tree   = NULL;
 
   /* this pdu */
   const gchar     *name;
@@ -4442,72 +5257,19 @@ dissect_acn_sdt_client_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
   guint32          protocol_id;
   guint16          association;
 
-  /* save start of pdu block */
-  pdu_start         = offset;
-  pdu_offsets.start = pdu_start;
-
-  /* get PDU flags and length flag first */
-  octet     = tvb_get_guint8(tvb, offset++);
-  pdu_flags = octet & 0xf0;
-  length1   = octet & 0x0f;     /* bottom 4 bits only */
-  length2   = tvb_get_guint8(tvb, offset++);
-
-  /* if length flag is set, then we have a 20 bit length else we have a 12 bit */
-  /* flvh = flags, length, vector, header */
-  if (pdu_flags & ACN_PDU_FLAG_L) {
-    length3 = tvb_get_guint8(tvb, offset);
-    offset += 1;
-    pdu_length = length3 | (length2 << 8) | (length1 << 16);
-    pdu_flvh_length = 3;
-  } else {
-    pdu_length = length2 | (length1 << 8);
-    pdu_flvh_length = 2;
-  }
-  /* offset should now be pointing to vector (if one exists) */
-
-  /* Add pdu item and tree */
-  ti       = proto_tree_add_item(tree, hf_acn_pdu, tvb, pdu_start, pdu_length, ENC_NA);
-  pdu_tree = proto_item_add_subtree(ti, ett_acn_sdt_client_pdu);
-
-  /* Add flag item and tree */
-  pi = proto_tree_add_uint(pdu_tree, hf_acn_pdu_flags, tvb, pdu_start, 1, pdu_flags);
-  flag_tree = proto_item_add_subtree(pi, ett_acn_pdu_flags);
-  proto_tree_add_item(flag_tree, hf_acn_pdu_flag_l, tvb, pdu_start, 1, ENC_BIG_ENDIAN);
-  proto_tree_add_item(flag_tree, hf_acn_pdu_flag_v, tvb, pdu_start, 1, ENC_BIG_ENDIAN);
-  proto_tree_add_item(flag_tree, hf_acn_pdu_flag_h, tvb, pdu_start, 1, ENC_BIG_ENDIAN);
-  proto_tree_add_item(flag_tree, hf_acn_pdu_flag_d, tvb, pdu_start, 1, ENC_BIG_ENDIAN);
+  begin_dissect_acn_pdu(&pdu_tree, tvb, &ti, tree, &pdu_start, &offset, &pdu_flags, &pdu_length, &pdu_flvh_length, ett_acn_sdt_client_pdu, 1);
 
   /* Add PDU Length item */
   proto_tree_add_uint(pdu_tree, hf_acn_pdu_length, tvb, pdu_start, pdu_flvh_length, pdu_length);
 
-  /* Set vector offset */
-  if (pdu_flags & ACN_PDU_FLAG_V) {
-    /* use new values */
-    vector_offset = offset;
-    last_pdu_offsets->vector = offset;
-    offset += 2;
-    pdu_flvh_length += 2;
-  } else {
-    /* use last values */
-    vector_offset = last_pdu_offsets->vector;
-  }
+  dissect_pdu_bit_flag_v(&offset, pdu_flags, &vector_offset, last_pdu_offsets, &pdu_flvh_length, 2);
   /* offset should now be pointing to header (if one exists) */
 
   /* add Member ID item  */
   member_id = tvb_get_ntohs(tvb, vector_offset);
   proto_tree_add_uint(pdu_tree, hf_acn_member_id, tvb, vector_offset, 2, member_id);
 
-  /* Set header offset */
-  if (pdu_flags & ACN_PDU_FLAG_H) {
-    /* use new values */
-    header_offset             = offset;
-    last_pdu_offsets->header  = offset;
-    offset                   += 6;
-    pdu_flvh_length          += 6;
-  } else {
-    /* use last values */
-    header_offset             = last_pdu_offsets->header;
-  }
+  dissect_pdu_bit_flag_h(&offset, pdu_flags, &header_offset, last_pdu_offsets, &pdu_flvh_length, 6);
   /* offset should now be pointing to data (if one exists) */
 
   /* add Protocol ID item (Header)*/
@@ -4525,18 +5287,7 @@ dissect_acn_sdt_client_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
   proto_tree_add_uint(pdu_tree, hf_acn_association, tvb, header_offset, 2, association);
   /*header_offset += 2;*/
 
-  /* Adjust data */
-  if (pdu_flags & ACN_PDU_FLAG_D) {
-    /* use new values */
-    data_offset = offset;
-    data_length = pdu_length - pdu_flvh_length;
-    last_pdu_offsets->data = offset;
-    last_pdu_offsets->data_length = data_length;
-  } else {
-    /* use last values */
-    data_offset = last_pdu_offsets->data;
-    data_length = last_pdu_offsets->data_length;
-  }
+  dissect_pdu_bit_flag_d(offset, pdu_flags, pdu_length, &data_offset, &data_length, last_pdu_offsets, pdu_flvh_length, 1);
   end_offset = data_offset + data_length;
 
   switch (protocol_id) {
@@ -4563,7 +5314,7 @@ dissect_acn_sdt_client_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
 /* level to string (ascii)                                                    */
 /*  level    : 8 bit value                                                    */
 /*  string   : pointer to buffer to fill                                      */
-/*  leading_char: character to buffer left of digits                             */
+/*  leading_char: character to buffer left of digits                          */
 /*  min_char : minimum number of characters (for filling, not including space)*/
 /*  show_zero: show zeros or dots                                             */
 /* also adds a space to right end                                             */
@@ -4623,10 +5374,6 @@ dissect_acn_dmx_data_pdu(guint32 protocol_id, tvbuff_t *tvb, packet_info *pinfo,
   guint32           pdu_start;
   guint32           pdu_length;
   guint32           pdu_flvh_length; /* flags, length, vector, header */
-  guint8            octet;
-  guint32           length1;
-  guint32           length2;
-  guint32           length3;
   guint32           vector_offset;
   guint32           data_offset;
   guint32           end_offset;
@@ -4635,9 +5382,8 @@ dissect_acn_dmx_data_pdu(guint32 protocol_id, tvbuff_t *tvb, packet_info *pinfo,
   guint32           total_cnt;
   guint32           item_cnt;
 
-  proto_item       *ti, *pi;
+  proto_item       *ti;
   proto_tree       *pdu_tree;
-  proto_tree       *flag_tree;
 
 /* this pdu */
   acn_dmp_adt_type  adt       = {0,0,0,0,0,0};
@@ -4660,54 +5406,12 @@ dissect_acn_dmx_data_pdu(guint32 protocol_id, tvbuff_t *tvb, packet_info *pinfo,
   buffer = (gchar*)wmem_alloc(wmem_packet_scope(), BUFFER_SIZE);
   buffer[0] = '\0';
 
-  /* save start of pdu block */
-  pdu_start = offset;
-
-  /* get PDU flags and length flag first */
-  octet     = tvb_get_guint8(tvb, offset++);
-  pdu_flags = octet & 0xf0;
-  length1   = octet & 0x0f;     /* bottom 4 bits only */
-  length2   = tvb_get_guint8(tvb, offset++);
-
-  /* if length flag is set, then we have a 20 bit length else we have a 12 bit */
-  /* flvh = flags, length, vector, header */
-  if (pdu_flags & ACN_PDU_FLAG_L) {
-    length3 = tvb_get_guint8(tvb, offset);
-    offset += 1;
-    pdu_length = length3 | (length2 << 8) | (length1 << 16);
-    pdu_flvh_length = 3;
-  } else {
-    pdu_length = length2 | (length1 << 8);
-    pdu_flvh_length = 2;
-  }
-  /* offset should now be pointing to vector (if one exists) */
-
-  /* Add pdu item and tree */
-  ti       = proto_tree_add_item(tree, hf_acn_pdu, tvb, pdu_start, pdu_length, ENC_NA);
-  pdu_tree = proto_item_add_subtree(ti, ett_acn_dmx_data_pdu);
-
-  /* Add flag item and tree */
-  pi = proto_tree_add_uint(pdu_tree, hf_acn_pdu_flags, tvb, pdu_start, 1, pdu_flags);
-  flag_tree = proto_item_add_subtree(pi, ett_acn_pdu_flags);
-  proto_tree_add_item(flag_tree, hf_acn_pdu_flag_l, tvb, pdu_start, 1, ENC_BIG_ENDIAN);
-  proto_tree_add_item(flag_tree, hf_acn_pdu_flag_v, tvb, pdu_start, 1, ENC_BIG_ENDIAN);
-  proto_tree_add_item(flag_tree, hf_acn_pdu_flag_h, tvb, pdu_start, 1, ENC_BIG_ENDIAN);
-  proto_tree_add_item(flag_tree, hf_acn_pdu_flag_d, tvb, pdu_start, 1, ENC_BIG_ENDIAN);
+  begin_dissect_acn_pdu(&pdu_tree, tvb, &ti, tree, &pdu_start, &offset, &pdu_flags, &pdu_length, &pdu_flvh_length, ett_acn_dmx_data_pdu, 1);
 
   /* Add PDU Length item */
   proto_tree_add_uint(pdu_tree, hf_acn_pdu_length, tvb, pdu_start, pdu_flvh_length, pdu_length);
 
-  /* Set vector offset */
-  if (pdu_flags & ACN_PDU_FLAG_V) {
-    /* use new values */
-    vector_offset = offset;
-    last_pdu_offsets->vector = offset;
-    offset += 1;
-    pdu_flvh_length += 1;
-  } else {
-    /* use last values */
-    vector_offset = last_pdu_offsets->vector;
-  }
+  dissect_pdu_bit_flag_v(&offset, pdu_flags, &vector_offset, last_pdu_offsets, &pdu_flvh_length, 1);
   /* offset should now be pointing to header (if one exists) */
 
   /* Add Vector item */
@@ -4719,42 +5423,21 @@ dissect_acn_dmx_data_pdu(guint32 protocol_id, tvbuff_t *tvb, packet_info *pinfo,
   proto_item_append_text(ti, ": ");
   proto_item_append_text(ti, "%s", name);
 
-  /* Set header offset */
-  if (pdu_flags & ACN_PDU_FLAG_H) {
-    /* use new values */
-    header_offset = offset;
-    last_pdu_offsets->header = offset;
-    offset += 1;
-    pdu_flvh_length++;
-  } else {
-    /* use last values */
-    header_offset = last_pdu_offsets->header;
-  }
+  dissect_pdu_bit_flag_h(&offset, pdu_flags, &header_offset, last_pdu_offsets, &pdu_flvh_length, 1);
   /* offset should now be pointing to data (if one exists) */
 
   /* process based on vector */
   acn_add_dmp_address_type(tvb, pinfo, pdu_tree, header_offset, &adt);
 
-  /* Adjust data */
-  if (pdu_flags & ACN_PDU_FLAG_D) {
-    /* use new values */
-    data_offset = offset;
-    data_length = pdu_length - pdu_flvh_length;
-    last_pdu_offsets->data = offset;
-    last_pdu_offsets->data_length = data_length;
-  } else {
-    /* use last values */
-    data_offset = last_pdu_offsets->data;
-    data_length = last_pdu_offsets->data_length;
-  }
+  dissect_pdu_bit_flag_d(offset, pdu_flags, pdu_length, &data_offset, &data_length, last_pdu_offsets, pdu_flvh_length, 1);
   end_offset = data_offset + data_length;
 
   switch (vector) {
     case ACN_DMP_VECTOR_SET_PROPERTY:
       dmx_start_code = tvb_get_ntohs(tvb, data_offset);
-      if (protocol_id==ACN_PROTOCOL_ID_DMX_2) {
+      if (protocol_id == ACN_PROTOCOL_ID_DMX_2) {
         proto_tree_add_item(pdu_tree, hf_acn_dmx_2_first_property_address, tvb, data_offset, 2, ENC_BIG_ENDIAN);
-      } else{
+      } else {
         proto_tree_add_item(pdu_tree, hf_acn_dmx_start_code, tvb, data_offset, 2, ENC_BIG_ENDIAN);
       }
       data_offset += 2;
@@ -4764,7 +5447,7 @@ dissect_acn_dmx_data_pdu(guint32 protocol_id, tvbuff_t *tvb, packet_info *pinfo,
       proto_tree_add_item(pdu_tree, hf_acn_dmx_count, tvb, data_offset, 2, ENC_BIG_ENDIAN);
       data_offset += 2;
 
-    if (protocol_id == ACN_PROTOCOL_ID_DMX_2) {
+      if (protocol_id == ACN_PROTOCOL_ID_DMX_2) {
         dmx_2_start_code = (guint8)tvb_get_ntohs(tvb, data_offset - 1);
         proto_tree_add_item(pdu_tree, hf_acn_dmx_2_start_code, tvb, data_offset, 1, ENC_BIG_ENDIAN);
         data_offset += 1;
@@ -4789,7 +5472,7 @@ dissect_acn_dmx_data_pdu(guint32 protocol_id, tvbuff_t *tvb, packet_info *pinfo,
           min_char = 2;
           base     = 16;
           break;
-/*        case ACN_PREF_DMX_DISPLAY_PER: */
+/*      case ACN_PREF_DMX_DISPLAY_PER: */
         default:
           min_char = 3;
           base     = 10;
@@ -4802,12 +5485,12 @@ dissect_acn_dmx_data_pdu(guint32 protocol_id, tvbuff_t *tvb, packet_info *pinfo,
         leading_char = ' ';
       }
       /* add a snippet to info (this may be slow) */
-    if (protocol_id == ACN_PROTOCOL_ID_DMX_2) {
-      info_start_code = dmx_2_start_code;
-    }
-    else {
-      info_start_code = dmx_start_code;
-    }
+      if (protocol_id == ACN_PROTOCOL_ID_DMX_2) {
+        info_start_code = dmx_2_start_code;
+      }
+      else {
+        info_start_code = dmx_start_code;
+      }
       col_append_fstr(pinfo->cinfo,COL_INFO, ", Sc %02x, [%02x %02x %02x %02x %02x %02x...]",
         info_start_code,
         tvb_get_guint8(tvb, data_offset),
@@ -4818,6 +5501,9 @@ dissect_acn_dmx_data_pdu(guint32 protocol_id, tvbuff_t *tvb, packet_info *pinfo,
         tvb_get_guint8(tvb, data_offset+5));
 
       /* add a header line */
+      *buf_ptr++ =  ' ';
+      *buf_ptr++ =  ' ';
+      *buf_ptr++ =  ' ';
       for (x=0; x<perline; x++) {
         buf_ptr = ltos((guint8)(x+1), buf_ptr, 10, ' ', min_char, FALSE);
         if ((x+1)==halfline) {
@@ -4836,7 +5522,7 @@ dissect_acn_dmx_data_pdu(guint32 protocol_id, tvbuff_t *tvb, packet_info *pinfo,
       item_cnt = 0;
       for (x=data_offset; x<end_offset; x++) {
         level = tvb_get_guint8(tvb, x);
-        if (global_acn_dmx_display_view==ACN_PREF_DMX_DISPLAY_PER) {
+        if (global_acn_dmx_display_view == ACN_PREF_DMX_DISPLAY_PER) {
           if ((level > 0) && (level < 3)) {
             level = 1;
           } else {
@@ -4863,25 +5549,43 @@ dissect_acn_dmx_data_pdu(guint32 protocol_id, tvbuff_t *tvb, packet_info *pinfo,
           }
         }
       }
-    /* NOTE:
-     address data type                   (fixed at 0xA2)
-     start code - 1 byte, reserved       (should be 0)
-                - 1 byte, start code     (0x255)
-                - 2 bytes, packet offset (should be 0000)
-     address increment - 4 bytes         (ignore)
-     number of dmx values - 4 bytes      (0-512)
-     dmx values 0-512 bytes              (data)
-     */
+      /* NOTE:
+      address data type                   (fixed at 0xA2)
+      start code - 1 byte, reserved       (should be 0)
+                 - 1 byte, start code     (0x255)
+                 - 2 bytes, packet offset (should be 0000)
+      address increment - 4 bytes         (ignore)
+      number of dmx values - 4 bytes      (0-512)
+      dmx values 0-512 bytes              (data)
+      */
 
-    break;
+      break;
   }
   return pdu_start + pdu_length;
 }
 
 /******************************************************************************/
+/* Dissect Common Base PDU                                                    */
+static void
+dissect_acn_common_base_pdu(tvbuff_t *tvb, proto_tree *tree, int *offset, acn_pdu_offsets *last_pdu_offsets, guint8 *pdu_flags, guint32 *pdu_start, guint32 *pdu_length, guint32 *pdu_flvh_length, guint32 *vector_offset, proto_item **ti, proto_tree **pdu_tree, gint ett_base_pdu, guint8 v_flag_increment, gboolean is_acn)
+{
+  begin_dissect_acn_pdu(pdu_tree, tvb, ti, tree, pdu_start, offset, pdu_flags, pdu_length, pdu_flvh_length, ett_base_pdu, is_acn);
+
+  /* Add PDU Length item */
+  if (is_acn) {
+    proto_tree_add_uint(*pdu_tree, hf_acn_pdu_length, tvb, *pdu_start, *pdu_flvh_length, *pdu_length);
+  } else {
+    proto_tree_add_uint(*pdu_tree, hf_rdmnet_pdu_length, tvb, *pdu_start, *pdu_flvh_length, *pdu_length);
+  }
+
+  dissect_pdu_bit_flag_v(offset, *pdu_flags, vector_offset, last_pdu_offsets, pdu_flvh_length, v_flag_increment);
+  /* offset should now be pointing to header (if one exists) */
+}
+
+/******************************************************************************/
 /* Dissect DMX Base PDU                                                       */
 static guint32
-dissect_acn_dmx_pdu(guint32 protocol_id, tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset, acn_pdu_offsets *last_pdu_offsets)
+dissect_acn_dmx_base_pdu(guint32 protocol_id, tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset, acn_pdu_offsets *last_pdu_offsets)
 {
   /* common to all pdu */
   guint8           pdu_flags;
@@ -4889,11 +5593,7 @@ dissect_acn_dmx_pdu(guint32 protocol_id, tvbuff_t *tvb, packet_info *pinfo, prot
   guint32          pdu_length;
   guint32          pdu_flvh_length; /* flags, length, vector, header */
   acn_pdu_offsets  pdu_offsets = {0,0,0,0,0};
-  guint8           octet;
   guint8           option_flags;
-  guint32          length1;
-  guint32          length2;
-  guint32          length3;
   guint32          vector_offset;
   guint32          data_offset;
   guint32          data_length;
@@ -4902,66 +5602,15 @@ dissect_acn_dmx_pdu(guint32 protocol_id, tvbuff_t *tvb, packet_info *pinfo, prot
   proto_tree      *pdu_tree;
   proto_tree      *flag_tree;
 
+  /* this pdu */
   const char      *name;
-
-/* this pdu */
   guint32          vector;
 
   guint32          universe;
   guint32          priority;
   guint32          sequence;
 
-  /* save start of pdu block */
-  pdu_start = offset;
-  pdu_offsets.start = pdu_start;
-
-  /* get PDU flags and length flag first */
-  octet     = tvb_get_guint8(tvb, offset++);
-  pdu_flags = octet & 0xf0;
-  length1   = octet & 0x0f;     /* bottom 4 bits only */
-  length2   = tvb_get_guint8(tvb, offset++);
-
-  /* if length flag is set, then we have a 20 bit length else we have a 12 bit */
-  /* flvh = flags, length, vector, header */
-  if (pdu_flags & ACN_PDU_FLAG_L) {
-    length3 = tvb_get_guint8(tvb, offset);
-    offset += 1;
-    pdu_length = length3 | (length2 << 8) | (length1 << 16);
-    pdu_flvh_length = 3;
-  } else {
-    pdu_length = length2 | (length1 << 8);
-    pdu_flvh_length = 2;
-  }
-
-  /* offset should now be pointing to vector (if one exists) */
-
-  /* Add pdu item and tree */
-  ti = proto_tree_add_item(tree, hf_acn_pdu, tvb, pdu_start, pdu_length, ENC_NA);
-  pdu_tree = proto_item_add_subtree(ti, ett_acn_dmx_pdu);
-
-  /* Add flag item and tree */
-  pi = proto_tree_add_uint(pdu_tree, hf_acn_pdu_flags, tvb, pdu_start, 1, pdu_flags);
-  flag_tree = proto_item_add_subtree(pi, ett_acn_pdu_flags);
-  proto_tree_add_item(flag_tree, hf_acn_pdu_flag_l, tvb, pdu_start, 1, ENC_BIG_ENDIAN);
-  proto_tree_add_item(flag_tree, hf_acn_pdu_flag_v, tvb, pdu_start, 1, ENC_BIG_ENDIAN);
-  proto_tree_add_item(flag_tree, hf_acn_pdu_flag_h, tvb, pdu_start, 1, ENC_BIG_ENDIAN);
-  proto_tree_add_item(flag_tree, hf_acn_pdu_flag_d, tvb, pdu_start, 1, ENC_BIG_ENDIAN);
-
-  /* Add PDU Length item */
-  proto_tree_add_uint(pdu_tree, hf_acn_pdu_length, tvb, pdu_start, pdu_flvh_length, pdu_length);
-
-  /* Set vector offset */
-  if (pdu_flags & ACN_PDU_FLAG_V) {
-    /* use new values */
-    vector_offset = offset;
-    last_pdu_offsets->vector = offset;
-    offset          += 4;
-    pdu_flvh_length += 4;
-  } else {
-    /* use last values */
-    vector_offset = last_pdu_offsets->vector;
-  }
-  /* offset should now be pointing to header (if one exists) */
+  dissect_acn_common_base_pdu(tvb, tree, &offset, last_pdu_offsets, &pdu_flags, &pdu_start, &pdu_length, &pdu_flvh_length, &vector_offset, &ti, &pdu_tree, ett_acn_dmx_pdu, 4, 1);
 
   /* Add Vector item */
   vector = tvb_get_ntohl(tvb, vector_offset);
@@ -4974,26 +5623,15 @@ dissect_acn_dmx_pdu(guint32 protocol_id, tvbuff_t *tvb, packet_info *pinfo, prot
 
   /* NO HEADER DATA ON THESE* (at least so far) */
 
-  /* Adjust data */
-  if (pdu_flags & ACN_PDU_FLAG_D) {
-    /* use new values */
-    data_offset = offset;
-    data_length = pdu_length - pdu_flvh_length;
-    last_pdu_offsets->data = offset;
-    last_pdu_offsets->data_length = data_length;
-  } else {
-    /* use last values */
-    data_offset = last_pdu_offsets->data;
-    /*data_length = last_pdu_offsets->data_length;*/
-  }
+  dissect_pdu_bit_flag_d(offset, pdu_flags, pdu_length, &data_offset, &data_length, last_pdu_offsets, pdu_flvh_length, 0);
 
   /* process based on vector */
   switch (vector) {
-    case 0x02:
-      if (protocol_id==ACN_PROTOCOL_ID_DMX_2) {
+    case ACN_DMP_VECTOR_SET_PROPERTY:
+      if (protocol_id == ACN_PROTOCOL_ID_DMX_2) {
         proto_tree_add_item(pdu_tree, hf_acn_dmx_source_name, tvb, data_offset, 64, ENC_UTF_8|ENC_NA);
         data_offset += 64;
-      } else{
+      } else {
         proto_tree_add_item(pdu_tree, hf_acn_dmx_source_name, tvb, data_offset, 32, ENC_UTF_8|ENC_NA);
         data_offset += 32;
       }
@@ -5002,7 +5640,7 @@ dissect_acn_dmx_pdu(guint32 protocol_id, tvbuff_t *tvb, packet_info *pinfo, prot
       proto_tree_add_item(pdu_tree, hf_acn_dmx_priority, tvb, data_offset, 1, ENC_BIG_ENDIAN);
       data_offset += 1;
 
-      if (protocol_id==ACN_PROTOCOL_ID_DMX_2) {
+      if (protocol_id == ACN_PROTOCOL_ID_DMX_2) {
         proto_tree_add_item(pdu_tree, hf_acn_dmx_2_reserved, tvb, data_offset, 2, ENC_BIG_ENDIAN);
         data_offset += 2;
       }
@@ -5046,10 +5684,6 @@ dissect_acn_sdt_base_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, in
   guint32          pdu_length;
   guint32          pdu_flvh_length; /* flags, length, vector, header */
   acn_pdu_offsets  pdu_offsets = {0,0,0,0,0};
-  guint8           octet;
-  guint32          length1;
-  guint32          length2;
-  guint32          length3;
   guint32          vector_offset;
   guint32          data_offset;
   guint32          end_offset;
@@ -5058,63 +5692,13 @@ dissect_acn_sdt_base_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, in
 
   proto_item      *ti, *pi;
   proto_tree      *pdu_tree;
-  proto_tree      *flag_tree;
 
   /* this pdu */
   const gchar     *name;
   guint32          vector;
   guint32          member_id;
 
-  /* save start of pdu block */
-  pdu_start         = offset;
-  pdu_offsets.start = pdu_start;
-
-  /* get PDU flags and length flag first */
-  octet     = tvb_get_guint8(tvb, offset++);
-  pdu_flags = octet & 0xf0;
-  length1   = octet & 0x0f;     /* bottom 4 bits only */
-  length2   = tvb_get_guint8(tvb, offset++);
-
-  /* if length flag is set, then we have a 20 bit length else we have a 12 bit */
-  /* flvh = flags, length, vector, header */
-  if (pdu_flags & ACN_PDU_FLAG_L) {
-    length3 = tvb_get_guint8(tvb, offset);
-    offset += 1;
-    pdu_length      = length3 | (length2 << 8) | (length1 << 16);
-    pdu_flvh_length = 3;
-  } else {
-    pdu_length = length2 | (length1 << 8);
-    pdu_flvh_length = 2;
-  }
-  /* offset should now be pointing to vector (if one exists) */
-
-  /* Add pdu item and tree */
-  ti = proto_tree_add_item(tree, hf_acn_pdu, tvb, pdu_start, pdu_length, ENC_NA);
-  pdu_tree = proto_item_add_subtree(ti, ett_acn_sdt_base_pdu);
-
-  /* Add flag item and tree */
-  pi = proto_tree_add_uint(pdu_tree, hf_acn_pdu_flags, tvb, pdu_start, 1, pdu_flags);
-  flag_tree = proto_item_add_subtree(pi, ett_acn_pdu_flags);
-  proto_tree_add_item(flag_tree, hf_acn_pdu_flag_l, tvb, pdu_start, 1, ENC_BIG_ENDIAN);
-  proto_tree_add_item(flag_tree, hf_acn_pdu_flag_v, tvb, pdu_start, 1, ENC_BIG_ENDIAN);
-  proto_tree_add_item(flag_tree, hf_acn_pdu_flag_h, tvb, pdu_start, 1, ENC_BIG_ENDIAN);
-  proto_tree_add_item(flag_tree, hf_acn_pdu_flag_d, tvb, pdu_start, 1, ENC_BIG_ENDIAN);
-
-  /* Add PDU Length item */
-  proto_tree_add_uint(pdu_tree, hf_acn_pdu_length, tvb, pdu_start, pdu_flvh_length, pdu_length);
-
-  /* Set vector offset */
-  if (pdu_flags & ACN_PDU_FLAG_V) {
-    /* use new values */
-    vector_offset = offset;
-    last_pdu_offsets->vector = offset;
-    offset += 1;
-    pdu_flvh_length++;
-  } else {
-    /* use last values */
-    vector_offset = last_pdu_offsets->vector;
-  }
-  /* offset should now be pointing to header (if one exists) */
+  dissect_acn_common_base_pdu(tvb, tree, &offset, last_pdu_offsets, &pdu_flags, &pdu_start, &pdu_length, &pdu_flvh_length, &vector_offset, &ti, &pdu_tree, ett_acn_sdt_base_pdu, 1, 1);
 
   /* Add Vector item */
   vector = tvb_get_guint8(tvb, vector_offset);
@@ -5122,23 +5706,12 @@ dissect_acn_sdt_base_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, in
 
   /* Add Vector item to tree*/
   name = val_to_str(vector, acn_sdt_vector_vals, "not valid (%d)");
-  proto_item_append_text(ti, ": ");
-  proto_item_append_text(ti, "%s", name);
+  proto_item_append_text(ti, ": %s", name);
+  /* proto_item_append_text(ti, "%s", name); */
 
   /* NO HEADER DATA ON THESE* (at least so far) */
 
-  /* Adjust data */
-  if (pdu_flags & ACN_PDU_FLAG_D) {
-    /* use new values */
-    data_offset = offset;
-    data_length = pdu_length - pdu_flvh_length;
-    last_pdu_offsets->data = offset;
-    last_pdu_offsets->data_length = data_length;
-  } else {
-    /* use last values */
-    data_offset = last_pdu_offsets->data;
-    data_length = last_pdu_offsets->data_length;
-  }
+  dissect_pdu_bit_flag_d(offset, pdu_flags, pdu_length, &data_offset, &data_length, last_pdu_offsets, pdu_flvh_length, 1);
   end_offset = data_offset + data_length;
 
   /* process based on vector */
@@ -5275,185 +5848,1240 @@ dissect_acn_sdt_base_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, in
   return pdu_start + pdu_length;
 }
 
+
 /******************************************************************************/
-/* Dissect Root PDU                                                           */
+/* Dissect LLRP Probe Request PDU                                             */
+static guint32
+dissect_llrp_probe_request_pdu(tvbuff_t *tvb, proto_tree *tree, int offset, acn_pdu_offsets *last_pdu_offsets)
+{
+  /* common to all pdu */
+  guint8           pdu_flags;
+  guint8           vector;
+  guint8           filter_flags;
+  guint32          pdu_start;
+  guint32          pdu_length;
+  guint32          pdu_flvh_length; /* flags, length, vector, header */
+  guint32          data_offset;
+  guint32          end_offset;
+
+  proto_item      *ti, *pi;
+  proto_tree      *flag_tree;
+  proto_tree      *pdu_tree;
+
+  begin_dissect_acn_pdu(&pdu_tree, tvb, &ti, tree, &pdu_start, &offset, &pdu_flags, &pdu_length, &pdu_flvh_length, ett_rdmnet_llrp_probe_request_pdu, 0);
+
+  /* Add PDU Length item */
+  proto_tree_add_uint(pdu_tree, hf_rdmnet_llrp_probe_request_pdu_length, tvb, pdu_start, pdu_flvh_length, pdu_length);
+
+  dissect_pdu_bit_flag_v(&offset, pdu_flags, &data_offset, last_pdu_offsets, &pdu_flvh_length, 2);
+  /* offset should now be pointing to header (if one exists) */
+
+  /* add vector item  */
+  vector = tvb_get_guint8(tvb, data_offset);
+  proto_tree_add_uint(pdu_tree, hf_rdmnet_llrp_probe_request_vector, tvb, data_offset, 1, vector);
+
+  dissect_pdu_bit_flag_h(&offset, pdu_flags, &data_offset, last_pdu_offsets, &pdu_flvh_length, 6);
+  data_offset -= 1;
+  /* offset should now be pointing to data (if one exists) */
+
+  /* lower uid */
+  proto_tree_add_item(pdu_tree, hf_rdmnet_llrp_probe_request_lower_uid, tvb, data_offset, 6, ENC_NA);
+  data_offset += 6;
+
+  /* upper uid */
+  proto_tree_add_item(pdu_tree, hf_rdmnet_llrp_probe_request_upper_uid, tvb, data_offset, 6, ENC_NA);
+  data_offset += 6;
+
+  /* filter */
+  filter_flags = tvb_get_guint8(tvb, data_offset);
+  filter_flags = filter_flags & 0x03;
+  pi = proto_tree_add_uint(pdu_tree, hf_rdmnet_llrp_probe_request_filter, tvb, data_offset, 1, filter_flags);
+  flag_tree = proto_item_add_subtree(pi, ett_rdmnet_llrp_probe_request_filter_flags);
+  proto_tree_add_item(flag_tree, hf_rdmnet_llrp_probe_request_filter_brokers_only, tvb, data_offset, 1, ENC_BIG_ENDIAN);
+  proto_tree_add_item(flag_tree, hf_rdmnet_llrp_probe_request_filter_client_tcp_inactive, tvb, data_offset, 2, ENC_BIG_ENDIAN);
+  data_offset += 2;
+
+  /* known uids */
+  end_offset = pdu_start + pdu_length;
+  while (data_offset + 6 <= end_offset) {
+    proto_tree_add_item(pdu_tree, hf_rdmnet_llrp_probe_request_known_uid, tvb, data_offset, 6, ENC_NA);
+    data_offset += 6;
+  }
+
+  return pdu_start + pdu_length;
+}
+
+
+/******************************************************************************/
+/* Dissect LLRP Probe Reply PDU                                             */
+static guint32
+dissect_llrp_probe_reply_pdu(tvbuff_t *tvb, proto_tree *tree, int offset, acn_pdu_offsets *last_pdu_offsets)
+{
+  /* common to all pdu */
+  guint8           pdu_flags;
+  guint8           vector;
+  guint32          pdu_start;
+  guint32          pdu_length;
+  guint32          pdu_flvh_length; /* flags, length, vector, header */
+  guint32          data_offset;
+
+  proto_item      *ti;
+  proto_tree      *pdu_tree;
+
+  begin_dissect_acn_pdu(&pdu_tree, tvb, &ti, tree, &pdu_start, &offset, &pdu_flags, &pdu_length, &pdu_flvh_length, ett_rdmnet_llrp_probe_reply_pdu, 0);
+
+  /* Add PDU Length item */
+  proto_tree_add_uint(pdu_tree, hf_rdmnet_llrp_probe_request_pdu_length, tvb, pdu_start, pdu_flvh_length, pdu_length);
+
+  dissect_pdu_bit_flag_v(&offset, pdu_flags, &data_offset, last_pdu_offsets, &pdu_flvh_length, 2);
+  /* offset should now be pointing to header (if one exists) */
+
+  /* add vector item  */
+  vector = tvb_get_guint8(tvb, data_offset);
+  proto_tree_add_uint(pdu_tree, hf_rdmnet_llrp_probe_reply_vector, tvb, data_offset, 1, vector);
+
+  dissect_pdu_bit_flag_h(&offset, pdu_flags, &data_offset, last_pdu_offsets, &pdu_flvh_length, 6);
+  data_offset -= 1;
+  /* offset should now be pointing to data (if one exists) */
+
+  /* uid */
+  proto_tree_add_item(pdu_tree, hf_rdmnet_llrp_probe_reply_uid, tvb, data_offset, 6, ENC_NA);
+  data_offset += 6;
+
+  /* hardware address */
+  proto_tree_add_item(pdu_tree, hf_rdmnet_llrp_probe_reply_hardware_address, tvb, data_offset, 6, ENC_NA);
+  data_offset += 6;
+
+  /* component type */
+  proto_tree_add_item(pdu_tree, hf_rdmnet_llrp_probe_reply_component_type, tvb, data_offset, 1, ENC_BIG_ENDIAN);
+
+  return pdu_start + pdu_length;
+}
+
+
+/******************************************************************************/
+/* Dissect RDM Command                                                        */
+static guint32
+dissect_rdm_command(tvbuff_t *tvb, packet_info *pinfo, proto_tree *pdu_tree, guint32 data_offset, guint32 length)
+{
+  gboolean         save_info;
+  gboolean         save_protocol;
+  guint32          data_end;
+  tvbuff_t        *next_tvb;
+
+  save_info     = col_get_writable(pinfo->cinfo, COL_INFO);
+  save_protocol = col_get_writable(pinfo->cinfo, COL_PROTOCOL);
+  col_set_writable(pinfo->cinfo, COL_INFO, FALSE);
+  col_set_writable(pinfo->cinfo, COL_PROTOCOL, FALSE);
+
+  data_end = data_offset + length;
+  next_tvb = tvb_new_subset_length(tvb, data_offset, length);
+  call_dissector(rdm_handle, next_tvb, pinfo, pdu_tree);
+
+  col_set_writable(pinfo->cinfo, COL_INFO, save_info);
+  col_set_writable(pinfo->cinfo, COL_PROTOCOL, save_protocol);
+
+  return data_end;
+}
+
+
+/******************************************************************************/
+/* Dissect LLRP RDM Command PDU                                               */
 static guint32
-dissect_acn_root_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset, acn_pdu_offsets *last_pdu_offsets)
+dissect_llrp_rdm_command_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset, acn_pdu_offsets *last_pdu_offsets)
 {
   /* common to all pdu */
   guint8           pdu_flags;
+  guint8           vector;
+  guint32          pdu_start;
+  guint32          pdu_length;
+  guint32          pdu_end;
+  guint32          pdu_flvh_length; /* flags, length, vector, header */
+  guint32          data_offset;
+
+  proto_item      *ti;
+  proto_tree      *pdu_tree;
+
+  /* this pdu */
+  const gchar     *name;
+
+  begin_dissect_acn_pdu(&pdu_tree, tvb, &ti, tree, &pdu_start, &offset, &pdu_flags, &pdu_length, &pdu_flvh_length, ett_rdmnet_llrp_rdm_command_pdu, 0);
+
+  /* Add PDU Length item */
+  proto_tree_add_uint(pdu_tree, hf_rdmnet_llrp_probe_request_pdu_length, tvb, pdu_start, pdu_flvh_length, pdu_length);
+
+  dissect_pdu_bit_flag_v(&offset, pdu_flags, &data_offset, last_pdu_offsets, &pdu_flvh_length, 2);
+  /* offset should now be pointing to header (if one exists) */
+
+  /* add vector item  */
+  vector = tvb_get_guint8(tvb, data_offset);
+  proto_tree_add_uint(pdu_tree, hf_rdmnet_llrp_rdm_command_start_code, tvb, data_offset, 1, vector);
+
+  /* Add Vector item to tree */
+  name = val_to_str(vector, rdmnet_llrp_rdm_command_start_code_vals, "unknown (%d)");
+  proto_item_append_text(ti, ": %s", name);
+
+  dissect_pdu_bit_flag_h(&offset, pdu_flags, &data_offset, last_pdu_offsets, &pdu_flvh_length, 6);
+  data_offset -= 1;
+  /* offset should now be pointing to data (if one exists) */
+
+  pdu_end = pdu_start + pdu_length;
+  dissect_rdm_command(tvb, pinfo, pdu_tree, data_offset, (pdu_length-4));
+
+  return pdu_end;
+}
+
+
+/******************************************************************************/
+/* Dissect LLRP Base PDU                                                      */
+static guint32
+dissect_acn_llrp_base_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset, acn_pdu_offsets *last_pdu_offsets)
+{
+  guint8           pdu_flags;
   guint32          pdu_start;
   guint32          pdu_length;
   guint32          pdu_flvh_length; /* flags, length, vector, header */
   acn_pdu_offsets  pdu_offsets = {0,0,0,0,0};
-  guint8           octet;
-  guint32          length1;
-  guint32          length2;
-  guint32          length3;
   guint32          vector_offset;
-  guint32          header_offset;
   guint32          data_offset;
+  guint32          data_length;
+  e_guid_t         guid;
+
+  proto_item      *ti;
+  proto_tree      *pdu_tree;
+
+  /* this pdu */
+  const gchar     *name;
+  guint32          vector;
+
+  dissect_acn_common_base_pdu(tvb, tree, &offset, last_pdu_offsets, &pdu_flags, &pdu_start, &pdu_length, &pdu_flvh_length, &vector_offset, &ti, &pdu_tree, ett_rdmnet_llrp_base_pdu, 1, 0);
+
+  /* Add Vector item */
+  vector = tvb_get_ntohl(tvb, vector_offset);
+  proto_tree_add_item(pdu_tree, hf_rdmnet_llrp_vector, tvb, vector_offset, 4, ENC_BIG_ENDIAN);
+
+  /* Add Vector item to tree */
+  name = val_to_str(vector, rdmnet_llrp_vector_vals, "unknown (%d)");
+  proto_item_append_text(ti, ": %s", name);
+
+  /* NO HEADER DATA ON THESE* (at least so far) */
+
+  dissect_pdu_bit_flag_d(offset, pdu_flags, pdu_length, &data_offset, &data_length, last_pdu_offsets, pdu_flvh_length, 0);
+  data_offset += 3;
+
+  /* get destination (CID) 16 bytes */
+  proto_tree_add_item(pdu_tree, hf_rdmnet_llrp_destination_cid, tvb, data_offset, 16, ENC_BIG_ENDIAN);
+  tvb_get_guid(tvb, data_offset, &guid, ENC_BIG_ENDIAN);
+  proto_item_append_text(ti, ", Dest: %s", guid_to_str(wmem_packet_scope(), &guid));
+  data_offset += 16;
+
+  /* transaction number (4 bytes) */
+  proto_tree_add_item(pdu_tree, hf_rdmnet_llrp_transaction_number, tvb, data_offset, 4, ENC_BIG_ENDIAN);
+  data_offset += 4;
+
+  /* process based on vector */
+  switch (vector) {
+    case RDMNET_LLRP_VECTOR_PROBE_REQUEST:
+      dissect_llrp_probe_request_pdu(tvb, pdu_tree, data_offset, &pdu_offsets);
+      break;
+    case RDMNET_LLRP_VECTOR_PROBE_REPLY:
+      dissect_llrp_probe_reply_pdu(tvb, pdu_tree, data_offset, &pdu_offsets);
+      break;
+    case RDMNET_LLRP_VECTOR_RDM_CMD:
+      dissect_llrp_rdm_command_pdu(tvb, pinfo, pdu_tree, data_offset, &pdu_offsets);
+      break;
+  }
+
+  return pdu_start + pdu_length;
+}
+
+
+/******************************************************************************/
+/* Dissect Broker Client Entry PDU                                            */
+static guint32
+dissect_broker_client_entry_pdu(tvbuff_t *tvb, proto_tree *tree, guint32 offset, acn_pdu_offsets *last_pdu_offsets)
+{
+  guint8           pdu_flags;
+  guint32          pdu_start;
+  guint32          pdu_length;
+  guint32          pdu_end;
+  guint32          pdu_flvh_length; /* flags, length, vector, header */
+  guint32          vector_offset;
+  guint32          data_offset;
+  guint32          data_length;
+
+  proto_item      *ti;
+  proto_item      *ti2;
+  proto_tree      *pdu_tree;
+  proto_tree      *pdu_tree2;
+
+  /* this pdu */
+  const gchar     *name;
+  guint32          vector;
+
+  dissect_acn_common_base_pdu(tvb, tree, &offset, last_pdu_offsets, &pdu_flags, &pdu_start, &pdu_length, &pdu_flvh_length, &vector_offset, &ti, &pdu_tree, ett_rdmnet_broker_client_entry_pdu, 1, 0);
+  pdu_end = pdu_start + pdu_length;
+
+  /* Add Vector item */
+  vector = tvb_get_ntohl(tvb, vector_offset);
+  proto_tree_add_item(pdu_tree, hf_rdmnet_broker_client_protocol_vector, tvb, vector_offset, 4, ENC_BIG_ENDIAN);
+
+  /* Add Vector item to tree */
+  name = val_to_str(vector, broker_client_protocol_vals, "unknown (%d)");
+  proto_item_append_text(ti, ": %s", name);
+
+  /* NO HEADER DATA ON THESE* (at least so far) */
+
+  dissect_pdu_bit_flag_d(offset, pdu_flags, pdu_length, &data_offset, &data_length, last_pdu_offsets, pdu_flvh_length, 0);
+  data_offset += 3;
+
+  /* client protocol cid */
+  proto_tree_add_item(pdu_tree, hf_rdmnet_broker_client_protocol_cid, tvb, data_offset, 16, ENC_NA);
+  data_offset += 16;
+
+  /* process based on vector */
+  switch (vector) {
+  case RDMNET_CLIENT_PROTOCOL_RPT:
+    /* client uid */
+    proto_tree_add_item(pdu_tree, hf_rdmnet_broker_client_rpt_client_uid, tvb, data_offset, 6, ENC_NA);
+    data_offset += 6;
+
+    /* client type */
+    proto_tree_add_item(pdu_tree, hf_rdmnet_broker_client_rpt_client_type, tvb, data_offset, 1, ENC_BIG_ENDIAN);
+    data_offset += 1;
+
+    /* binding cid */
+    proto_tree_add_item(pdu_tree, hf_rdmnet_broker_client_rpt_binding_cid, tvb, data_offset, 16, ENC_NA);
+    data_offset += 16;
+    break;
+  case RDMNET_CLIENT_PROTOCOL_EPT:
+    while (offset + 36 < pdu_end) {
+      /* protocol vector (manufacturer id + protocol id) */
+      ti2 = proto_tree_add_item(pdu_tree, hf_rdmnet_broker_client_ept_protocol_vector, tvb, data_offset, 4, ENC_NA);
+      pdu_tree2 = proto_item_add_subtree(ti2, ett_rdmnet_broker_client_entry_manufacturer_protocol_ids);
+      proto_tree_add_item(pdu_tree2, hf_rdmnet_broker_client_ept_protocol_manufacturer_id, tvb, 0, 2, ENC_BIG_ENDIAN);
+      proto_tree_add_item(pdu_tree2, hf_rdmnet_broker_client_ept_protocol_protocol_id, tvb, 2, 2, ENC_BIG_ENDIAN);
+      offset += 4;
+
+      /* protocol string */
+      proto_tree_add_item(pdu_tree, hf_rdmnet_broker_client_ept_protocol_string, tvb, data_offset, 32, ENC_ASCII|ENC_NA);
+      data_offset += 32;
+    }
+    break;
+  }
+
+  return pdu_end;
+}
+
+
+/******************************************************************************/
+/* Dissect Broker Connect                                                     */
+static guint32
+dissect_broker_connect(tvbuff_t *tvb, proto_tree *tree, int offset, acn_pdu_offsets *last_pdu_offsets, guint32 pdu_end)
+{
+  guint8           connection_flags;
+  proto_item      *pi;
+  proto_tree      *flag_tree;
+
+  /* client scope */
+  proto_tree_add_item(tree, hf_rdmnet_broker_connect_client_scope, tvb, offset, 63, ENC_ASCII|ENC_NA);
+  offset += 63;
+
+  /* e133 version */
+  proto_tree_add_item(tree, hf_rdmnet_broker_connect_e133_version, tvb, offset, 2, ENC_BIG_ENDIAN);
+  offset += 2;
+
+  /* search domain */
+  proto_tree_add_item(tree, hf_rdmnet_broker_connect_search_domain, tvb, offset, 231, ENC_ASCII|ENC_NA);
+  offset += 231;
+
+  /* connection flags */
+  connection_flags = tvb_get_guint8(tvb, offset);
+  connection_flags = connection_flags & 0x01;
+  pi = proto_tree_add_uint(tree, hf_rdmnet_broker_connect_connection_flags, tvb, offset, 1, connection_flags);
+  flag_tree = proto_item_add_subtree(pi, ett_rdmnet_broker_connect_connection_flags);
+  proto_tree_add_item(flag_tree, hf_rdmnet_broker_connect_connection_flags_incremental_updates, tvb, offset, 1, ENC_BIG_ENDIAN);
+  offset += 1;
+
+  /* client_entry_pdu */
+  dissect_broker_client_entry_pdu(tvb, tree, offset, last_pdu_offsets);
+
+  return pdu_end;
+}
+
+
+/******************************************************************************/
+/* Dissect Broker Connect Reply                                               */
+static guint32
+dissect_broker_connect_reply(tvbuff_t *tvb, proto_tree *tree, int offset)
+{
+  /* connection code */
+  proto_tree_add_item(tree, hf_rdmnet_broker_connect_reply_connection_code, tvb, offset, 2, ENC_BIG_ENDIAN);
+  offset += 2;
+
+  /* e133 version */
+  proto_tree_add_item(tree, hf_rdmnet_broker_connect_reply_e133_version, tvb, offset, 2, ENC_BIG_ENDIAN);
+  offset += 2;
+
+  /* broker uid */
+  proto_tree_add_item(tree, hf_rdmnet_broker_connect_reply_broker_uid, tvb, offset, 6, ENC_NA);
+  offset += 6;
+
+  /* client uid */
+  proto_tree_add_item(tree, hf_rdmnet_broker_connect_reply_client_uid, tvb, offset, 6, ENC_NA);
+
+  return 0;
+}
+
+
+/******************************************************************************/
+/* Dissect Broker Client Entry Update                                         */
+static guint32
+dissect_broker_client_entry_update(tvbuff_t *tvb, proto_tree *tree, int offset, acn_pdu_offsets *last_pdu_offsets, guint32 pdu_end)
+{
+  guint8           connection_flags;
+
+  proto_item      *pi;
+  proto_tree      *flag_tree;
+
+  /* connection flags */
+  connection_flags = tvb_get_guint8(tvb, offset);
+  connection_flags = connection_flags & 0x01;
+  pi = proto_tree_add_uint(tree, hf_rdmnet_broker_client_entry_update_connection_flags, tvb, offset, 1, connection_flags);
+  flag_tree = proto_item_add_subtree(pi, ett_rdmnet_broker_client_entry_update_connection_flags);
+  proto_tree_add_item(flag_tree, hf_rdmnet_broker_client_entry_update_connection_flags_incremental_updates, tvb, offset, 1, ENC_BIG_ENDIAN);
+  offset += 1;
+
+  /* client_entry_pdu */
+  dissect_broker_client_entry_pdu(tvb, tree, offset, last_pdu_offsets);
+
+  return pdu_end;
+}
+
+
+/******************************************************************************/
+/* Dissect Broker Redirect V4                                                 */
+static guint32
+dissect_broker_redirect_v4(tvbuff_t *tvb, proto_tree *tree, int offset)
+{
+  /* ipv4 address */
+  proto_tree_add_item(tree, hf_rdmnet_broker_redirect_ipv4_address, tvb, offset, 4, ENC_BIG_ENDIAN);
+  offset += 4;
+
+  /* tcp port */
+  proto_tree_add_item(tree, hf_rdmnet_broker_redirect_ipv4_tcp_port, tvb, offset, 2, ENC_BIG_ENDIAN);
+
+  return 0;
+}
+
+
+/******************************************************************************/
+/* Dissect Broker Redirect V6                                                 */
+static guint32
+dissect_broker_redirect_v6(tvbuff_t *tvb, proto_tree *tree, int offset)
+{
+  /* ipv4 address */
+  proto_tree_add_item(tree, hf_rdmnet_broker_redirect_ipv6_address, tvb, offset, 16, ENC_NA);
+  offset += 16;
+
+  /* tcp port */
+  proto_tree_add_item(tree, hf_rdmnet_broker_redirect_ipv6_tcp_port, tvb, offset, 2, ENC_BIG_ENDIAN);
+
+  return 0;
+}
+
+
+/******************************************************************************/
+/* Dissect Broker Disconnect                                                  */
+static guint32
+dissect_broker_disconnect(tvbuff_t *tvb, proto_tree *tree, int offset)
+{
+  /* disconnect reason */
+  proto_tree_add_item(tree, hf_rdmnet_broker_disconnect_reason, tvb, offset, 2, ENC_BIG_ENDIAN);
+
+  return 0;
+}
+
+
+/******************************************************************************/
+/* Dissect Broker Request Dynamic UIDs                                        */
+static guint32
+dissect_broker_request_dynamic_uids(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint32 pdu_end)
+{
+  /* packed list of dynamic uid request (6 bytes) and rid (16 bytes) */
+  while (offset + 22 < pdu_end) {
+    /* dynamic uid request (6 bytes) */
+    proto_tree_add_item(tree, hf_rdmnet_broker_dynamic_uid_request, tvb, offset, 6, ENC_NA);
+    offset += 6;
+
+    /* rid (16 bytes) */
+    proto_tree_add_item(tree, hf_rdmnet_broker_rid, tvb, offset, 16, ENC_NA);
+    offset += 16;
+  }
+
+  return 0;
+}
+
+
+/******************************************************************************/
+/* Dissect Broker Assigned Dynamic UIDs                                       */
+static guint32
+dissect_broker_assigned_dynamic_uids(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint32 pdu_end)
+{
+  /* packed list of dynamic uid request (6 bytes), rid (16 bytes), and status_code (2 bytes) */
+  while (offset + 24 < pdu_end) {
+    /* dynamic uid request (6 bytes) */
+    proto_tree_add_item(tree, hf_rdmnet_broker_assigned_dynamic_uid, tvb, offset, 6, ENC_NA);
+    offset += 6;
+
+    /* rid (16 bytes) */
+    proto_tree_add_item(tree, hf_rdmnet_broker_assigned_rid, tvb, offset, 16, ENC_NA);
+    offset += 16;
+
+    /* status code (2 bytes) */
+    proto_tree_add_item(tree, hf_rdmnet_broker_assigned_status_code, tvb, offset, 2, ENC_NA);
+    offset += 2;
+  }
+
+  return 0;
+}
+
+
+/******************************************************************************/
+/* Dissect Broker Fetch Dynamic UIDs                                       */
+static guint32
+dissect_broker_fetch_dynamic_uids(tvbuff_t *tvb, proto_tree *tree, guint32 offset, guint32 pdu_end)
+{
+  /* packed list of dynamic uid request (6 bytes) */
+  while (offset + 6 < pdu_end) {
+    /* dynamic uid request (6 bytes) */
+    proto_tree_add_item(tree, hf_rdmnet_broker_fetch_dynamic_uid, tvb, offset, 6, ENC_NA);
+    offset += 6;
+  }
+
+  return 0;
+}
+
+
+/******************************************************************************/
+/* Dissect Broker Base PDU                                                    */
+static guint32
+dissect_acn_broker_base_pdu(tvbuff_t *tvb, proto_tree *tree, int offset, acn_pdu_offsets *last_pdu_offsets)
+{
+  guint8           pdu_flags;
+  guint32          pdu_start;
+  guint32          pdu_length;
+  guint32          pdu_end;
+  guint32          pdu_flvh_length; /* flags, length, vector, header */
+  acn_pdu_offsets  pdu_offsets = {0,0,0,0,0};
+  guint32          vector_offset;
+  guint32          data_offset;
+  guint32          old_offset;
   guint32          end_offset;
+  guint32          data_length;
+
+  proto_item      *ti;
+  proto_tree      *pdu_tree;
+
+  /* this pdu */
+  const gchar     *name;
+  guint16          vector;
+
+  dissect_acn_common_base_pdu(tvb, tree, &offset, last_pdu_offsets, &pdu_flags, &pdu_start, &pdu_length, &pdu_flvh_length, &vector_offset, &ti, &pdu_tree, ett_rdmnet_broker_base_pdu, 1, 0);
+  pdu_end = pdu_start + pdu_length;
+
+  /* Add Vector item */
+  vector = tvb_get_ntohs(tvb, vector_offset);
+  proto_tree_add_item(pdu_tree, hf_rdmnet_broker_vector, tvb, vector_offset, 2, ENC_BIG_ENDIAN);
+
+  /* Add Vector item to tree */
+  name = val_to_str(vector, rdmnet_broker_vector_vals, "unknown (%d)");
+  proto_item_append_text(ti, ": %s", name);
+
+  /* NO HEADER DATA ON THESE* (at least so far) */
+
+  dissect_pdu_bit_flag_d(offset, pdu_flags, pdu_length, &data_offset, &data_length, last_pdu_offsets, pdu_flvh_length, 0);
+  data_offset += 1;
+
+  /* process based on vector */
+  switch (vector) {
+  case RDMNET_BROKER_VECTOR_FETCH_CLIENT_LIST:
+  case RDMNET_BROKER_VECTOR_NULL:
+    /* no data */
+    break;
+  case RDMNET_BROKER_VECTOR_CONNECTED_CLIENT_LIST:
+  case RDMNET_BROKER_VECTOR_CLIENT_ADD:
+  case RDMNET_BROKER_VECTOR_CLIENT_REMOVE:
+  case RDMNET_BROKER_VECTOR_CLIENT_ENTRY_CHANGE:
+    end_offset = pdu_start + pdu_length;
+    while (data_offset < end_offset) {
+      old_offset = data_offset;
+      data_offset = dissect_broker_client_entry_pdu(tvb, pdu_tree, data_offset, &pdu_offsets);
+      if (data_offset == old_offset) break;
+    }
+    break;
+  case RDMNET_BROKER_VECTOR_CONNECT:
+    dissect_broker_connect(tvb, pdu_tree, data_offset, &pdu_offsets, pdu_end);
+    break;
+  case RDMNET_BROKER_VECTOR_CONNECT_REPLY:
+    dissect_broker_connect_reply(tvb, pdu_tree, data_offset);
+    break;
+  case RDMNET_BROKER_VECTOR_CLIENT_ENTRY_UPDATE:
+    dissect_broker_client_entry_update(tvb, pdu_tree, data_offset, &pdu_offsets, pdu_end);
+    break;
+  case RDMNET_BROKER_VECTOR_REDIRECT_V4:
+    dissect_broker_redirect_v4(tvb, pdu_tree, data_offset);
+    break;
+  case RDMNET_BROKER_VECTOR_REDIRECT_V6:
+    dissect_broker_redirect_v6(tvb, pdu_tree, data_offset);
+    break;
+  case RDMNET_BROKER_VECTOR_DISCONNECT:
+    dissect_broker_disconnect(tvb, pdu_tree, data_offset);
+    break;
+  case RDMNET_BROKER_VECTOR_REQUEST_DYNAMIC_UIDS:
+    dissect_broker_request_dynamic_uids(tvb, pdu_tree, data_offset, pdu_end);
+    break;
+  case RDMNET_BROKER_VECTOR_ASSIGNED_DYNAMIC_UIDS:
+    dissect_broker_assigned_dynamic_uids(tvb, pdu_tree, data_offset, pdu_end);
+    break;
+  case RDMNET_BROKER_VECTOR_FETCH_DYNAMIC_UID_LIST:
+    dissect_broker_fetch_dynamic_uids(tvb, pdu_tree, data_offset, pdu_end);
+    break;
+  }
+
+  return pdu_start + pdu_length;
+}
+
+
+/******************************************************************************/
+/* Dissect RPT Request RDM Command                                            */
+static guint32
+dissect_rpt_request_rdm_command(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset, acn_pdu_offsets *last_pdu_offsets)
+{
+  guint8           pdu_flags;
+  guint32          pdu_start;
+  guint32          pdu_length;
+  guint32          pdu_end;
+  guint32          pdu_flvh_length; /* flags, length, vector, header */
+  guint32          vector_offset;
+  guint32          data_offset;
+  guint32          data_length;
+
+  proto_item      *ti;
+  proto_tree      *pdu_tree;
+
+  /* this pdu */
+  const gchar     *name;
+  guint8           vector;
+
+  dissect_acn_common_base_pdu(tvb, tree, &offset, last_pdu_offsets, &pdu_flags, &pdu_start, &pdu_length, &pdu_flvh_length, &vector_offset, &ti, &pdu_tree, ett_rdmnet_rpt_request_pdu, 1, 0);
+
+  /* Add Vector item */
+  vector = tvb_get_guint8(tvb, vector_offset);
+  proto_tree_add_item(pdu_tree, hf_rdmnet_rpt_request_rdm_command, tvb, vector_offset, 1, ENC_BIG_ENDIAN);
+
+  /* Add Vector item to tree */
+  name = val_to_str(vector, rdmnet_rpt_request_rdm_command_start_code_vals, "unknown (%d)");
+  proto_item_append_text(ti, ": %s", name);
+
+  /* NO HEADER DATA ON THESE* (at least so far) */
+
+  dissect_pdu_bit_flag_d(offset, pdu_flags, pdu_length, &data_offset, &data_length, last_pdu_offsets, pdu_flvh_length, 0);
+  /* data_offset += 3; */
+
+  pdu_end = pdu_start + pdu_length;
+  dissect_rdm_command(tvb, pinfo, pdu_tree, data_offset, (pdu_length-4));
+
+  return pdu_end;
+}
+
+
+/******************************************************************************/
+/* Dissect RPT Request                                                        */
+static guint32
+dissect_rpt_request(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset, acn_pdu_offsets *last_pdu_offsets)
+{
+  guint8           pdu_flags;
+  guint32          pdu_start;
+  guint32          pdu_length;
+  guint32          pdu_flvh_length; /* flags, length, vector, header */
+  acn_pdu_offsets  pdu_offsets = {0,0,0,0,0};
+  guint32          vector_offset;
+  guint32          data_offset;
+  guint32          data_length;
+
+  proto_item      *ti;
+  proto_tree      *pdu_tree;
+
+  /* this pdu */
+  const gchar     *name;
+  guint32          vector;
+
+  dissect_acn_common_base_pdu(tvb, tree, &offset, last_pdu_offsets, &pdu_flags, &pdu_start, &pdu_length, &pdu_flvh_length, &vector_offset, &ti, &pdu_tree, ett_rdmnet_rpt_request_pdu, 1, 0);
+
+  /* Add Vector item */
+  vector = tvb_get_ntohl(tvb, vector_offset);
+  proto_tree_add_item(pdu_tree, hf_rdmnet_rpt_request_vector, tvb, vector_offset, 4, ENC_BIG_ENDIAN);
+
+  /* Add Vector item to tree */
+  name = val_to_str(vector, rdmnet_rpt_request_vals, "unknown (%d)");
+  proto_item_append_text(ti, ": %s", name);
+
+  /* NO HEADER DATA ON THESE* (at least so far) */
+
+  dissect_pdu_bit_flag_d(offset, pdu_flags, pdu_length, &data_offset, &data_length, last_pdu_offsets, pdu_flvh_length, 0);
+  data_offset += 3;
+
+  /* rdm command */
+  dissect_rpt_request_rdm_command(tvb, pinfo, pdu_tree, data_offset, &pdu_offsets);
+
+  return 0;
+}
+
+
+/******************************************************************************/
+/* Dissect RPT Status                                                         */
+static guint32
+dissect_rpt_status(tvbuff_t *tvb, proto_tree *tree, int offset, acn_pdu_offsets *last_pdu_offsets)
+{
+  guint8           pdu_flags;
+  guint32          pdu_start;
+  guint32          pdu_length;
+  guint32          pdu_end;
+  guint32          pdu_flvh_length; /* flags, length, vector, header */
+  guint32          vector_offset;
+  guint32          data_offset;
+  guint32          data_length;
+
+  proto_item      *ti;
+  proto_tree      *pdu_tree;
+
+  /* this pdu */
+  const gchar     *name;
+  guint16          vector;
+
+  dissect_acn_common_base_pdu(tvb, tree, &offset, last_pdu_offsets, &pdu_flags, &pdu_start, &pdu_length, &pdu_flvh_length, &vector_offset, &ti, &pdu_tree, ett_rdmnet_rpt_status_pdu, 1, 0);
+
+  /* Add Vector item */
+  vector = tvb_get_ntohs(tvb, vector_offset);
+  proto_item_append_text(ti, ", vector = %u", vector);
+  proto_tree_add_item(pdu_tree, hf_rdmnet_rpt_status_vector, tvb, vector_offset, 2, ENC_BIG_ENDIAN);
+
+  /* Add Vector item to tree */
+  name = val_to_str(vector, rdmnet_rpt_status_vector_vals, "unknown (%d)");
+  proto_item_append_text(ti, ": %s", name);
+
+  /* NO HEADER DATA ON THESE* (at least so far) */
+
+  dissect_pdu_bit_flag_d(offset, pdu_flags, pdu_length, &data_offset, &data_length, last_pdu_offsets, pdu_flvh_length, 0);
+  data_offset += 3;
+
+  pdu_end = pdu_start + pdu_length;
+  switch (vector) {
+  case RDMNET_RPT_VECTOR_STATUS_UNKNOWN_RPT_UID:
+    if (pdu_end > data_offset) {
+      proto_tree_add_item(pdu_tree, hf_rdmnet_rpt_status_unknown_rpt_uid_string, tvb, data_offset, (pdu_end - data_offset), ENC_ASCII|ENC_NA);
+    }
+    break;
+  case RDMNET_RPT_VECTOR_STATUS_RDM_TIMEOUT:
+    if (pdu_end > data_offset) {
+      proto_tree_add_item(pdu_tree, hf_rdmnet_rpt_status_rdm_timeout_string, tvb, data_offset, (pdu_end - data_offset), ENC_ASCII|ENC_NA);
+    }
+    break;
+  case RDMNET_RPT_VECTOR_STATUS_RDM_INVALID_RESPONSE:
+    if (pdu_end > data_offset) {
+      proto_tree_add_item(pdu_tree, hf_rdmnet_rpt_status_rdm_invalid_response_string, tvb, data_offset, (pdu_end - data_offset), ENC_ASCII|ENC_NA);
+    }
+    break;
+  case RDMNET_RPT_VECTOR_STATUS_UNKNOWN_RDM_UID:
+    if (pdu_end > data_offset) {
+      proto_tree_add_item(pdu_tree, hf_rdmnet_rpt_status_unknown_rdm_uid_string, tvb, data_offset, (pdu_end - data_offset), ENC_ASCII|ENC_NA);
+    }
+    break;
+  case RDMNET_RPT_VECTOR_STATUS_UNKNOWN_ENDPOINT:
+    if (pdu_end > data_offset) {
+      proto_tree_add_item(pdu_tree, hf_rdmnet_rpt_status_unknown_endpoint_string, tvb, data_offset, (pdu_end - data_offset), ENC_ASCII|ENC_NA);
+    }
+    break;
+  case RDMNET_RPT_VECTOR_STATUS_BROADCAST_COMPLETE:
+    if (pdu_end > data_offset) {
+      proto_tree_add_item(pdu_tree, hf_rdmnet_rpt_status_broadcast_complete_string, tvb, data_offset, (pdu_end - data_offset), ENC_ASCII|ENC_NA);
+    }
+    break;
+  case RDMNET_RPT_VECTOR_STATUS_UNKNOWN_VECTOR:
+    if (pdu_end > data_offset) {
+      proto_tree_add_item(pdu_tree, hf_rdmnet_rpt_status_unknown_vector_string, tvb, data_offset, (pdu_end - data_offset), ENC_ASCII|ENC_NA);
+    }
+    break;
+  case RDMNET_RPT_VECTOR_STATUS_INVALID_MESSAGE:
+  case RDMNET_RPT_VECTOR_STATUS_INVALID_COMMAND_CLASS:
+    /* no data */
+    break;
+  }
+
+  return pdu_start + pdu_length;
+}
+
+
+/******************************************************************************/
+/* Dissect RPT Notification RDM Command                                       */
+static guint32
+dissect_rpt_notification_rdm_command(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset, acn_pdu_offsets *last_pdu_offsets)
+{
+  guint8           pdu_flags;
+  guint32          pdu_start;
+  guint32          pdu_length;
+  guint32          pdu_end;
+  guint32          pdu_flvh_length; /* flags, length, vector, header */
+  guint32          vector_offset;
+  guint32          data_offset;
+  guint32          data_length;
+
+  proto_item      *ti;
+  proto_tree      *pdu_tree;
+
+  /* this pdu */
+  const gchar     *name;
+  guint8           vector;
+
+  dissect_acn_common_base_pdu(tvb, tree, &offset, last_pdu_offsets, &pdu_flags, &pdu_start, &pdu_length, &pdu_flvh_length, &vector_offset, &ti, &pdu_tree, ett_rdmnet_rpt_request_pdu, 1, 0);
+
+  /* Add Vector item */
+  vector = tvb_get_guint8(tvb, vector_offset);
+  proto_tree_add_item(pdu_tree, hf_rdmnet_rpt_notification_rdm_command, tvb, vector_offset, 1, ENC_BIG_ENDIAN);
+
+  /* Add Vector item to tree */
+  name = val_to_str(vector, rdmnet_rpt_request_rdm_command_start_code_vals, "unknown (%d)");
+  proto_item_append_text(ti, ": %s", name);
+
+  /* NO HEADER DATA ON THESE* (at least so far) */
+
+  dissect_pdu_bit_flag_d(offset, pdu_flags, pdu_length, &data_offset, &data_length, last_pdu_offsets, pdu_flvh_length, 0);
+  /* data_offset += 3; */
+
+  pdu_end = pdu_start + pdu_length;
+  dissect_rdm_command(tvb, pinfo, pdu_tree, data_offset, (pdu_length-4));
+
+  return pdu_end;
+}
+
+
+/******************************************************************************/
+/* Dissect RPT Notification                                                   */
+static guint32
+dissect_rpt_notification(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset, acn_pdu_offsets *last_pdu_offsets)
+{
+  guint8           pdu_flags;
+  guint32          pdu_start;
+  guint32          pdu_length;
+  guint32          pdu_end;
+  guint32          pdu_flvh_length; /* flags, length, vector, header */
+  acn_pdu_offsets  pdu_offsets = {0,0,0,0,0};
+  guint32          vector_offset;
+  guint32          data_offset;
+  guint32          data_length;
   guint32          old_offset;
+
+  proto_item      *ti;
+  proto_tree      *pdu_tree;
+
+  /* this pdu */
+  const gchar     *name;
+  guint32          vector;
+
+  dissect_acn_common_base_pdu(tvb, tree, &offset, last_pdu_offsets, &pdu_flags, &pdu_start, &pdu_length, &pdu_flvh_length, &vector_offset, &ti, &pdu_tree, ett_rdmnet_rpt_notification_pdu, 1, 0);
+
+  /* Add Vector item */
+  vector = tvb_get_ntohl(tvb, vector_offset);
+  proto_tree_add_item(pdu_tree, hf_rdmnet_rpt_notification_vector, tvb, vector_offset, 4, ENC_BIG_ENDIAN);
+
+  /* Add Vector item to tree  "RDM Command" */
+  name = val_to_str(vector, rdmnet_rpt_notification_vals, "unknown (%d)");
+  proto_item_append_text(ti, ": %s", name);
+
+  /* NO HEADER DATA ON THESE* (at least so far) */
+
+  dissect_pdu_bit_flag_d(offset, pdu_flags, pdu_length, &data_offset, &data_length, last_pdu_offsets, pdu_flvh_length, 0);
+  data_offset += 3;
+
+  /* rdm command */
+  pdu_end = pdu_start + pdu_length;
+  while (data_offset < pdu_end) {
+    old_offset = data_offset;
+    data_offset = dissect_rpt_notification_rdm_command(tvb, pinfo, pdu_tree, data_offset, &pdu_offsets);
+    if (data_offset == old_offset) break;
+  }
+
+  return pdu_end;
+}
+
+
+/******************************************************************************/
+/* Dissect RPT Base PDU                                                       */
+static guint32
+dissect_acn_rpt_base_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset, acn_pdu_offsets *last_pdu_offsets)
+{
+  guint8           pdu_flags;
+  guint32          pdu_start;
+  guint32          pdu_length;
+  guint32          pdu_flvh_length; /* flags, length, vector, header */
+  acn_pdu_offsets  pdu_offsets = {0,0,0,0,0};
+  guint32          vector_offset;
+  guint32          data_offset;
   guint32          data_length;
 
-  proto_item      *ti, *pi;
+  proto_item      *ti;
   proto_tree      *pdu_tree;
-  proto_tree      *flag_tree;
 
   /* this pdu */
-  guint32          protocol_id;
-  e_guid_t         guid;
+  const gchar     *name;
+  guint32          vector;
 
-  /* save start of pdu block */
-  pdu_start         = offset;
-  pdu_offsets.start = pdu_start;
+  dissect_acn_common_base_pdu(tvb, tree, &offset, last_pdu_offsets, &pdu_flags, &pdu_start, &pdu_length, &pdu_flvh_length, &vector_offset, &ti, &pdu_tree, ett_rdmnet_rpt_base_pdu, 1, 0);
 
-  /* get PDU flags and length flag first */
-  octet     = tvb_get_guint8(tvb, offset++);
-  pdu_flags = octet & 0xf0;
-  length1   = octet & 0x0f;     /* bottom 4 bits only */
-  length2   = tvb_get_guint8(tvb, offset++);
+  /* Add Vector item */
+  vector = tvb_get_ntohl(tvb, vector_offset);
+  proto_tree_add_item(pdu_tree, hf_rdmnet_rpt_vector, tvb, vector_offset, 4, ENC_BIG_ENDIAN);
 
-  /* if length flag is set, then we have a 20 bit length else we have a 12 bit */
-  /* flvh = flags, length, vector, header */
-  if (pdu_flags & ACN_PDU_FLAG_L) {
-    length3 = tvb_get_guint8(tvb, offset);
-    offset += 1;
-    pdu_length = length3 | (length2 << 8) | (length1 << 16);
-    pdu_flvh_length = 3;
-  } else {
-    pdu_length = length2 | (length1 << 8);
-    pdu_flvh_length = 2;
+  /* Add Vector item to tree */
+  name = val_to_str(vector, rdmnet_rpt_vector_vals, "unknown (%d)");
+  proto_item_append_text(ti, ": %s", name);
+
+  /* NO HEADER DATA ON THESE* (at least so far) */
+
+  dissect_pdu_bit_flag_d(offset, pdu_flags, pdu_length, &data_offset, &data_length, last_pdu_offsets, pdu_flvh_length, 0);
+  data_offset += 3;
+
+  /* source uid (6 bytes) */
+  proto_tree_add_item(pdu_tree, hf_rdmnet_rpt_source_uid, tvb, data_offset, 6, ENC_NA);
+  data_offset += 6;
+
+  /* source endpoint id (2 bytes) */
+  proto_tree_add_item(pdu_tree, hf_rdmnet_rpt_source_endpoint_id, tvb, data_offset, 2, ENC_BIG_ENDIAN);
+  data_offset += 2;
+
+  /* destination uid (6 bytes) */
+  proto_tree_add_item(pdu_tree, hf_rdmnet_rpt_destination_uid, tvb, data_offset, 6, ENC_NA);
+  data_offset += 6;
+
+  /* destination endpoint id (2 bytes) */
+  proto_tree_add_item(pdu_tree, hf_rdmnet_rpt_destination_endpoint_id, tvb, data_offset, 2, ENC_BIG_ENDIAN);
+  data_offset += 2;
+
+  /* sequence number (4 bytes) */
+  proto_tree_add_item(pdu_tree, hf_rdmnet_rpt_sequence_number, tvb, data_offset, 4, ENC_BIG_ENDIAN);
+  data_offset += 4;
+
+  /* reserved (1 byte) */
+  proto_tree_add_item(pdu_tree, hf_rdmnet_rpt_reserved, tvb, data_offset, 1, ENC_BIG_ENDIAN);
+  data_offset += 1;
+
+  /* process based on vector */
+  switch (vector) {
+  case RDMNET_RPT_VECTOR_REQUEST:
+    dissect_rpt_request(tvb, pinfo, pdu_tree, data_offset, &pdu_offsets);
+    break;
+  case RDMNET_RPT_VECTOR_STATUS:
+    dissect_rpt_status(tvb, pdu_tree, data_offset, &pdu_offsets);
+    break;
+  case RDMNET_RPT_VECTOR_NOTIFICATION:
+    dissect_rpt_notification(tvb, pinfo, pdu_tree, data_offset, &pdu_offsets);
+    break;
   }
-  /* offset should now be pointing to vector (if one exists) */
 
-  /* Add pdu item and tree */
-  ti = proto_tree_add_item(tree, hf_acn_pdu, tvb, pdu_start, pdu_length, ENC_NA);
-  pdu_tree = proto_item_add_subtree(ti, ett_acn_root_pdu);
+  return pdu_start + pdu_length;
+}
+
+
+/******************************************************************************/
+/* Dissect EPT Data                                                           */
+static guint32
+dissect_ept_data(tvbuff_t *tvb, proto_tree *tree, int offset, acn_pdu_offsets *last_pdu_offsets)
+{
+  guint8           pdu_flags;
+  guint32          pdu_start;
+  guint32          pdu_length;
+  guint32          pdu_end;
+  guint32          pdu_flvh_length; /* flags, length, vector, header */
+  guint32          vector_offset;
+  guint32          data_offset;
+
+  proto_item      *ti;
+  proto_item      *ti2;
+  proto_tree      *pdu_tree;
+  proto_tree      *pdu_tree2;
 
-  /* Add flag item and tree */
-  pi = proto_tree_add_uint(pdu_tree, hf_acn_pdu_flags, tvb, pdu_start, 1, pdu_flags);
-  flag_tree = proto_item_add_subtree(pi, ett_acn_pdu_flags);
-  proto_tree_add_item(flag_tree, hf_acn_pdu_flag_l, tvb, pdu_start, 1, ENC_BIG_ENDIAN);
-  proto_tree_add_item(flag_tree, hf_acn_pdu_flag_v, tvb, pdu_start, 1, ENC_BIG_ENDIAN);
-  proto_tree_add_item(flag_tree, hf_acn_pdu_flag_h, tvb, pdu_start, 1, ENC_BIG_ENDIAN);
-  proto_tree_add_item(flag_tree, hf_acn_pdu_flag_d, tvb, pdu_start, 1, ENC_BIG_ENDIAN);
+  dissect_acn_common_base_pdu(tvb, tree, &offset, last_pdu_offsets, &pdu_flags, &pdu_start, &pdu_length, &pdu_flvh_length, &vector_offset, &ti, &pdu_tree, ett_rdmnet_ept_data_pdu, 1, 0);
 
   /* Add PDU Length item */
-  proto_tree_add_uint(pdu_tree, hf_acn_pdu_length, tvb, pdu_start, pdu_flvh_length, pdu_length);
+  proto_tree_add_uint(pdu_tree, hf_rdmnet_ept_data_pdu_length, tvb, pdu_start, pdu_flvh_length, pdu_length);
 
-  /* Set vector offset */
-  if (pdu_flags & ACN_PDU_FLAG_V) {
-    /* use new values */
-    vector_offset = offset;
-    last_pdu_offsets->vector = offset;
-    offset += 4;
-    pdu_flvh_length += 4;
+  dissect_pdu_bit_flag_v(&offset, pdu_flags, &data_offset, last_pdu_offsets, &pdu_flvh_length, 2);
+  /* offset should now be pointing to header (if one exists) */
+
+  /* esta manufacturer id + protocol id (4 bytes) */
+  ti2 = proto_tree_add_item(pdu_tree, hf_rdmnet_ept_data_vector, tvb, data_offset, 4, ENC_BIG_ENDIAN);
+  pdu_tree2 = proto_item_add_subtree(ti2, ett_rdmnet_ept_data_vector_pdu);
+  proto_tree_add_item(pdu_tree2, hf_rdmnet_ept_data_vector_manfacturer_id, tvb, 0, 2, ENC_BIG_ENDIAN);
+  proto_tree_add_item(pdu_tree2, hf_rdmnet_ept_data_vector_protocol_id, tvb, 2, 2, ENC_BIG_ENDIAN);
+  data_offset += 4;
+
+  /* opaque data */
+  pdu_end = pdu_start + pdu_length;
+  proto_tree_add_item(pdu_tree, hf_rdmnet_ept_data_opaque_data, tvb, data_offset, (pdu_end - data_offset), ENC_NA);
+
+  return pdu_start + pdu_length;
+}
+
+
+/******************************************************************************/
+/* Dissect EPT Status                                                         */
+static guint32
+dissect_ept_status(tvbuff_t *tvb, proto_tree *tree, int offset, acn_pdu_offsets *last_pdu_offsets)
+{
+  guint8           pdu_flags;
+  guint16          vector;
+  guint32          pdu_start;
+  guint32          pdu_length;
+  guint32          pdu_end;
+  guint32          pdu_flvh_length; /* flags, length, vector, header */
+  guint32          vector_offset;
+  guint32          data_offset;
+
+  proto_item      *ti;
+  proto_tree      *pdu_tree;
+
+  dissect_acn_common_base_pdu(tvb, tree, &offset, last_pdu_offsets, &pdu_flags, &pdu_start, &pdu_length, &pdu_flvh_length, &vector_offset, &ti, &pdu_tree, ett_rdmnet_ept_status_pdu, 1, 0);
+
+  /* Add PDU Length item */
+  proto_tree_add_uint(pdu_tree, hf_rdmnet_ept_status_pdu_length, tvb, pdu_start, pdu_flvh_length, pdu_length);
+
+  dissect_pdu_bit_flag_v(&offset, pdu_flags, &data_offset, last_pdu_offsets, &pdu_flvh_length, 2);
+  /* offset should now be pointing to header (if one exists) */
+
+  vector = tvb_get_ntohs(tvb, data_offset);
+  proto_tree_add_item(pdu_tree, hf_rdmnet_ept_status_vector, tvb, data_offset, 2, ENC_NA);
+  data_offset += 2;
+
+  /* process based on vector */
+  switch (vector) {
+  case RDMNET_EPT_VECTOR_UNKNOWN_CID:
+      /* unknown cid (16 bytes) */
+      proto_tree_add_item(pdu_tree, hf_rdmnet_ept_status_unknown_cid, tvb, data_offset, 16, ENC_NA);
+      data_offset += 16;
+
+      /* status string */
+      pdu_end = pdu_start + pdu_length;
+      proto_tree_add_item(pdu_tree, hf_rdmnet_ept_status_status_string, tvb, data_offset, (pdu_end - data_offset), ENC_ASCII|ENC_NA);
+      break;
+  case RDMNET_EPT_VECTOR_UNKNOWN_VECTOR:
+      /* unknown cid (4 bytes) */
+      proto_tree_add_item(pdu_tree, hf_rdmnet_ept_status_unknown_vector, tvb, data_offset, 4, ENC_NA);
+      data_offset += 4;
+
+      /* vector string */
+      pdu_end = pdu_start + pdu_length;
+      proto_tree_add_item(pdu_tree, hf_rdmnet_ept_status_vector_string, tvb, data_offset, (pdu_end - data_offset), ENC_ASCII|ENC_NA);
+      break;
+  }
+
+  return pdu_start + pdu_length;
+}
+
+
+/******************************************************************************/
+/* Dissect EPT Base PDU                                                       */
+static guint32
+dissect_acn_ept_base_pdu(tvbuff_t *tvb, proto_tree *tree, int offset, acn_pdu_offsets *last_pdu_offsets)
+{
+  guint8           pdu_flags;
+  guint32          pdu_start;
+  guint32          pdu_length;
+  guint32          pdu_flvh_length; /* flags, length, vector, header */
+  acn_pdu_offsets  pdu_offsets = {0,0,0,0,0};
+  guint32          vector_offset;
+  guint32          data_offset;
+  guint32          data_length;
+
+  proto_item      *ti;
+  proto_tree      *pdu_tree;
+
+  /* this pdu */
+  const gchar     *name;
+  guint32          vector;
+
+  dissect_acn_common_base_pdu(tvb, tree, &offset, last_pdu_offsets, &pdu_flags, &pdu_start, &pdu_length, &pdu_flvh_length, &vector_offset, &ti, &pdu_tree, ett_rdmnet_ept_base_pdu, 1, 0);
+
+  /* Add Vector item */
+  vector = tvb_get_ntohl(tvb, vector_offset);
+  proto_tree_add_item(pdu_tree, hf_rdmnet_ept_vector, tvb, vector_offset, 4, ENC_BIG_ENDIAN);
+
+  /* Add Vector item to tree */
+  name = val_to_str(vector, rdmnet_ept_vector_vals, "unknown (%d)");
+  proto_item_append_text(ti, ": %s", name);
+
+  /* NO HEADER DATA ON THESE* (at least so far) */
+
+  dissect_pdu_bit_flag_d(offset, pdu_flags, pdu_length, &data_offset, &data_length, last_pdu_offsets, pdu_flvh_length, 0);
+  data_offset += 3;
+
+  /* destination cid (16 bytes) */
+  proto_tree_add_item(pdu_tree, hf_rdmnet_ept_destination_cid, tvb, data_offset, 16, ENC_NA);
+  data_offset += 16;
+
+  /* process based on vector */
+  switch (vector) {
+  case RDMNET_EPT_VECTOR_DATA:
+      dissect_ept_data(tvb, pdu_tree, data_offset, &pdu_offsets);
+      break;
+  case RDMNET_EPT_VECTOR_STATUS:
+      dissect_ept_status(tvb, pdu_tree, data_offset, &pdu_offsets);
+      break;
+  }
+
+  return pdu_start + pdu_length;
+}
+
+/******************************************************************************/
+/* Dissect Root PDU                                                           */
+static guint32
+dissect_acn_root_pdu_header(tvbuff_t *tvb, packet_info *pinfo, proto_tree *pdu_tree, proto_item *ti, const char *title, int *offset, guint8 pdu_flags, guint32 pdu_length, guint32 *data_offset, guint32 *data_length, acn_pdu_offsets *last_pdu_offsets, gboolean add_cid_to_info, guint32 *pdu_flvh_length, gboolean is_acn)
+{
+  guint32   header_offset;
+  e_guid_t  guid;
+
+  /* Adjust header */
+  proto_item_append_text(ti, "%s", title);
+
+  dissect_pdu_bit_flag_h(offset, pdu_flags, &header_offset, last_pdu_offsets, pdu_flvh_length, 16);
+  /* offset should now be pointing to data (if one exists) */
+
+  /* get Header (CID) 16 bytes */
+  tvb_get_guid(tvb, header_offset, &guid, ENC_BIG_ENDIAN);
+  proto_item_append_text(ti, ", Src: %s", guid_to_str(wmem_packet_scope(), &guid));
+
+  if (add_cid_to_info) {
+    /* add cid to info */
+    col_add_fstr(pinfo->cinfo, COL_INFO, "CID %s", guid_to_str(wmem_packet_scope(), &guid));
+  }
+
+  if (is_acn) {
+    proto_tree_add_item(pdu_tree, hf_acn_cid, tvb, header_offset, 16, ENC_BIG_ENDIAN);
   } else {
-    /* use last values */
-    vector_offset = last_pdu_offsets->vector;
+    proto_tree_add_item(pdu_tree, hf_rdmnet_cid, tvb, header_offset, 16, ENC_BIG_ENDIAN);
   }
+  /* header_offset += 16; */
+
+  dissect_pdu_bit_flag_d(*offset, pdu_flags, pdu_length, data_offset, data_length, last_pdu_offsets, *pdu_flvh_length, 1);
+
+  return (*data_offset) + (*data_length);
+}
+
+/******************************************************************************/
+/* Dissect Root PDU                                                           */
+static guint32
+dissect_acn_root_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, int offset, acn_pdu_offsets *last_pdu_offsets, gboolean is_acn)
+{
+  /* common to all pdu */
+  guint8           pdu_flags;
+  guint32          pdu_start;
+  guint32          pdu_length;
+  guint32          pdu_flvh_length; /* flags, length, vector, header */
+  acn_pdu_offsets  pdu_offsets = {0,0,0,0,0};
+  guint32          vector_offset;
+  guint32          data_offset;
+  guint32          end_offset;
+  guint32          old_offset;
+  guint32          data_length;
+
+  proto_item      *ti;
+  proto_tree      *pdu_tree;
+
+  /* this pdu */
+  guint32          protocol_id;
+
+  begin_dissect_acn_pdu(&pdu_tree, tvb, &ti, tree, &pdu_start, &offset, &pdu_flags, &pdu_length, &pdu_flvh_length, ett_acn_root_pdu, is_acn);
+
+  /* Add PDU Length item */
+  if (is_acn) {
+    proto_tree_add_uint(pdu_tree, hf_acn_pdu_length, tvb, pdu_start, pdu_flvh_length, pdu_length);
+  } else {
+    proto_tree_add_uint(pdu_tree, hf_rdmnet_pdu_length, tvb, pdu_start, pdu_flvh_length, pdu_length);
+  }
+
+  dissect_pdu_bit_flag_v(&offset, pdu_flags, &vector_offset, last_pdu_offsets, &pdu_flvh_length, 4);
   /* offset should now be pointing to header (if one exists) */
 
   /* Get Protocol ID (vector) */
   protocol_id = tvb_get_ntohl(tvb, vector_offset);
-  proto_tree_add_uint(pdu_tree, hf_acn_protocol_id, tvb, vector_offset, 4, protocol_id);
+  if (is_acn) {
+    proto_tree_add_uint(pdu_tree, hf_acn_protocol_id, tvb, vector_offset, 4, protocol_id);
+  } else {
+    proto_tree_add_uint(pdu_tree, hf_rdmnet_protocol_id, tvb, vector_offset, 4, protocol_id);
+  }
 
   /* process based on protocol_id */
   switch (protocol_id) {
     case ACN_PROTOCOL_ID_DMX:
     case ACN_PROTOCOL_ID_DMX_2:
       if (global_acn_dmx_enable) {
-        proto_item_append_text(ti,": Root DMX");
-
-        /* Set header offset */
-        if (pdu_flags & ACN_PDU_FLAG_H) {
-          /* use new values */
-          header_offset = offset;
-          last_pdu_offsets->header = offset;
-          offset += 16;
-          pdu_flvh_length += 16;
-        } else {
-          /* use last values */
-          header_offset = last_pdu_offsets->header;
-        }
-        /* offset should now be pointing to data (if one exists) */
-
-        /* get Header (CID) 16 bytes */
-        tvb_get_guid(tvb, header_offset, &guid, ENC_BIG_ENDIAN);
-        proto_item_append_text(ti, ", Src: %s", guid_to_str(wmem_packet_scope(), &guid));
-
-        /* add cid to info */
-        col_add_fstr(pinfo->cinfo,COL_INFO, "CID %s", guid_to_str(wmem_packet_scope(), &guid));
-
-        proto_tree_add_item(pdu_tree, hf_acn_cid, tvb, header_offset, 16, ENC_BIG_ENDIAN);
-        /*header_offset += 16;*/
-
-        /* Adjust data */
-        if (pdu_flags & ACN_PDU_FLAG_D) {
-          /* use new values */
-          data_offset = offset;
-          data_length = pdu_length - pdu_flvh_length;
-          last_pdu_offsets->data = offset;
-          last_pdu_offsets->data_length = data_length;
-        } else {
-          /* use last values */
-          data_offset = last_pdu_offsets->data;
-          data_length = last_pdu_offsets->data_length;
-        }
-        end_offset = data_offset + data_length;
+        end_offset = dissect_acn_root_pdu_header(tvb, pinfo, pdu_tree, ti, ": Root DMX", &offset, pdu_flags, pdu_length, &data_offset, &data_length, last_pdu_offsets, 1, &pdu_flvh_length, 1);
 
         /* adjust for what we used */
         while (data_offset < end_offset) {
           old_offset = data_offset;
-          data_offset = dissect_acn_dmx_pdu(protocol_id, tvb, pinfo, pdu_tree, data_offset, &pdu_offsets);
+          data_offset = dissect_acn_dmx_base_pdu(protocol_id, tvb, pinfo, pdu_tree, data_offset, &pdu_offsets);
           if (data_offset == old_offset) break;
         }
       }
       break;
     case ACN_PROTOCOL_ID_SDT:
-      /* Adjust header */
-      proto_item_append_text(ti,": Root SDT");
-
-      /* Set header offset */
-      if (pdu_flags & ACN_PDU_FLAG_H) {
-        /* use new values */
-        header_offset = offset;
-        last_pdu_offsets->header = offset;
-        offset += 16;
-        pdu_flvh_length += 16;
-      } else {
-        /* use last values */
-        header_offset = last_pdu_offsets->header;
+      end_offset = dissect_acn_root_pdu_header(tvb, pinfo, pdu_tree, ti, ": Root SDT", &offset, pdu_flags, pdu_length, &data_offset, &data_length, last_pdu_offsets, 0, &pdu_flvh_length, 1);
+
+      /* adjust for what we used */
+      while (data_offset < end_offset) {
+        old_offset = data_offset;
+        data_offset = dissect_acn_sdt_base_pdu(tvb, pinfo, pdu_tree, data_offset, &pdu_offsets);
+        if (data_offset == old_offset) break;
       }
-      /* offset should now be pointing to data (if one exists) */
-
-      /* get Header (CID) 16 bytes */
-      tvb_get_guid(tvb, header_offset, &guid, ENC_BIG_ENDIAN);
-      proto_item_append_text(ti, ", Src: %s", guid_to_str(wmem_packet_scope(), &guid));
-
-      proto_tree_add_item(pdu_tree, hf_acn_cid, tvb, header_offset, 16, ENC_BIG_ENDIAN);
-      /*header_offset += 16;*/
-
-      /* Adjust data */
-      if (pdu_flags & ACN_PDU_FLAG_D) {
-        /* use new values */
-        data_offset = offset;
-        data_length = pdu_length - pdu_flvh_length;
-        last_pdu_offsets->data = offset;
-        last_pdu_offsets->data_length = data_length;
-      } else {
-        /* use last values */
-        data_offset = last_pdu_offsets->data;
-        data_length = last_pdu_offsets->data_length;
+      break;
+    case ACN_PROTOCOL_ID_RPT:
+      end_offset = dissect_acn_root_pdu_header(tvb, pinfo, pdu_tree, ti, ": Root RPT", &offset, pdu_flags, pdu_length, &data_offset, &data_length, last_pdu_offsets, 0, &pdu_flvh_length, 0);
+
+      /* adjust for what we used */
+      while (data_offset < end_offset) {
+        old_offset = data_offset;
+        data_offset = dissect_acn_rpt_base_pdu(tvb, pinfo, pdu_tree, data_offset, &pdu_offsets);
+        if (data_offset == old_offset) break;
+      }
+      break;
+    case ACN_PROTOCOL_ID_BROKER:
+      end_offset = dissect_acn_root_pdu_header(tvb, pinfo, pdu_tree, ti, ": Root Broker", &offset, pdu_flags, pdu_length, &data_offset, &data_length, last_pdu_offsets, 0, &pdu_flvh_length, 0);
+
+      /* adjust for what we used */
+      while (data_offset < end_offset) {
+        old_offset = data_offset;
+        data_offset = dissect_acn_broker_base_pdu(tvb, pdu_tree, data_offset, &pdu_offsets);
+        if (data_offset == old_offset) break;
       }
-      end_offset = data_offset + data_length;
+      break;
+    case ACN_PROTOCOL_ID_LLRP:
+      end_offset = dissect_acn_root_pdu_header(tvb, pinfo, pdu_tree, ti, ": Root LLRP", &offset, pdu_flags, pdu_length, &data_offset, &data_length, last_pdu_offsets, 0, &pdu_flvh_length, 0);
 
       /* adjust for what we used */
       while (data_offset < end_offset) {
         old_offset = data_offset;
-        data_offset = dissect_acn_sdt_base_pdu(tvb, pinfo, pdu_tree, data_offset, &pdu_offsets);
+        data_offset = dissect_acn_llrp_base_pdu(tvb, pinfo, pdu_tree, data_offset, &pdu_offsets);
+        if (data_offset == old_offset) break;
+      }
+      break;
+    case ACN_PROTOCOL_ID_EPT:
+      end_offset = dissect_acn_root_pdu_header(tvb, pinfo, pdu_tree, ti, ": Root EPT", &offset, pdu_flags, pdu_length, &data_offset, &data_length, last_pdu_offsets, 0, &pdu_flvh_length, 0);
+
+      /* adjust for what we used */
+      while (data_offset < end_offset) {
+        old_offset = data_offset;
+        data_offset = dissect_acn_ept_base_pdu(tvb, pdu_tree, data_offset, &pdu_offsets);
         if (data_offset == old_offset) break;
       }
       break;
@@ -5480,8 +7108,7 @@ dissect_acn(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
 
   /* Set the protocol column */
   col_set_str(pinfo->cinfo, COL_PROTOCOL, "ACN");
-
-  col_add_fstr(pinfo->cinfo,COL_INFO, "ACN [Src Port: %d, Dst Port: %d]", pinfo->srcport, pinfo->destport );
+  col_add_fstr(pinfo->cinfo, COL_INFO, "ACN [Src Port: %d, Dst Port: %d]", pinfo->srcport, pinfo->destport );
 
   ti = proto_tree_add_item(tree, proto_acn, tvb, 0, -1, ENC_NA);
   acn_tree = proto_item_add_subtree(ti, ett_acn);
@@ -5498,13 +7125,72 @@ dissect_acn(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
   end_offset = data_offset + tvb_reported_length_remaining(tvb, data_offset);
   while (data_offset < end_offset) {
     old_offset = data_offset;
-    data_offset = dissect_acn_root_pdu(tvb, pinfo, acn_tree, data_offset, &pdu_offsets);
+    data_offset = dissect_acn_root_pdu(tvb, pinfo, acn_tree, data_offset, &pdu_offsets, 1);
     if (data_offset == old_offset) break;
   }
   return tvb_reported_length(tvb);
 }
 
 /******************************************************************************/
+/* Dissect RDMnet                                                             */
+static int
+dissect_rdmnet(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint32 data_offset, gboolean is_udp)
+{
+  proto_item      *ti;
+  proto_tree      *rdmnet_tree;
+  /* guint32          data_offset = 0; */
+  guint32          old_offset;
+  guint32          end_offset;
+  guint32          pdu_length;
+  acn_pdu_offsets  pdu_offsets = {0,0,0,0,0};
+
+  /* Set the protocol column */
+  col_set_str(pinfo->cinfo, COL_PROTOCOL, "RDMnet");
+  col_add_fstr(pinfo->cinfo, COL_INFO, "RDMnet [Src Port: %d, Dst Port: %d]", pinfo->srcport, pinfo->destport );
+
+  if (is_udp) {
+    ti = proto_tree_add_item(tree, proto_rdmnet, tvb, data_offset, -1, ENC_NA);
+  } else {
+    pdu_length = tvb_get_ntohl(tvb, 12) + 16;
+    ti = proto_tree_add_item(tree, proto_rdmnet, tvb, data_offset, pdu_length, ENC_NA);
+  }
+  rdmnet_tree = proto_item_add_subtree(ti, ett_rdmnet);
+
+  if (is_udp) {
+    /* UDP only: preamble and postamble */
+    proto_tree_add_item(rdmnet_tree, hf_rdmnet_preamble_size, tvb, data_offset, 2, ENC_BIG_ENDIAN);
+    data_offset += 2;
+    proto_tree_add_item(rdmnet_tree, hf_rdmnet_postamble_size, tvb, data_offset, 2, ENC_BIG_ENDIAN);
+    data_offset += 2;
+  }
+  /* add ACN Packet ID */
+  proto_tree_add_item(rdmnet_tree, hf_rdmnet_packet_identifier, tvb, data_offset, 12, ENC_UTF_8 | ENC_NA);
+  data_offset += 12;
+
+  pdu_length = 0;
+  if (!is_udp) {
+    /* TCP only: data length (may be less than packet length) */
+    proto_tree_add_item(rdmnet_tree, hf_rdmnet_tcp_length, tvb, data_offset, 4, ENC_BIG_ENDIAN);
+    pdu_length = tvb_get_ntohl(tvb, data_offset);
+    data_offset += 4;
+  }
+
+  /* one past the last byte */
+  if (is_udp) {
+    end_offset = data_offset + tvb_reported_length_remaining(tvb, data_offset);
+  } else {
+    end_offset = data_offset + pdu_length;
+  }
+  while (data_offset < end_offset) {
+    old_offset = data_offset;
+    data_offset = dissect_acn_root_pdu(tvb, pinfo, rdmnet_tree, data_offset, &pdu_offsets, 0);
+    if (data_offset == old_offset) break;
+  }
+
+  return end_offset;
+}
+
+/******************************************************************************/
 /* Register protocol                                                          */
 void
 proto_register_acn(void)
@@ -5839,7 +7525,7 @@ proto_register_acn(void)
         FT_UINT16, BASE_DEC_HEX, NULL, 0x0,
         NULL, HFILL }
     },
-    /* MemberID */
+    /* Member ID */
     { &hf_acn_member_id,
       { "Member ID", "acn.member_id",
         FT_UINT16, BASE_DEC_HEX, NULL, 0x0,
@@ -5875,7 +7561,7 @@ proto_register_acn(void)
         FT_UINT32, BASE_DEC_HEX, NULL, 0x0,
         NULL, HFILL }
     },
-    /* Preamble Sizet */
+    /* Preamble Size */
     { &hf_acn_preamble_size,
       { "Size of preamble", "acn.preamble_size",
         FT_UINT16, BASE_DEC, NULL, 0x0,
@@ -5975,7 +7661,7 @@ proto_register_acn(void)
     },
     /* SDT Vector */
     { &hf_acn_sdt_vector,
-      { "STD Vector", "acn.sdt_vector",
+      { "SDT Vector", "acn.sdt_vector",
         FT_UINT8, BASE_DEC, VALS(acn_sdt_vector_vals), 0x0,
         NULL, HFILL }
     },
@@ -6275,6 +7961,559 @@ proto_register_acn(void)
     },
   };
 
+  static hf_register_info rdmnet_hf[] = {
+    /* CID */
+    { &hf_rdmnet_cid,
+      { "CID", "rdmnet.cid",
+        FT_GUID, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }
+    },
+    /* Packet Identifier */
+    { &hf_rdmnet_packet_identifier,
+      { "Packet Identifier", "rdmnet.packet_identifier",
+        FT_STRING, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }
+    },
+    /* PDU */
+    { &hf_rdmnet_pdu,
+      { "PDU", "rdmnet.pdu",
+        FT_NONE, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }
+    },
+    /* PDU flags*/
+    { &hf_rdmnet_pdu_flags,
+      { "Flags", "rdmnet.pdu.flags",
+        FT_UINT8, BASE_HEX, NULL, 0x0,
+        "PDU Flags", HFILL }
+    },
+    { &hf_rdmnet_pdu_flag_d,
+      { "Data", "rdmnet.pdu.flag_d",
+        FT_BOOLEAN, 8, NULL, ACN_PDU_FLAG_D,
+        "Data flag", HFILL }
+    },
+    { &hf_rdmnet_pdu_flag_h,
+      { "Header", "rdmnet.pdu.flag_h",
+        FT_BOOLEAN, 8, NULL, ACN_PDU_FLAG_H,
+        "Header flag", HFILL }
+    },
+    { &hf_rdmnet_pdu_flag_l,
+      { "Length", "rdmnet.pdu.flag_l",
+        FT_BOOLEAN, 8, NULL, ACN_PDU_FLAG_L,
+        "Length flag", HFILL }
+    },
+    { &hf_rdmnet_pdu_flag_v,
+      { "Vector", "rdmnet.pdu.flag_v",
+        FT_BOOLEAN, 8, NULL, ACN_PDU_FLAG_V,
+        "Vector flag", HFILL }
+    },
+    /* PDU Length */
+    { &hf_rdmnet_pdu_length,
+      { "Length", "rdmnet.pdu.length",
+        FT_UINT32, BASE_DEC, NULL, 0x0,
+        "PDU Length", HFILL }
+    },
+    /* Postamble Size */
+    { &hf_rdmnet_postamble_size,
+      { "Size of postamble", "rdmnet.postamble_size",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        "Postamble size in bytes", HFILL }
+    },
+    /* Preamble Size */
+    { &hf_rdmnet_preamble_size,
+      { "Size of preamble", "rdmnet.preamble_size",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        "Preamble size in bytes", HFILL }
+    },
+    /* Protocol ID */
+    { &hf_rdmnet_protocol_id,
+      { "Protocol ID", "rdmnet.protocol_id",
+        FT_UINT32, BASE_DEC, VALS(acn_protocol_id_vals), 0x0,
+        NULL, HFILL }
+    },
+    /* Postamble Size */
+    { &hf_rdmnet_tcp_length,
+      { "Data length", "rdmnet.tcp_length",
+        FT_UINT32, BASE_DEC, NULL, 0x0,
+        "TCP data size in bytes", HFILL }
+    },
+    /* LLRP Vector */
+    { &hf_rdmnet_llrp_vector,
+      { "LLRP Vector", "rdmnet.llrp_vector",
+        FT_UINT32, BASE_DEC, VALS(rdmnet_llrp_vector_vals), 0x0,
+        NULL, HFILL }
+    },
+    /* LLRP Destination CID */
+    { &hf_rdmnet_llrp_destination_cid,
+      { "CID", "rdmnet.llrp.destination_cid",
+        FT_GUID, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }
+    },
+    /* LLRP Transaction Number */
+    { &hf_rdmnet_llrp_transaction_number,
+      { "Transaction Number", "rdmnet.llrp.transaction_number",
+        FT_UINT32, BASE_DEC_HEX, NULL, 0x0,
+        NULL, HFILL }
+    },
+    /* LLRP Probe Request PDU Length */
+    { &hf_rdmnet_llrp_probe_request_pdu_length,
+      { "Length", "rdmnet.llrp.probe_request.pdu.length",
+        FT_UINT24, BASE_DEC, NULL, 0x0,
+        "PDU Length", HFILL }
+    },
+    /* LLRP Probe Request Vector */
+    { &hf_rdmnet_llrp_probe_request_vector,
+      { "LLRP Vector", "rdmnet.llrp.probe_request_vector",
+        FT_UINT8, BASE_DEC, VALS(rdmnet_llrp_probe_request_vals), 0x0,
+        NULL, HFILL }
+    },
+    /* LLRP Probe Request Lower UID */
+    { &hf_rdmnet_llrp_probe_request_lower_uid,
+      { "Lower UID", "rdmnet.llrp.probe_request.lower_uid",
+        FT_BYTES, SEP_SPACE, NULL, 0x0,
+        NULL, HFILL }
+    },
+    /* LLRP Probe Request Upper UID */
+    { &hf_rdmnet_llrp_probe_request_upper_uid,
+      { "Upper UID", "rdmnet.llrp.probe_request.upper_uid",
+        FT_BYTES, SEP_SPACE, NULL, 0x0,
+        NULL, HFILL }
+    },
+    /* LLRP Probe Request Filter */
+    { &hf_rdmnet_llrp_probe_request_filter,
+      { "Filter", "rdmnet.llrp.probe_request.filter",
+        FT_UINT16, BASE_HEX, NULL, 0x0,
+        NULL, HFILL }
+    },
+    { &hf_rdmnet_llrp_probe_request_filter_brokers_only,
+      { "Brokers Only", "rdmnet.llrp.probe_request.filter_brokers_only",
+        FT_BOOLEAN, 8, NULL, RDMNET_LLRP_VECTOR_PROBE_REQUEST_BROKERS_ONLY,
+        "Brokers only flag", HFILL }
+    },
+    { &hf_rdmnet_llrp_probe_request_filter_client_tcp_inactive,
+      { "Client TCP Inactive", "rdmnet.llrp.probe_request.filter_client_tcp_inactive",
+        FT_BOOLEAN, 8, NULL, RDMNET_LLRP_VECTOR_PROBE_REQUEST_CLIENT_TCP_INACTIVE,
+        "Client TCP inactive flag", HFILL }
+    },
+    /* LLRP Probe Request Unknown UID */
+    { &hf_rdmnet_llrp_probe_request_known_uid,
+      { "Known UID", "rdmnet.llrp.probe_request.known_uid",
+        FT_BYTES, SEP_SPACE, NULL, 0x0,
+        NULL, HFILL }
+    },
+    /* LLRP Probe Reply Vector */
+    { &hf_rdmnet_llrp_probe_reply_vector,
+      { "LLRP Vector", "rdmnet.llrp.probe_reply_vector",
+        FT_UINT8, BASE_DEC, VALS(rdmnet_llrp_probe_reply_vals), 0x0,
+        NULL, HFILL }
+    },
+    /* LLRP Probe Reply UID */
+    { &hf_rdmnet_llrp_probe_reply_uid,
+      { "UID", "rdmnet.llrp.probe_reply.uid",
+        FT_BYTES, SEP_SPACE, NULL, 0x0,
+        NULL, HFILL }
+    },
+    /* LLRP Probe Reply Hardware Address */
+    { &hf_rdmnet_llrp_probe_reply_hardware_address,
+      { "Hardware Address", "rdmnet.llrp.probe_reply.hardware_address",
+        FT_BYTES, SEP_COLON, NULL, 0x0,
+        NULL, HFILL }
+    },
+    /* LLRP Probe Reply Component Type */
+    { &hf_rdmnet_llrp_probe_reply_component_type,
+      { "Component Type", "rdmnet.llrp.probe_reply.component_type",
+        FT_UINT8, BASE_DEC, VALS(rdmnet_llrp_probe_reply_component_type_vals), 0x0,
+        NULL, HFILL }
+    },
+    /* LLRP RDM Command Start Code */
+    { &hf_rdmnet_llrp_rdm_command_start_code,
+      { "RDM Command", "rdmnet.llrp.rdm_command.start_code",
+        FT_UINT8, BASE_DEC, VALS(rdmnet_llrp_rdm_command_start_code_vals), 0x0,
+        NULL, HFILL }
+    },
+    /* RPT Vector */
+    { &hf_rdmnet_rpt_vector,
+      { "RPT Vector", "rdmnet.rpt_vector",
+        FT_UINT8, BASE_DEC, VALS(rdmnet_rpt_vector_vals), 0x0,
+        NULL, HFILL }
+    },
+    /* RPT Source UID */
+    { &hf_rdmnet_rpt_source_uid,
+      { "Source UID", "rdmnet.rpt.source_uid",
+        FT_BYTES, SEP_SPACE, NULL, 0x0,
+        NULL, HFILL }
+    },
+    /* RPT Source Endpoint ID */
+    { &hf_rdmnet_rpt_source_endpoint_id,
+      { "Source Endpoint ID", "rdmnet.rpt.source_endpoint_id",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }
+    },
+    /* RPT Destination UID */
+    { &hf_rdmnet_rpt_destination_uid,
+      { "Destination UID", "rdmnet.rpt.destination_uid",
+        FT_BYTES, SEP_SPACE, NULL, 0x0,
+        NULL, HFILL }
+    },
+    /* RPT Destination Endpoint ID */
+    { &hf_rdmnet_rpt_destination_endpoint_id,
+      { "Destination Endpoint ID", "rdmnet.rpt.destination_endpoint_id",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }
+    },
+    /* RPT Sequence Number */
+    { &hf_rdmnet_rpt_sequence_number,
+      { "Sequence Number", "rdmnet.rpt.sequence_number",
+        FT_UINT32, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }
+    },
+    /* RPT Reserved */
+    { &hf_rdmnet_rpt_reserved,
+      { "Reserved", "rdmnet.rpt.reserved",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }
+    },
+    /* RPT Request Vector */
+    { &hf_rdmnet_rpt_request_vector,
+      { "RPT Request Vector", "rdmnet.rpt.request_vector",
+        FT_UINT32, BASE_DEC, VALS(rdmnet_rpt_request_vals), 0x0,
+        NULL, HFILL }
+    },
+    /* RPT Request RDM Command */
+    { &hf_rdmnet_rpt_request_rdm_command,
+      { "RDM Command", "rdmnet.rpt.request.rdm_command",
+        FT_UINT8, BASE_DEC, VALS(rdmnet_rpt_request_rdm_command_start_code_vals), 0x0,
+        NULL, HFILL }
+    },
+    /* RPT Status Vector */
+    { &hf_rdmnet_rpt_status_vector,
+      { "Status Vector", "rdmnet.rpt.status.vector",
+        FT_UINT16, BASE_DEC, VALS(rdmnet_rpt_status_vector_vals), 0x0,
+        NULL, HFILL }
+    },
+    /* RPT Status Unknown RPT UID String */
+    { &hf_rdmnet_rpt_status_unknown_rpt_uid_string,
+      { "Status", "rdmnet.rpt.status.unknown_rpt_uid_string",
+        FT_STRING, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }
+    },
+    /* RPT Status RDM Timeout String */
+    { &hf_rdmnet_rpt_status_rdm_timeout_string,
+      { "Status", "rdmnet.rpt.status.rdm_timeout_string",
+        FT_STRING, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }
+    },
+    /* RPT Status Invalid RDM Response String */
+    { &hf_rdmnet_rpt_status_rdm_invalid_response_string,
+      { "Status", "rdmnet.rpt.status.invalid_rdm_response_string",
+        FT_STRING, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }
+    },
+    /* RPT Status Unknown RDM UID String */
+    { &hf_rdmnet_rpt_status_unknown_rdm_uid_string,
+      { "Status", "rdmnet.rpt.status.unknown_rdm_uid_string",
+        FT_STRING, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }
+    },
+    /* RPT Status Unknown Endpoint String */
+    { &hf_rdmnet_rpt_status_unknown_endpoint_string,
+      { "Status", "rdmnet.rpt.status.unknown_endpoint_string",
+        FT_STRING, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }
+    },
+    /* RPT Status Broadcast Complete String */
+    { &hf_rdmnet_rpt_status_broadcast_complete_string,
+      { "Status", "rdmnet.rpt.status.broadcast_complete_string",
+        FT_STRING, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }
+    },
+    /* RPT Status Unknown Vector String */
+    { &hf_rdmnet_rpt_status_unknown_vector_string,
+      { "Status", "rdmnet.rpt.status.unknown_vector_string",
+        FT_STRING, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }
+    },
+    /* RPT Notification Vector */
+    { &hf_rdmnet_rpt_notification_vector,
+      { "RPT Notification Vector", "rdmnet.rpt.notification_vector",
+        FT_UINT32, BASE_DEC, VALS(rdmnet_rpt_notification_vals), 0x0,
+        NULL, HFILL }
+    },
+    /* RPT Notification RDM Command */
+    { &hf_rdmnet_rpt_notification_rdm_command,
+      { "RDM Command", "rdmnet.rpt.notification.rdm_command",
+        FT_UINT8, BASE_DEC, VALS(rdmnet_rpt_request_rdm_command_start_code_vals), 0x0,
+        NULL, HFILL }
+    },
+    /* Broker Vector */
+    { &hf_rdmnet_broker_vector,
+      { "Broker Vector", "rdmnet.broker_vector",
+        FT_UINT8, BASE_DEC, VALS(rdmnet_broker_vector_vals), 0x0,
+        NULL, HFILL }
+    },
+    /* Broker Client Protocol Vector */
+    { &hf_rdmnet_broker_client_protocol_vector,
+      { "Client Protocol", "rdmnet.broker_client_protocol_vector",
+        FT_UINT32, BASE_DEC, VALS(broker_client_protocol_vals), 0x0,
+        NULL, HFILL }
+    },
+    /* Broker Client Protocol CID */
+    { &hf_rdmnet_broker_client_protocol_cid,
+      { "Client CID", "rdmnet.broker_client_cid",
+        FT_BYTES, SEP_SPACE, NULL, 0x0,
+        NULL, HFILL }
+    },
+    /* Broker Client RPT Client UID */
+    { &hf_rdmnet_broker_client_rpt_client_uid,
+      { "Client UID", "rdmnet.broker_client_rpt_client_uid",
+        FT_BYTES, SEP_SPACE, NULL, 0x0,
+        NULL, HFILL }
+    },
+    /* Broker Client RPT Client Type */
+    { &hf_rdmnet_broker_client_rpt_client_type,
+      { "RPT client type", "rdmnet.broker_client_rpt_client_type",
+        FT_UINT8, BASE_DEC, VALS(broker_client_rpt_client_type_vals), 0x0,
+        NULL, HFILL }
+    },
+    /* Broker Client RPT Binding CID */
+    { &hf_rdmnet_broker_client_rpt_binding_cid,
+      { "Binding CID", "rdmnet.broker_client_rpt_binding_cid",
+        FT_BYTES, SEP_SPACE, NULL, 0x0,
+        NULL, HFILL }
+    },
+    /* Broker Client EPT Protocol Vector */
+    { &hf_rdmnet_broker_client_ept_protocol_vector,
+      { "Protocol Vector", "rdmnet.broker_client_ept_vector",
+        FT_BYTES, SEP_SPACE, NULL, 0x0,
+        NULL, HFILL }
+    },
+    /* Broker Client EPT Manufacturer ID */
+    { &hf_rdmnet_broker_client_ept_protocol_manufacturer_id,
+      { "Manufacturer ID", "rdmnet.broker_client_ept_manufacturer_id",
+        FT_UINT16, BASE_HEX, NULL, 0x0,
+        NULL, HFILL }
+    },
+    /* Broker Client EPT Protocol ID */
+    { &hf_rdmnet_broker_client_ept_protocol_protocol_id,
+      { "Protocol ID", "rdmnet.broker_client_ept_protocol_id",
+        FT_UINT16, BASE_HEX, NULL, 0x0,
+        NULL, HFILL }
+    },
+    /* Broker Client EPT Protocol String */
+    { &hf_rdmnet_broker_client_ept_protocol_string,
+      { "Protocol String", "rdmnet.broker_client_ept_protocol_string",
+        FT_STRING, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }
+    },
+    /* Broker Connect Scope */
+    { &hf_rdmnet_broker_connect_client_scope,
+      { "Client Scope", "rdmnet.broker.connect.client_scope",
+        FT_STRING, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }
+    },
+    /* Broker Connect E1.33 Version */
+    { &hf_rdmnet_broker_connect_e133_version,
+      { "E1.33 Version", "rdmnet.broker.connect.e133_version",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }
+    },
+    /* Broker Connect Search Domain */
+    { &hf_rdmnet_broker_connect_search_domain,
+      { "Search Domain", "rdmnet.broker.connect.search_domain",
+        FT_STRING, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }
+    },
+    /* Broker Connect Connection Flags */
+    { &hf_rdmnet_broker_connect_connection_flags,
+      { "Flags", "rdmnet.broker.connect.flags",
+        FT_UINT8, BASE_HEX, NULL, 0x0,
+        "Connection Flags", HFILL }
+    },
+    { &hf_rdmnet_broker_connect_connection_flags_incremental_updates,
+      { "Incremental Updates", "rdmnet.broker.connect.flags_incremental_updates",
+        FT_BOOLEAN, 8, NULL, RDMNET_BROKER_VECTOR_CONNECT_INCREMENTAL_UPDATES,
+        "Incremental updates flag", HFILL }
+    },
+    /* Broker Connect Reply Connection Code */
+    { &hf_rdmnet_broker_connect_reply_connection_code,
+      { "Connection Code", "rdmnet.broker.connect_reply.connection_code",
+        FT_UINT16, BASE_DEC, VALS(rdmnet_broker_status_code_vals), 0x0,
+        NULL, HFILL }
+    },
+    /* Broker Connect Reply E1.33 Version */
+    { &hf_rdmnet_broker_connect_reply_e133_version,
+      { "E1.33 Version", "rdmnet.broker.connect_reply.e133_version",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }
+    },
+    /* Broker Connect Reply Broker UID */
+    { &hf_rdmnet_broker_connect_reply_broker_uid,
+      { "Broker UID", "rdmnet.broker.connect_reply.broker_uid",
+        FT_BYTES, SEP_SPACE, NULL, 0x0,
+        NULL, HFILL }
+    },
+    /* Broker Connect Reply Client UID */
+    { &hf_rdmnet_broker_connect_reply_client_uid,
+      { "Client UID", "rdmnet.broker.connect_reply.client_uid",
+        FT_BYTES, SEP_SPACE, NULL, 0x0,
+        NULL, HFILL }
+    },
+    /* Broker Client Entry Update Connection Flags */
+    { &hf_rdmnet_broker_client_entry_update_connection_flags,
+      { "Flags", "rdmnet.broker.client_entry_update.flags",
+        FT_UINT8, BASE_HEX, NULL, 0x0,
+        "Connection Flags", HFILL }
+    },
+    { &hf_rdmnet_broker_client_entry_update_connection_flags_incremental_updates,
+      { "Incremental Updates", "rdmnet.broker.client_entry_update.flags_incremental_updates",
+        FT_BOOLEAN, 8, NULL, RDMNET_BROKER_VECTOR_CONNECT_INCREMENTAL_UPDATES,
+        "Incremental updates flag", HFILL }
+    },
+    /* Broker Redirect IPv4 Address */
+    { &hf_rdmnet_broker_redirect_ipv4_address,
+      { "IPv4 Address", "rdmnet.broker.redirect_ipv4.ipv4_address",
+        FT_IPv4, BASE_NONE, NULL, 0x0,
+        "Redirect IPv4 address", HFILL }
+    },
+    /* Broker Redirect IPv4 TCP Port */
+    { &hf_rdmnet_broker_redirect_ipv4_tcp_port,
+      { "IPv4 TCP Port", "rdmnet.broker.redirect_ipv4.tcp_port",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        "Redirect IPv4 TCP port", HFILL }
+    },
+    /* Broker Redirect IPv6 Address */
+    { &hf_rdmnet_broker_redirect_ipv6_address,
+      { "IPv6 Address", "rdmnet.broker.redirect_ipv6.ipv4_address",
+        FT_IPv6, BASE_NONE, NULL, 0x0,
+        "Redirect IPv6 address", HFILL }
+    },
+    /* Broker Redirect IPv6 TCP Port */
+    { &hf_rdmnet_broker_redirect_ipv6_tcp_port,
+      { "TCP Port", "rdmnet.broker.redirect_ipv6.tcp_port",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        "Redirect IPv6 TCP port", HFILL }
+    },
+    /* Broker Disconnect Reason */
+    { &hf_rdmnet_broker_disconnect_reason,
+      { "Reason", "rdmnet.broker.disconnect.reason",
+        FT_UINT16, BASE_DEC, VALS(rdmnet_broker_disconnect_reason_vals), 0x0,
+        "Disconnect reason", HFILL }
+    },
+    /* Broker Dynamic UID Request */
+    { &hf_rdmnet_broker_dynamic_uid_request,
+      { "Dynamic UID Request", "rdmnet.broker.request_dynamic_uids.dynamic_uid_request",
+        FT_BYTES, SEP_DOT, NULL, 0x0,
+        NULL, HFILL }
+    },
+    /* Broker RID */
+    { &hf_rdmnet_broker_rid,
+      { "RID", "rdmnet.broker.request_dynamic_uids.rid",
+        FT_BYTES, SEP_DOT, NULL, 0x0,
+        NULL, HFILL }
+    },
+    /* Broker Assigned Dynamic UID */
+    { &hf_rdmnet_broker_assigned_dynamic_uid,
+      { "Dynamic UID Request", "rdmnet.broker.assigned_dynamic_uids.dynamic_uid",
+        FT_BYTES, SEP_DOT, NULL, 0x0,
+        NULL, HFILL }
+    },
+    /* Broker Assigned RID */
+    { &hf_rdmnet_broker_assigned_rid,
+      { "RID", "rdmnet.broker.assigned_dynamic_uids.rid",
+        FT_BYTES, SEP_DOT, NULL, 0x0,
+        NULL, HFILL }
+    },
+    /* Broker_Assigned Status Code */
+    { &hf_rdmnet_broker_assigned_status_code,
+      { "Status Code", "rdmnet.broker.assigned_dynamic_uids.status_code",
+        FT_UINT16, BASE_DEC, VALS(dynamic_uid_mapping_status_code_vals), 0x0,
+        NULL, HFILL }
+    },
+    /* Broker Fetch Dynamic UID */
+    { &hf_rdmnet_broker_fetch_dynamic_uid,
+      { "Dynamic UID", "rdmnet.broker.fetch_dynamic_uids.dynamic_uid",
+        FT_BYTES, SEP_DOT, NULL, 0x0,
+        NULL, HFILL }
+    },
+    /* EPT Vector */
+    { &hf_rdmnet_ept_vector,
+      { "EPT Vector", "rdmnet.ept_vector",
+        FT_UINT8, BASE_DEC, VALS(rdmnet_ept_vector_vals), 0x0,
+        NULL, HFILL }
+    },
+    /* EPT Destination CID */
+    { &hf_rdmnet_ept_destination_cid,
+      { "Destination CID", "rdmnet.ept.destination_cid",
+        FT_BYTES, SEP_SPACE, NULL, 0x0,
+        NULL, HFILL }
+    },
+    /* EPT Data PDU Length */
+    { &hf_rdmnet_ept_data_pdu_length,
+      { "Length", "rdmnet.ept.data.pdu.length",
+        FT_UINT24, BASE_DEC, NULL, 0x0,
+        "PDU Length", HFILL }
+    },
+    /* EPT Data Vector */
+    { &hf_rdmnet_ept_data_vector,
+      { "Vector", "rdmnet.ept.data.vector",
+        FT_UINT32, BASE_HEX, NULL, 0x0,
+        "Data vector", HFILL }
+    },
+    /* EPT Data Vector Manfacturer ID */
+    { &hf_rdmnet_ept_data_vector_manfacturer_id,
+      { "Manfac. ID", "rdmnet.ept.data.vector.manfacturer_id",
+        FT_UINT16, BASE_HEX, NULL, 0x0,
+        "Manfacturer id", HFILL }
+    },
+    /* EPT Data Vector Protocol ID */
+    { &hf_rdmnet_ept_data_vector_protocol_id,
+      { "Protocol", "rdmnet.ept.data.vector.protocol_id",
+        FT_UINT16, BASE_HEX, NULL, 0x0,
+        "Protocol id", HFILL }
+    },
+    /* EPT Data Opaque Data */
+    { &hf_rdmnet_ept_data_opaque_data,
+      { "Data", "rdmnet.ept.data.opaque_data",
+        FT_BYTES, SEP_SPACE, NULL, 0x0,
+        NULL, HFILL }
+    },
+    /* EPT Status PDU Length */
+    { &hf_rdmnet_ept_status_pdu_length,
+      { "Length", "rdmnet.ept.status.pdu.length",
+        FT_UINT24, BASE_DEC, NULL, 0x0,
+        "PDU Length", HFILL }
+    },
+    /* EPT Status Unknown CID */
+    { &hf_rdmnet_ept_status_unknown_cid,
+      { "Unknown CID", "rdmnet.ept.status.unknown_cid",
+        FT_BYTES, SEP_SPACE, NULL, 0x0,
+        NULL, HFILL }
+    },
+    /* EPT Status Status String */
+    { &hf_rdmnet_ept_status_status_string,
+      { "Status String", "rdmnet.ept.status.status_string",
+        FT_STRING, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }
+    },
+    /* EPT Status Vector */
+    { &hf_rdmnet_ept_status_vector,
+      { "Unknown Vector", "rdmnet.ept.status.vector",
+        FT_BYTES, SEP_SPACE, NULL, 0x0,
+        NULL, HFILL }
+    },
+    /* EPT Status Unknown Vector */
+    { &hf_rdmnet_ept_status_unknown_vector,
+      { "Unknown Vector", "rdmnet.ept.status.unknown_vector",
+        FT_BYTES, SEP_SPACE, NULL, 0x0,
+        NULL, HFILL }
+    },
+    /* EPT Status Vector String */
+    { &hf_rdmnet_ept_status_vector_string,
+      { "Vector String", "rdmnet.ept.status.vector_string",
+        FT_STRING, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }
+    }
+  };
+
   /* Setup protocol subtree array */
   static gint *ett[] = {
     &ett_acn,
@@ -6301,6 +8540,30 @@ proto_register_acn(void)
     &ett_magic
   };
 
+  /* Setup protocol subtree array */
+  static gint *rdmnet_ett[] = {
+    &ett_rdmnet,
+    &ett_rdmnet_pdu_flags,
+    &ett_rdmnet_llrp_base_pdu,
+    &ett_rdmnet_llrp_probe_request_pdu,
+    &ett_rdmnet_llrp_probe_request_filter_flags,
+    &ett_rdmnet_llrp_probe_reply_pdu,
+    &ett_rdmnet_llrp_rdm_command_pdu,
+    &ett_rdmnet_rpt_base_pdu,
+    &ett_rdmnet_rpt_request_pdu,
+    &ett_rdmnet_rpt_status_pdu,
+    &ett_rdmnet_rpt_notification_pdu,
+    &ett_rdmnet_broker_base_pdu,
+    &ett_rdmnet_broker_client_entry_pdu,
+    &ett_rdmnet_broker_client_entry_manufacturer_protocol_ids,
+    &ett_rdmnet_broker_connect_connection_flags,
+    &ett_rdmnet_broker_client_entry_update_connection_flags,
+    &ett_rdmnet_ept_base_pdu,
+    &ett_rdmnet_ept_data_pdu,
+    &ett_rdmnet_ept_data_vector_pdu,
+    &ett_rdmnet_ept_status_pdu
+  };
+
   static ei_register_info ei[] = {
     { &ei_magic_reply_invalid_type, { "magic.reply.invalid_type", PI_PROTOCOL, PI_WARN, "Invalid type", EXPFILL }},
   };
@@ -6315,11 +8578,17 @@ proto_register_acn(void)
     );
 
   proto_magic = proto_register_protocol(
-    "Magic",                             /* name */
+    "Magic Bullet",                      /* name */
     "MAGIC",                             /* short name */
     "magic"                              /* abbrev */
     );
 
+  proto_rdmnet = proto_register_protocol(
+    "RDMnet",                            /* name */
+    "RDMnet",                            /* short name */
+    "rdmnet"                             /* abbrev */
+    );
+
   proto_register_field_array(proto_acn, hf, array_length(hf));
   proto_register_subtree_array(ett, array_length(ett));
 
@@ -6359,6 +8628,9 @@ proto_register_acn(void)
   proto_register_subtree_array(magic_ett, array_length(magic_ett));
   expert_acn = expert_register_protocol(proto_magic);
   expert_register_field_array(expert_acn, ei, array_length(ei));
+
+  proto_register_field_array(proto_rdmnet, rdmnet_hf, array_length(rdmnet_hf));
+  proto_register_subtree_array(rdmnet_ett, array_length(rdmnet_ett));
 }
 
 
@@ -6370,7 +8642,12 @@ proto_reg_handoff_acn(void)
   /* dissector_handle_t acn_handle; */
   /* acn_handle = create_dissector_handle(dissect_acn, proto_acn); */
   /* dissector_add_for_decode_as_with_preference("udp.port", acn_handle);                         */
-  heur_dissector_add("udp", dissect_acn_heur, "ACN over UDP", "acn_udp", proto_acn, HEURISTIC_DISABLE);
+
+  rdm_handle      = find_dissector_add_dependency("rdm", proto_acn);
+
+  heur_dissector_add("udp", dissect_acn_heur, "ACN", "acn", proto_acn, HEURISTIC_DISABLE);
+  heur_dissector_add("udp", dissect_rdmnet_over_udp_heur, "RDMnet over UDP (LLRP)", "rdmnet_udp", proto_acn, HEURISTIC_DISABLE);
+  heur_dissector_add("tcp", dissect_rdmnet_over_tcp_heur, "RDMnet over TCP (Broker, RPT, EPT)", "rdmnet_tcp", proto_acn, HEURISTIC_DISABLE);
 }
 
 /*
diff --git a/epan/dissectors/packet-rdm.c b/epan/dissectors/packet-rdm.c
index 426d1e974d..c0bc20f1c2 100644
--- a/epan/dissectors/packet-rdm.c
+++ b/epan/dissectors/packet-rdm.c
@@ -15,6 +15,7 @@
  *
  * SPDX-License-Identifier: GPL-2.0-or-later
  */
+
 /*
  * ANSI E1.20-2006, Entertainment Technology
  * Remote Device Management over USITT DMX512, describes a method of
@@ -32,512 +33,789 @@
 #include <epan/packet.h>
 #include <epan/expert.h>
 #include "packet-rdm.h"
+#include "packet-arp.h"
 
 void proto_register_rdm(void);
 void proto_reg_handoff_rdm(void);
 
-#define RDM_SC_RDM				0xCC
-#define RDM_SC_SUB_MESSAGE			0x01
+#define RDM_SC_RDM          0xCC
+#define RDM_SC_SUB_MESSAGE  0x01
 
-#define RDM_CC_COMMAND_RESPONSE_FLAG		0x01
+#define RDM_CC_COMMAND_RESPONSE_FLAG    0x01
 
-#define RDM_CC_DISCOVERY_COMMAND		0x10
-#define RDM_CC_DISCOVERY_COMMAND_RESPONSE	0x11
-#define RDM_CC_GET_COMMAND			0x20
-#define RDM_CC_GET_COMMAND_RESPONSE		0x21
-#define RDM_CC_SET_COMMAND			0x30
-#define RDM_CC_SET_COMMAND_RESPONSE		0x31
+#define RDM_CC_DISCOVERY_COMMAND           0x10
+#define RDM_CC_DISCOVERY_COMMAND_RESPONSE  0x11
+#define RDM_CC_GET_COMMAND                 0x20
+#define RDM_CC_GET_COMMAND_RESPONSE        0x21
+#define RDM_CC_SET_COMMAND                 0x30
+#define RDM_CC_SET_COMMAND_RESPONSE        0x31
 
 static const value_string rdm_cc_vals[] = {
-	{ RDM_CC_DISCOVERY_COMMAND,		"Discovery Command" },
-	{ RDM_CC_DISCOVERY_COMMAND_RESPONSE,	"Discovery Command Response" },
-	{ RDM_CC_GET_COMMAND,			"Get Command" },
-	{ RDM_CC_GET_COMMAND_RESPONSE,		"Get Command Response" },
-	{ RDM_CC_SET_COMMAND,			"Set Command" },
-	{ RDM_CC_SET_COMMAND_RESPONSE,		"Set Command Response" },
-	{ 0, NULL },
+  { RDM_CC_DISCOVERY_COMMAND,           "Discovery Command" },
+  { RDM_CC_DISCOVERY_COMMAND_RESPONSE,  "Discovery Command Response" },
+  { RDM_CC_GET_COMMAND,                 "Get Command" },
+  { RDM_CC_GET_COMMAND_RESPONSE,        "Get Command Response" },
+  { RDM_CC_SET_COMMAND,                 "Set Command" },
+  { RDM_CC_SET_COMMAND_RESPONSE,        "Set Command Response" },
+  { 0, NULL },
 };
 
-#define RDM_RESPONSE_TYPE_ACK			0x00
-#define RDM_RESPONSE_TYPE_ACK_TIMER		0x01
-#define RDM_RESPONSE_TYPE_NACK_REASON		0x02
-#define RDM_RESPONSE_TYPE_ACK_OVERFLOW		0x03
+#define RDM_RESPONSE_TYPE_ACK           0x00
+#define RDM_RESPONSE_TYPE_ACK_TIMER     0x01
+#define RDM_RESPONSE_TYPE_NACK_REASON   0x02
+#define RDM_RESPONSE_TYPE_ACK_OVERFLOW  0x03
 
 static const value_string rdm_rt_vals[] = {
-	{ RDM_RESPONSE_TYPE_ACK,		"Ack" },
-	{ RDM_RESPONSE_TYPE_ACK_TIMER,		"Ack Timer" },
-	{ RDM_RESPONSE_TYPE_NACK_REASON,	"Nack Reason" },
-	{ RDM_RESPONSE_TYPE_ACK_OVERFLOW,	"Ack Overflow" },
-	{ 0, NULL },
+  { RDM_RESPONSE_TYPE_ACK,           "Ack" },
+  { RDM_RESPONSE_TYPE_ACK_TIMER,     "Ack Timer" },
+  { RDM_RESPONSE_TYPE_NACK_REASON,   "Nack Reason" },
+  { RDM_RESPONSE_TYPE_ACK_OVERFLOW,  "Ack Overflow" },
+  { 0, NULL },
 };
 
-#define RDM_NR_UNKNOWN_PID			0x0000
-#define RDM_NR_FORMAT_ERROR			0x0001
-#define RDM_NR_HARDWARE_FAULT			0x0002
-#define RDM_NR_PROXY_REJECT			0x0003
-#define RDM_NR_WRITE_PROTECT			0x0004
-#define RDM_NR_UNSUPPORTED_COMMAND_CLASS	0x0005
-#define RDM_NR_DATA_OUT_OF_RANGE		0x0006
-#define RDM_NR_BUFFER_FULL			0x0007
-#define RDM_NR_PACKET_SIZE_UNSUPPORTED		0x0008
-#define RDM_NR_SUB_DEVICE_OUT_OF_RANGE		0x0009
-#define RDM_NR_PROXY_BUFFER_FULL		0x000A
+#define RDM_NR_UNKNOWN_PID                 0x0000
+#define RDM_NR_FORMAT_ERROR                0x0001
+#define RDM_NR_HARDWARE_FAULT              0x0002
+#define RDM_NR_PROXY_REJECT                0x0003
+#define RDM_NR_WRITE_PROTECT               0x0004
+#define RDM_NR_UNSUPPORTED_COMMAND_CLASS   0x0005
+#define RDM_NR_DATA_OUT_OF_RANGE           0x0006
+#define RDM_NR_BUFFER_FULL                 0x0007
+#define RDM_NR_PACKET_SIZE_UNSUPPORTED     0x0008
+#define RDM_NR_SUB_DEVICE_OUT_OF_RANGE     0x0009
+#define RDM_NR_PROXY_BUFFER_FULL           0x000A
+#define RDM_NR_ACTION_NOT_SUPPORTED        0x000B  /* E1.37-2 */
+#define RDM_NR_ENDPOINT_NUMBER_INVALID     0x000C  /* E1.37-7 */
+#define RDM_NR_INVALID_ENDPOINT_MODE       0x000D
+#define RDM_NR_UNKNOWN_UID                 0x000E
+
+#define RDM_NR_UNKNOWN_SCOPE               0x000F  /* E1.33 */
+#define RDM_NR_INVALID_STATIC_CONFIG_TYPE  0x0010  /* E1.33 */
+#define RDM_NR_INVALID_IPV4_ADDRESS        0x0011  /* E1.33 */
+#define RDM_NR_INVALID_IPV6_ADDRESS        0x0012  /* E1.33 */
+#define RDM_NR_INVALID_PORT                0x0013  /* E1.33 */
 
 static const value_string rdm_nr_vals[] = {
-	{ RDM_NR_UNKNOWN_PID,			"Unknown PID" },
-	{ RDM_NR_FORMAT_ERROR,			"Format Error" },
-	{ RDM_NR_HARDWARE_FAULT,		"Hardware Fault" },
-	{ RDM_NR_PROXY_REJECT,			"Proxy Reject" },
-	{ RDM_NR_WRITE_PROTECT,			"Write Protect" },
-	{ RDM_NR_UNSUPPORTED_COMMAND_CLASS,	"Unsupported Command Class" },
-	{ RDM_NR_DATA_OUT_OF_RANGE,		"Data Out Of Range" },
-	{ RDM_NR_BUFFER_FULL,			"Buffer Full" },
-	{ RDM_NR_PACKET_SIZE_UNSUPPORTED,	"Packet Size Unsupported" },
-	{ RDM_NR_SUB_DEVICE_OUT_OF_RANGE,	"Sub-Device Out Of Range" },
-	{ RDM_NR_PROXY_BUFFER_FULL,		"Proxy Buffer Full" },
-	{ 0, NULL },
+  { RDM_NR_UNKNOWN_PID,                 "Unknown PID" },
+  { RDM_NR_FORMAT_ERROR,                "Format Error" },
+  { RDM_NR_HARDWARE_FAULT,              "Hardware Fault" },
+  { RDM_NR_PROXY_REJECT,                "Proxy Reject" },
+  { RDM_NR_WRITE_PROTECT,               "Write Protect" },
+  { RDM_NR_UNSUPPORTED_COMMAND_CLASS,   "Unsupported Command Class" },
+  { RDM_NR_DATA_OUT_OF_RANGE,           "Data Out Of Range" },
+  { RDM_NR_BUFFER_FULL,                 "Buffer Full" },
+  { RDM_NR_PACKET_SIZE_UNSUPPORTED,     "Packet Size Unsupported" },
+  { RDM_NR_SUB_DEVICE_OUT_OF_RANGE,     "Sub-Device Out Of Range" },
+  { RDM_NR_PROXY_BUFFER_FULL,           "Proxy Buffer Full" },
+  { RDM_NR_ACTION_NOT_SUPPORTED,        "Action Not Supported" },  /* E1.37-2 */
+  { RDM_NR_ENDPOINT_NUMBER_INVALID,     "Endpoint Number Invalid" },  /* E1.37-7 */
+  { RDM_NR_INVALID_ENDPOINT_MODE,       "Invalid Endpoint Mode" },
+  { RDM_NR_UNKNOWN_UID,                 "Unknown UID" },
+  { RDM_NR_UNKNOWN_SCOPE,               "Unknown Scope" },    /* E1.33 */
+  { RDM_NR_INVALID_STATIC_CONFIG_TYPE,  "Invalid Static Config Type" },
+  { RDM_NR_INVALID_IPV4_ADDRESS,        "Invalid IPv4 Address" },
+  { RDM_NR_INVALID_IPV6_ADDRESS,        "Invalid IPv6 Address" },
+  { RDM_NR_INVALID_PORT,                "Invalid Port" },
+  { 0, NULL },
 };
 
-#define RDM_PARAM_ID_DISC_UNIQUE_BRANCH			0x0001
-#define RDM_PARAM_ID_DISC_MUTE				0x0002
-#define RDM_PARAM_ID_DISC_UN_MUTE			0x0003
-#define RDM_PARAM_ID_PROXIED_DEVICES			0x0010
-#define RDM_PARAM_ID_PROXIED_DEVICE_COUNT		0x0011
-#define RDM_PARAM_ID_COMMS_STATUS			0x0015
-#define RDM_PARAM_ID_QUEUED_MESSAGE			0x0020
-#define RDM_PARAM_ID_STATUS_MESSAGES			0x0030
-#define RDM_PARAM_ID_STATUS_ID_DESCRIPTION		0x0031
-#define RDM_PARAM_ID_CLEAR_STATUS_ID			0x0032
-#define RDM_PARAM_ID_SUB_DEVICE_STATUS_REPORT_THRESHOLD 0x0033
-#define RDM_PARAM_ID_SUPPORTED_PARAMETERS		0x0050
-#define RDM_PARAM_ID_PARAMETER_DESCRIPTION		0x0051
-#define RDM_PARAM_ID_DEVICE_INFO			0x0060
-#define RDM_PARAM_ID_PRODUCT_DETAIL_ID_LIST		0x0070
-#define RDM_PARAM_ID_DEVICE_MODEL_DESCRIPTION		0x0080
-#define RDM_PARAM_ID_MANUFACTURER_LABEL			0x0081
-#define RDM_PARAM_ID_DEVICE_LABEL			0x0082
-#define RDM_PARAM_ID_FACTORY_DEFAULTS			0x0090
-#define RDM_PARAM_ID_LANGUAGE_CAPABILITIES		0x00A0
-#define RDM_PARAM_ID_LANGUAGE				0x00B0
-#define RDM_PARAM_ID_SOFTWARE_VERSION_LABEL		0x00C0
-#define RDM_PARAM_ID_BOOT_SOFTWARE_VERSION_ID		0x00C1
-#define RDM_PARAM_ID_BOOT_SOFTWARE_VERSION_LABEL	0x00C2
-#define RDM_PARAM_ID_DMX_PERSONALITY			0x00E0
-#define RDM_PARAM_ID_DMX_PERSONALITY_DESCRIPTION	0x00E1
-#define RDM_PARAM_ID_DMX_START_ADDRESS			0x00F0
-#define RDM_PARAM_ID_SLOT_INFO				0x0120
-#define RDM_PARAM_ID_SLOT_DESCRIPTION			0x0121
-#define RDM_PARAM_ID_DEFAULT_SLOT_VALUE			0x0122
-#define RDM_PARAM_ID_SENSOR_DEFINITION			0x0200
-#define RDM_PARAM_ID_SENSOR_VALUE			0x0201
-#define RDM_PARAM_ID_RECORD_SENSORS			0x0202
-#define RDM_PARAM_ID_DEVICE_HOURS			0x0400
-#define RDM_PARAM_ID_LAMP_HOURS				0x0401
-#define RDM_PARAM_ID_LAMP_STRIKES			0x0402
-#define RDM_PARAM_ID_LAMP_STATE				0x0403
-#define RDM_PARAM_ID_LAMP_ON_MODE			0x0404
-#define RDM_PARAM_ID_DEVICE_POWER_CYCLES		0x0405
-#define RDM_PARAM_ID_DISPLAY_INVERT			0x0500
-#define RDM_PARAM_ID_DISPLAY_LEVEL			0x0501
-#define RDM_PARAM_ID_PAN_INVERT				0x0600
-#define RDM_PARAM_ID_TILT_INVERT			0x0601
-#define RDM_PARAM_ID_PAN_TILT_SWAP			0x0602
-#define RDM_PARAM_ID_REAL_TIME_CLOCK			0x0603
-#define RDM_PARAM_ID_IDENTIFY_DEVICE			0x1000
-#define RDM_PARAM_ID_RESET_DEVICE			0x1001
-#define RDM_PARAM_ID_POWER_STATE			0x1010
-#define RDM_PARAM_ID_PERFORM_SELFTEST			0x1020
-#define RDM_PARAM_ID_SELF_TEST_DESCRIPTION		0x1021
-#define RDM_PARAM_ID_CAPTURE_PRESET			0x1030
-#define RDM_PARAM_ID_PRESET_PLAYBACK			0x1031
+/* E1.20, E1.33, and E1.37 PIDs */
+#define RDM_PARAM_ID_DISC_UNIQUE_BRANCH                           0x0001
+#define RDM_PARAM_ID_DISC_MUTE                                    0x0002
+#define RDM_PARAM_ID_DISC_UN_MUTE                                 0x0003
+#define RDM_PARAM_ID_PROXIED_DEVICES                              0x0010
+#define RDM_PARAM_ID_PROXIED_DEVICE_COUNT                         0x0011
+#define RDM_PARAM_ID_COMMS_STATUS                                 0x0015
+#define RDM_PARAM_ID_QUEUED_MESSAGE                               0x0020
+#define RDM_PARAM_ID_STATUS_MESSAGES                              0x0030
+#define RDM_PARAM_ID_STATUS_ID_DESCRIPTION                        0x0031
+#define RDM_PARAM_ID_CLEAR_STATUS_ID                              0x0032
+#define RDM_PARAM_ID_SUB_DEVICE_STATUS_REPORT_THRESHOLD           0x0033
+#define RDM_PARAM_ID_SUPPORTED_PARAMETERS                         0x0050
+#define RDM_PARAM_ID_PARAMETER_DESCRIPTION                        0x0051
+#define RDM_PARAM_ID_DEVICE_INFO                                  0x0060
+#define RDM_PARAM_ID_PRODUCT_DETAIL_ID_LIST                       0x0070
+#define RDM_PARAM_ID_DEVICE_MODEL_DESCRIPTION                     0x0080
+#define RDM_PARAM_ID_MANUFACTURER_LABEL                           0x0081
+#define RDM_PARAM_ID_DEVICE_LABEL                                 0x0082
+#define RDM_PARAM_ID_FACTORY_DEFAULTS                             0x0090
+#define RDM_PARAM_ID_LANGUAGE_CAPABILITIES                        0x00A0
+#define RDM_PARAM_ID_LANGUAGE                                     0x00B0
+#define RDM_PARAM_ID_SOFTWARE_VERSION_LABEL                       0x00C0
+#define RDM_PARAM_ID_BOOT_SOFTWARE_VERSION_ID                     0x00C1
+#define RDM_PARAM_ID_BOOT_SOFTWARE_VERSION_LABEL                  0x00C2
+#define RDM_PARAM_ID_DMX_PERSONALITY                              0x00E0
+#define RDM_PARAM_ID_DMX_PERSONALITY_DESCRIPTION                  0x00E1
+#define RDM_PARAM_ID_DMX_START_ADDRESS                            0x00F0
+#define RDM_PARAM_ID_SLOT_INFO                                    0x0120
+#define RDM_PARAM_ID_SLOT_DESCRIPTION                             0x0121
+#define RDM_PARAM_ID_DEFAULT_SLOT_VALUE                           0x0122
+
+#define RDM_PARAM_ID_DMX_BLOCK_ADDRESS                            0x0140  /* E1.37-1 */
+#define RDM_PARAM_ID_DMX_FAIL_MODE                                0x0141
+#define RDM_PARAM_ID_DMX_STARTUP_MODE                             0x0142
+
+#define RDM_PARAM_ID_SENSOR_DEFINITION                            0x0200
+#define RDM_PARAM_ID_SENSOR_VALUE                                 0x0201
+#define RDM_PARAM_ID_RECORD_SENSORS                               0x0202
+
+#define RDM_PARAM_ID_DIMMER_INFO                                  0x0340  /* E1.37-1 */
+#define RDM_PARAM_ID_MINIMUM_LEVEL                                0x0341
+#define RDM_PARAM_ID_MAXIMUM_LEVEL                                0x0342
+#define RDM_PARAM_ID_CURVE                                        0x0343
+#define RDM_PARAM_ID_CURVE_DESCRIPTION                            0x0344
+#define RDM_PARAM_ID_OUTPUT_RESPONSE_TIME                         0x0345
+#define RDM_PARAM_ID_OUTPUT_RESPONSE_TIME_DESCRIPTION             0x0346
+#define RDM_PARAM_ID_MODULATION_FREQUENCY                         0x0347
+#define RDM_PARAM_ID_MODULATION_FREQUENCY_DESCRIPTION             0x0348
+
+#define RDM_PARAM_ID_DEVICE_HOURS                                 0x0400
+#define RDM_PARAM_ID_LAMP_HOURS                                   0x0401
+#define RDM_PARAM_ID_LAMP_STRIKES                                 0x0402
+#define RDM_PARAM_ID_LAMP_STATE                                   0x0403
+#define RDM_PARAM_ID_LAMP_ON_MODE                                 0x0404
+#define RDM_PARAM_ID_DEVICE_POWER_CYCLES                          0x0405
+
+#define RDM_PARAM_ID_BURN_IN                                      0x0440  /* E1.37-1 */
+
+#define RDM_PARAM_ID_DISPLAY_INVERT                               0x0500
+#define RDM_PARAM_ID_DISPLAY_LEVEL                                0x0501
+#define RDM_PARAM_ID_PAN_INVERT                                   0x0600
+#define RDM_PARAM_ID_TILT_INVERT                                  0x0601
+#define RDM_PARAM_ID_PAN_TILT_SWAP                                0x0602
+#define RDM_PARAM_ID_REAL_TIME_CLOCK                              0x0603
+
+#define RDM_PARAM_ID_LOCK_PIN                                     0x0640  /* E1.37-1 */
+#define RDM_PARAM_ID_LOCK_STATE                                   0x0641
+#define RDM_PARAM_ID_LOCK_STATE_DESCRIPTION                       0x0642
+
+#define RDM_PARAM_ID_LIST_INTERFACES                              0x0700  /* E1.37-2 */
+#define RDM_PARAM_ID_INTERFACE_LABEL                              0x0701
+#define RDM_PARAM_ID_INTERFACE_HARDWARE_ADDRESS_TYPE1             0x0702
+#define RDM_PARAM_ID_IPV4_DHCP_MODE                               0x0703
+#define RDM_PARAM_ID_IPV4_ZEROCONF_MODE                           0x0704
+#define RDM_PARAM_ID_IPV4_CURRENT_ADDRESS                         0x0705
+#define RDM_PARAM_ID_IPV4_STATIC_ADDRESS                          0x0706
+#define RDM_PARAM_ID_INTERFACE_RENEW_DHCP                         0x0707
+#define RDM_PARAM_ID_INTERFACE_RELEASE_DHCP                       0x0708
+#define RDM_PARAM_ID_INTERFACE_APPLY_CONFIGURATION                0x0709
+#define RDM_PARAM_ID_IPV4_DEFAULT_ROUTE                           0x070A
+#define RDM_PARAM_ID_DNS_IPV4_NAME_SERVER                         0x070B
+#define RDM_PARAM_ID_DNS_HOSTNAME                                 0x070C
+#define RDM_PARAM_ID_DNS_DOMAIN_NAME                              0x070D
+
+#define RDM_PARAM_ID_COMPONENT_SCOPE                              0x0800  /* E1.33 */
+#define RDM_PARAM_ID_SEARCH_DOMAIN                                0x0801  /* E1.33 */
+#define RDM_PARAM_ID_TCP_COMMS_STATUS                             0x0802  /* E1.33 */
+#define RDM_PARAM_ID_BROKER_STATUS                                0x0803  /* E1.33 */
+
+#define RDM_PARAM_ID_ENDPOINT_LIST                                0x0900  /* E1.37-7 */
+#define RDM_PARAM_ID_ENDPOINT_LIST_CHANGE                         0x0901
+#define RDM_PARAM_ID_IDENTIFY_ENDPOINT                            0x0902
+#define RDM_PARAM_ID_ENDPOINT_TO_UNIVERSE                         0x0903
+#define RDM_PARAM_ID_ENDPOINT_MODE                                0x0904
+#define RDM_PARAM_ID_ENDPOINT_LABEL                               0x0905
+#define RDM_PARAM_ID_RDM_TRAFFIC_ENABLE                           0x0906
+#define RDM_PARAM_ID_DISCOVERY_STATE                              0x0907
+#define RDM_PARAM_ID_BACKGROUND_DISCOVERY                         0x0908
+#define RDM_PARAM_ID_ENDPOINT_TIMING                              0x0909
+#define RDM_PARAM_ID_ENDPOINT_TIMING_DESCRIPTION                  0x090A
+#define RDM_PARAM_ID_ENDPOINT_RESPONDERS                          0x090B
+#define RDM_PARAM_ID_ENDPOINT_RESPONDER_LIST_CHANGE               0x090C
+#define RDM_PARAM_ID_BINDING_CONTROL_FIELDS                       0x090D
+#define RDM_PARAM_ID_BACKGROUND_QUEUED_STATUS_POLICY              0x090E
+#define RDM_PARAM_ID_BACKGROUND_QUEUED_STATUS_POLICY_DESCRIPTION  0x090F
+
+#define RDM_PARAM_ID_IDENTIFY_DEVICE                              0x1000
+#define RDM_PARAM_ID_RESET_DEVICE                                 0x1001
+#define RDM_PARAM_ID_POWER_STATE                                  0x1010
+#define RDM_PARAM_ID_PERFORM_SELFTEST                             0x1020
+#define RDM_PARAM_ID_SELF_TEST_DESCRIPTION                        0x1021
+#define RDM_PARAM_ID_CAPTURE_PRESET                               0x1030
+#define RDM_PARAM_ID_PRESET_PLAYBACK                              0x1031
+
+#define RDM_PARAM_ID_IDENTIFY_MODE                                0x1040  /* E1.37-1 */
+#define RDM_PARAM_ID_PRESET_INFO                                  0x1041
+#define RDM_PARAM_ID_PRESET_STATUS                                0x1042
+#define RDM_PARAM_ID_PRESET_MERGEMODE                             0x1043
+#define RDM_PARAM_ID_POWER_ON_SELF_TEST                           0x1044
 
 const value_string rdm_param_id_vals[] = {
-	{ RDM_PARAM_ID_DISC_UNIQUE_BRANCH,		   "DISC_UNIQUE_BRANCH" },
-	{ RDM_PARAM_ID_DISC_MUTE,			   "DISC_MUTE" },
-	{ RDM_PARAM_ID_DISC_UN_MUTE,			   "DISC_UN_MUTE" },
-	{ RDM_PARAM_ID_PROXIED_DEVICES,			   "PROXIED_DEVICES" },
-	{ RDM_PARAM_ID_PROXIED_DEVICE_COUNT,		   "PROXIED_DEVICE_COUNT" },
-	{ RDM_PARAM_ID_COMMS_STATUS,			   "COMMS_STATUS" },
-	{ RDM_PARAM_ID_QUEUED_MESSAGE,			   "QUEUED_MESSAGE" },
-	{ RDM_PARAM_ID_STATUS_MESSAGES,			   "STATUS_MESSAGES" },
-	{ RDM_PARAM_ID_STATUS_ID_DESCRIPTION,		   "STATUS_ID_DESCRIPTION" },
-	{ RDM_PARAM_ID_CLEAR_STATUS_ID,			   "CLEAR_STATUS_ID" },
-	{ RDM_PARAM_ID_SUB_DEVICE_STATUS_REPORT_THRESHOLD, "DEVICE_STATUS_REPORT_THRESHOLD" },
-	{ RDM_PARAM_ID_SUPPORTED_PARAMETERS,		   "SUPPORTED_PARAMETERS" },
-	{ RDM_PARAM_ID_PARAMETER_DESCRIPTION,		   "PARAMETER_DESCRIPTION" },
-	{ RDM_PARAM_ID_DEVICE_INFO,			   "DEVICE_INFO" },
-	{ RDM_PARAM_ID_PRODUCT_DETAIL_ID_LIST,		   "PRODUCT_DETAIL_ID_LIST" },
-	{ RDM_PARAM_ID_DEVICE_MODEL_DESCRIPTION,	   "DEVICE_MODEL_DESCRIPTION" },
-	{ RDM_PARAM_ID_MANUFACTURER_LABEL,		   "MANUFACTURER_LABEL" },
-	{ RDM_PARAM_ID_DEVICE_LABEL,			   "DEVICE_LABEL" },
-	{ RDM_PARAM_ID_FACTORY_DEFAULTS,		   "FACTORY_DEFAULTS" },
-	{ RDM_PARAM_ID_LANGUAGE_CAPABILITIES,		   "LANGUAGE_CAPABILITIES" },
-	{ RDM_PARAM_ID_LANGUAGE,			   "LANGUAGE" },
-	{ RDM_PARAM_ID_SOFTWARE_VERSION_LABEL,		   "SOFTWARE_VERSION_LABEL" },
-	{ RDM_PARAM_ID_BOOT_SOFTWARE_VERSION_ID,	   "BOOT_SOFTWARE_VERSION_ID" },
-	{ RDM_PARAM_ID_BOOT_SOFTWARE_VERSION_LABEL,	   "BOOT_SOFTWARE_VERSION_LABEL" },
-	{ RDM_PARAM_ID_DMX_PERSONALITY,			   "DMX_PERSONALITY" },
-	{ RDM_PARAM_ID_DMX_PERSONALITY_DESCRIPTION,	   "DMX_PERSONALITY_DESCRIPTION" },
-	{ RDM_PARAM_ID_DMX_START_ADDRESS,		   "DMX_START_ADDRESS" },
-	{ RDM_PARAM_ID_SLOT_INFO,			   "SLOT_INFO" },
-	{ RDM_PARAM_ID_SLOT_DESCRIPTION,		   "SLOT_DESCRIPTION" },
-	{ RDM_PARAM_ID_DEFAULT_SLOT_VALUE,		   "DEFAULT_SLOT_VALUE" },
-	{ RDM_PARAM_ID_SENSOR_DEFINITION,		   "SENSOR_DEFINITION" },
-	{ RDM_PARAM_ID_SENSOR_VALUE,			   "SENSOR_VALUE" },
-	{ RDM_PARAM_ID_RECORD_SENSORS,			   "RECORD_SENSORS" },
-	{ RDM_PARAM_ID_DEVICE_HOURS,			   "DEVICE_HOURS" },
-	{ RDM_PARAM_ID_LAMP_HOURS,			   "LAMP_HOURS" },
-	{ RDM_PARAM_ID_LAMP_STRIKES,			   "LAMP_STRIKES" },
-	{ RDM_PARAM_ID_LAMP_STATE,			   "LAMP_STATE" },
-	{ RDM_PARAM_ID_LAMP_ON_MODE,			   "LAMP_ON_MODE" },
-	{ RDM_PARAM_ID_DEVICE_POWER_CYCLES,		   "DEVICE_POWER_CYCLES" },
-	{ RDM_PARAM_ID_DISPLAY_INVERT,			   "DISPLAY_INVERT" },
-	{ RDM_PARAM_ID_DISPLAY_LEVEL,			   "DISPLAY_LEVEL" },
-	{ RDM_PARAM_ID_PAN_INVERT,			   "PAN_INVERT" },
-	{ RDM_PARAM_ID_TILT_INVERT,			   "TILT_INVERT" },
-	{ RDM_PARAM_ID_PAN_TILT_SWAP,			   "PAN_TILT_SWAP" },
-	{ RDM_PARAM_ID_REAL_TIME_CLOCK,			   "REAL_TIME_CLOCK" },
-	{ RDM_PARAM_ID_IDENTIFY_DEVICE,			   "IDENTIFY_DEVICE" },
-	{ RDM_PARAM_ID_RESET_DEVICE,			   "RESET_DEVICE" },
-	{ RDM_PARAM_ID_POWER_STATE,			   "POWER_STATE" },
-	{ RDM_PARAM_ID_PERFORM_SELFTEST,		   "PERFORM_SELFTEST" },
-	{ RDM_PARAM_ID_SELF_TEST_DESCRIPTION,		   "SELF_TEST_DESCRIPTION" },
-	{ RDM_PARAM_ID_CAPTURE_PRESET,			   "CAPTURE_PRESET" },
-	{ RDM_PARAM_ID_PRESET_PLAYBACK,			   "PRESET_PLAYBACK" },
-	{ 0, NULL },
+  { RDM_PARAM_ID_DISC_UNIQUE_BRANCH,                  "Discovery Unique Branch" },
+  { RDM_PARAM_ID_DISC_MUTE,                           "Discovery Mute" },
+  { RDM_PARAM_ID_DISC_UN_MUTE,                        "Discovery Un-Mute" },
+  { RDM_PARAM_ID_PROXIED_DEVICES,                     "Proxied Devices" },
+  { RDM_PARAM_ID_PROXIED_DEVICE_COUNT,                "Proxied Device Count" },
+  { RDM_PARAM_ID_COMMS_STATUS,                        "Communication Status" },
+  { RDM_PARAM_ID_QUEUED_MESSAGE,                      "Queued Messages" },
+  { RDM_PARAM_ID_STATUS_MESSAGES,                     "Status Messages" },
+  { RDM_PARAM_ID_STATUS_ID_DESCRIPTION,               "Status ID Description" },
+  { RDM_PARAM_ID_CLEAR_STATUS_ID,                     "Clear Status ID" },
+  { RDM_PARAM_ID_SUB_DEVICE_STATUS_REPORT_THRESHOLD,  "Device Status Reporting Threshold" },
+  { RDM_PARAM_ID_SUPPORTED_PARAMETERS,                "Supported Parameters" },
+  { RDM_PARAM_ID_PARAMETER_DESCRIPTION,               "Parameter Description" },
+  { RDM_PARAM_ID_DEVICE_INFO,                         "Device Info" },
+  { RDM_PARAM_ID_PRODUCT_DETAIL_ID_LIST,              "Product Detail ID List" },
+  { RDM_PARAM_ID_DEVICE_MODEL_DESCRIPTION,            "Device Model Description" },
+  { RDM_PARAM_ID_MANUFACTURER_LABEL,                  "Manufacturer Label" },
+  { RDM_PARAM_ID_DEVICE_LABEL,                        "Device Label" },
+  { RDM_PARAM_ID_FACTORY_DEFAULTS,                    "Factory Defaults" },
+  { RDM_PARAM_ID_LANGUAGE_CAPABILITIES,               "Language Capabilities" },
+  { RDM_PARAM_ID_LANGUAGE,                            "Language" },
+  { RDM_PARAM_ID_SOFTWARE_VERSION_LABEL,              "Software Version Label" },
+  { RDM_PARAM_ID_BOOT_SOFTWARE_VERSION_ID,            "Boot Software Version ID" },
+  { RDM_PARAM_ID_BOOT_SOFTWARE_VERSION_LABEL,         "Boot Software Version Label" },
+  { RDM_PARAM_ID_DMX_PERSONALITY,                     "DMX Personality" },
+  { RDM_PARAM_ID_DMX_PERSONALITY_DESCRIPTION,         "DMX Personality Description" },
+  { RDM_PARAM_ID_DMX_START_ADDRESS,                   "DMX Start Address" },
+  { RDM_PARAM_ID_SLOT_INFO,                           "Slot Info" },
+  { RDM_PARAM_ID_SLOT_DESCRIPTION,                    "Slot Description" },
+  { RDM_PARAM_ID_DEFAULT_SLOT_VALUE,                  "Default Slot Value" },
+
+  { RDM_PARAM_ID_DMX_BLOCK_ADDRESS,                   "DMX Block Address" },  /* E1.37-1 */
+  { RDM_PARAM_ID_DMX_FAIL_MODE,                       "DMX Fail Mode" },
+  { RDM_PARAM_ID_DMX_STARTUP_MODE,                    "DMX Startup Mode" },
+
+  { RDM_PARAM_ID_SENSOR_DEFINITION,                   "Sensor Definition" },
+  { RDM_PARAM_ID_SENSOR_VALUE,                        "Sensor Value" },
+  { RDM_PARAM_ID_RECORD_SENSORS,                      "Record Sensors" },
+
+  { RDM_PARAM_ID_DIMMER_INFO,                         "Dimmer Info" },  /* E1.37-1 */
+  { RDM_PARAM_ID_MINIMUM_LEVEL,                       "Minimum Level" },
+  { RDM_PARAM_ID_MAXIMUM_LEVEL,                       "Maximum Level" },
+  { RDM_PARAM_ID_CURVE,                               "Curve" },
+  { RDM_PARAM_ID_CURVE_DESCRIPTION,                   "Curve Description" },
+  { RDM_PARAM_ID_OUTPUT_RESPONSE_TIME,                "Output Response Time" },
+  { RDM_PARAM_ID_OUTPUT_RESPONSE_TIME_DESCRIPTION,    "Output Response Time Description" },
+  { RDM_PARAM_ID_MODULATION_FREQUENCY,                "Modulation Frequency" },
+  { RDM_PARAM_ID_MODULATION_FREQUENCY_DESCRIPTION,    "Modulation Frequency Description" },
+
+  { RDM_PARAM_ID_DEVICE_HOURS,                        "Device Hours" },
+  { RDM_PARAM_ID_LAMP_HOURS,                          "Lamp Hours" },
+  { RDM_PARAM_ID_LAMP_STRIKES,                        "Lamp Strikes" },
+  { RDM_PARAM_ID_LAMP_STATE,                          "Lamp State" },
+  { RDM_PARAM_ID_LAMP_ON_MODE,                        "Lamp On Mode" },
+  { RDM_PARAM_ID_DEVICE_POWER_CYCLES,                 "Device Power Cycles" },
+
+  { RDM_PARAM_ID_BURN_IN,                             "Burn In" },  /* E1.37-1 */
+
+  { RDM_PARAM_ID_DISPLAY_INVERT,                      "Display Invert" },
+  { RDM_PARAM_ID_DISPLAY_LEVEL,                       "Display Level" },
+  { RDM_PARAM_ID_PAN_INVERT,                          "Pan Invert" },
+  { RDM_PARAM_ID_TILT_INVERT,                         "Tilt Invert" },
+  { RDM_PARAM_ID_PAN_TILT_SWAP,                       "Pan Tilt Swap" },
+  { RDM_PARAM_ID_REAL_TIME_CLOCK,                     "Real Time Clock" },
+
+  { RDM_PARAM_ID_LOCK_PIN,                            "Lock PIN" },  /* E1.37-1 */
+  { RDM_PARAM_ID_LOCK_STATE,                          "Lock State" },
+  { RDM_PARAM_ID_LOCK_STATE_DESCRIPTION,              "Lock State Description" },
+
+  { RDM_PARAM_ID_LIST_INTERFACES,                     "List Interfaces" },  /* E1.37-2 */
+  { RDM_PARAM_ID_INTERFACE_LABEL,                     "Interface Label" },
+  { RDM_PARAM_ID_INTERFACE_HARDWARE_ADDRESS_TYPE1,    "Interface Hardware Address Type 1" },
+  { RDM_PARAM_ID_IPV4_DHCP_MODE,                      "IPv4 DHCP Mode" },
+  { RDM_PARAM_ID_IPV4_ZEROCONF_MODE,                  "IPv4 Zero Configuration Mode" },
+  { RDM_PARAM_ID_IPV4_CURRENT_ADDRESS,                "IPv4 Current Address" },
+  { RDM_PARAM_ID_IPV4_STATIC_ADDRESS,                 "IPv4 Static Address" },
+  { RDM_PARAM_ID_INTERFACE_RENEW_DHCP,                "Interface Renew DHCP" },
+  { RDM_PARAM_ID_INTERFACE_RELEASE_DHCP,              "Interface Release DHCP" },
+  { RDM_PARAM_ID_INTERFACE_APPLY_CONFIGURATION,       "Interface Apply Configuration" },
+  { RDM_PARAM_ID_IPV4_DEFAULT_ROUTE,                  "IPv4 Default Route" },
+  { RDM_PARAM_ID_DNS_IPV4_NAME_SERVER,                "DNS IPv4 Name Server" },
+  { RDM_PARAM_ID_DNS_HOSTNAME,                        "DNS Hostname" },
+  { RDM_PARAM_ID_DNS_DOMAIN_NAME,                     "DNS Domain Name" },
+
+  { RDM_PARAM_ID_COMPONENT_SCOPE,                     "Component Scope" },
+  { RDM_PARAM_ID_SEARCH_DOMAIN,                       "Search Domain" },
+  { RDM_PARAM_ID_TCP_COMMS_STATUS,                    "TCP Communication Status" },
+  { RDM_PARAM_ID_BROKER_STATUS,                       "Broker Status" },
+
+  { RDM_PARAM_ID_ENDPOINT_LIST,                       "Endpoint List" },  /* E1.37-7 */
+  { RDM_PARAM_ID_ENDPOINT_LIST_CHANGE,                "Endpoint List Change" },
+  { RDM_PARAM_ID_IDENTIFY_ENDPOINT,                   "Identify Endpoint" },
+  { RDM_PARAM_ID_ENDPOINT_TO_UNIVERSE,                "Endpoint To Universe" },
+  { RDM_PARAM_ID_ENDPOINT_MODE,                       "Endpoint Mode" },
+  { RDM_PARAM_ID_ENDPOINT_LABEL,                      "Endpoint Label" },
+  { RDM_PARAM_ID_RDM_TRAFFIC_ENABLE,                  "RDM Traffic Enable" },
+  { RDM_PARAM_ID_DISCOVERY_STATE,                     "Discovery State" },
+  { RDM_PARAM_ID_BACKGROUND_DISCOVERY,                "Background Discovery" },
+  { RDM_PARAM_ID_ENDPOINT_TIMING,                     "Endpoint Timing" },
+  { RDM_PARAM_ID_ENDPOINT_TIMING_DESCRIPTION,         "Endpoint Timing Description" },
+  { RDM_PARAM_ID_ENDPOINT_RESPONDERS,                 "Endpoint Responders" },
+  { RDM_PARAM_ID_ENDPOINT_RESPONDER_LIST_CHANGE,      "Endpoint Responder List Change" },
+  { RDM_PARAM_ID_BINDING_CONTROL_FIELDS,              "Binding Control Fields" },
+  { RDM_PARAM_ID_BACKGROUND_QUEUED_STATUS_POLICY,     "Background Queued Status Policy" },
+  { RDM_PARAM_ID_BACKGROUND_QUEUED_STATUS_POLICY_DESCRIPTION,  "Background Queued Status Policy Description" },
+
+  { RDM_PARAM_ID_IDENTIFY_DEVICE,                     "Identify Device" },
+  { RDM_PARAM_ID_RESET_DEVICE,                        "Reset Device" },
+  { RDM_PARAM_ID_POWER_STATE,                         "Power State" },
+  { RDM_PARAM_ID_PERFORM_SELFTEST,                    "Perform Self Test" },
+  { RDM_PARAM_ID_SELF_TEST_DESCRIPTION,               "Self Test Description" },
+  { RDM_PARAM_ID_CAPTURE_PRESET,                      "Capture Preset" },
+  { RDM_PARAM_ID_PRESET_PLAYBACK,                     "Preset Playback" },
+
+  { RDM_PARAM_ID_IDENTIFY_MODE,                       "Identify Mode" },  /* E1.37-1 */
+  { RDM_PARAM_ID_PRESET_INFO,                         "Preset Info" },
+  { RDM_PARAM_ID_PRESET_STATUS,                       "Preset Status" },
+  { RDM_PARAM_ID_PRESET_MERGEMODE,                    "Preset Merge Mode" },
+  { RDM_PARAM_ID_POWER_ON_SELF_TEST,                  "Power On Self Test" },
+
+  { 0, NULL },
 };
 
 value_string_ext rdm_param_id_vals_ext = VALUE_STRING_EXT_INIT(rdm_param_id_vals);
 
-#define RDM_STATUS_NONE				0x00
-#define RMD_STATUS_GET_LAST_MESSAGE		0x01
-#define RDM_STATUS_ADVISORY			0x02
-#define RDM_STATUS_WARNING			0x03
-#define RDM_STATUS_ERROR			0x04
+/* manufacturer IDs */
+#define RDM_MANUFACTURER_ID_ETC    0x6574
+
+#define RDM_STATUS_NONE              0x00
+#define RMD_STATUS_GET_LAST_MESSAGE  0x01
+#define RDM_STATUS_ADVISORY          0x02
+#define RDM_STATUS_WARNING           0x03
+#define RDM_STATUS_ERROR             0x04
 
 static const value_string rdm_status_vals[] = {
-	{ RDM_STATUS_NONE,		"None" },
-	{ RMD_STATUS_GET_LAST_MESSAGE,	"Get Last Message" },
-	{ RDM_STATUS_ADVISORY,		"Advisory" },
-	{ RDM_STATUS_WARNING,		"Warning" },
-	{ RDM_STATUS_ERROR,		"Error" },
-	{ 0, NULL },
+  { RDM_STATUS_NONE,              "None" },
+  { RMD_STATUS_GET_LAST_MESSAGE,  "Get Last Message" },
+  { RDM_STATUS_ADVISORY,          "Advisory" },
+  { RDM_STATUS_WARNING,           "Warning" },
+  { RDM_STATUS_ERROR,             "Error" },
+  { 0, NULL },
 };
 
-#define RDM_PREFIX_NONE		0x00
-#define RDM_PREFIX_DECI		0x01
-#define RDM_PREFIX_CENTI	0x02
-#define RDM_PREFIX_MILLI	0x03
-#define RDM_PREFIX_MICRO	0x04
-#define RDM_PREFIX_NANO		0x05
-#define RDM_PREFIX_PICO		0x06
-#define RDM_PREFIX_FEMPTO	0x07
-#define RDM_PREFIX_ATTO		0x08
-#define RDM_PREFIX_ZEPTO	0x09
-#define RDM_PREFIX_YOCTO	0x0A
-#define RDM_PREFIX_DECA		0x11
-#define RDM_PREFIX_HECTO	0x12
-#define RDM_PREFIX_KILO		0x13
-#define RDM_PREFIX_MEGA		0x14
-#define RDM_PREFIX_GIGA		0x15
-#define RDM_PREFIX_TERRA	0x16
-#define RDM_PREFIX_PETA		0x17
-#define RDM_PREFIX_EXA		0x18
-#define RDM_PREFIX_ZETTA	0x19
-#define RDM_PREFIX_YOTTA	0x1A
+#define RDM_PREFIX_NONE    0x00
+#define RDM_PREFIX_DECI    0x01
+#define RDM_PREFIX_CENTI   0x02
+#define RDM_PREFIX_MILLI   0x03
+#define RDM_PREFIX_MICRO   0x04
+#define RDM_PREFIX_NANO    0x05
+#define RDM_PREFIX_PICO    0x06
+#define RDM_PREFIX_FEMPTO  0x07
+#define RDM_PREFIX_ATTO    0x08
+#define RDM_PREFIX_ZEPTO   0x09
+#define RDM_PREFIX_YOCTO   0x0A
+#define RDM_PREFIX_DECA    0x11
+#define RDM_PREFIX_HECTO   0x12
+#define RDM_PREFIX_KILO    0x13
+#define RDM_PREFIX_MEGA    0x14
+#define RDM_PREFIX_GIGA    0x15
+#define RDM_PREFIX_TERRA   0x16
+#define RDM_PREFIX_PETA    0x17
+#define RDM_PREFIX_EXA     0x18
+#define RDM_PREFIX_ZETTA   0x19
+#define RDM_PREFIX_YOTTA   0x1A
 
 static const value_string rdm_prefix_vals[] = {
-	{ RDM_PREFIX_NONE,	"NONE (x1)" },
-	{ RDM_PREFIX_DECI,	"deci (x10^-1)" },
-	{ RDM_PREFIX_CENTI,	"centi (x10^-2)" },
-	{ RDM_PREFIX_MILLI,	"milli (x10^-3)" },
-	{ RDM_PREFIX_MICRO,	"micro (x10^-6)" },
-	{ RDM_PREFIX_NANO,	"nano (x10^-9)" },
-	{ RDM_PREFIX_PICO,	"pico (x10^-12)" },
-	{ RDM_PREFIX_FEMPTO,	"fempto (x10^-15)" },
-	{ RDM_PREFIX_ATTO,	"atto (x10^-18)" },
-	{ RDM_PREFIX_ZEPTO,	"zepto (x10^-21)" },
-	{ RDM_PREFIX_YOCTO,	"yocto (x10^-24)" },
-	{ RDM_PREFIX_DECA,	"deca (x10^1)" },
-	{ RDM_PREFIX_HECTO,	"hecto (x10^2)" },
-	{ RDM_PREFIX_KILO,	"kilo (x10^3)" },
-	{ RDM_PREFIX_MEGA,	"mega (x10^6)" },
-	{ RDM_PREFIX_GIGA,	"giga (x10^9)" },
-	{ RDM_PREFIX_TERRA,	"terra (x10^12)" },
-	{ RDM_PREFIX_PETA,	"peta (x10^15)" },
-	{ RDM_PREFIX_EXA,	"exa (x10^18)" },
-	{ RDM_PREFIX_ZETTA,	"zetta (x10^21)" },
-	{ RDM_PREFIX_YOTTA,	"yotta (x10^24)" },
-	{ 0, NULL },
+  { RDM_PREFIX_NONE,    "NONE (x1)" },
+  { RDM_PREFIX_DECI,    "deci (x10^-1)" },
+  { RDM_PREFIX_CENTI,   "centi (x10^-2)" },
+  { RDM_PREFIX_MILLI,   "milli (x10^-3)" },
+  { RDM_PREFIX_MICRO,   "micro (x10^-6)" },
+  { RDM_PREFIX_NANO,    "nano (x10^-9)" },
+  { RDM_PREFIX_PICO,    "pico (x10^-12)" },
+  { RDM_PREFIX_FEMPTO,  "fempto (x10^-15)" },
+  { RDM_PREFIX_ATTO,    "atto (x10^-18)" },
+  { RDM_PREFIX_ZEPTO,   "zepto (x10^-21)" },
+  { RDM_PREFIX_YOCTO,   "yocto (x10^-24)" },
+  { RDM_PREFIX_DECA,    "deca (x10^1)" },
+  { RDM_PREFIX_HECTO,   "hecto (x10^2)" },
+  { RDM_PREFIX_KILO,    "kilo (x10^3)" },
+  { RDM_PREFIX_MEGA,    "mega (x10^6)" },
+  { RDM_PREFIX_GIGA,    "giga (x10^9)" },
+  { RDM_PREFIX_TERRA,   "terra (x10^12)" },
+  { RDM_PREFIX_PETA,    "peta (x10^15)" },
+  { RDM_PREFIX_EXA,     "exa (x10^18)" },
+  { RDM_PREFIX_ZETTA,   "zetta (x10^21)" },
+  { RDM_PREFIX_YOTTA,   "yotta (x10^24)" },
+  { 0, NULL },
 };
 static value_string_ext rdm_prefix_vals_ext = VALUE_STRING_EXT_INIT(rdm_prefix_vals);
 
-#define RDM_UNITS_NONE			      0x00
-#define RDM_UNITS_CENTIGRADE		      0x01
-#define RDM_UNITS_VOLTS_DC		      0x02
-#define RDM_UNITS_VOLTS_AC_PEAK		      0x03
-#define RDM_UNITS_VOLTS_AC_RMS		      0x04
-#define RDM_UNITS_AMPERE_DC		      0x05
-#define RDM_UNITS_AMPERE_AC_PEAK	      0x06
-#define RDM_UNITS_AMPERE_AC_RMS		      0x07
-#define RDM_UNITS_HERTZ			      0x08
-#define RDM_UNITS_OHM			      0x09
-#define RDM_UNITS_WATT			      0x0A
-#define RDM_UNITS_KILOGRAM		      0x0B
-#define RDM_UNITS_METERS		      0x0C
-#define RDM_UNITS_METERS_SQUARED	      0x0D
-#define RDM_UNITS_METERS_CUBED		      0x0E
-#define RDM_UNITS_KILOGRAMMES_PER_METER_CUBED 0x0F
-#define RDM_UNITS_METERS_PER_SECOND	      0x10
-#define RDM_UNITS_METERS_PER_SECOND_SQUARED   0x11
-#define RDM_UNITS_NEWTON		      0x12
-#define RDM_UNITS_JOULE			      0x13
-#define RDM_UNITS_PASCAL		      0x14
-#define RDM_UNITS_SECOND		      0x15
-#define RDM_UNITS_DEGREE		      0x16
-#define RDM_UNITS_STERADIAN		      0x17
-#define RDM_UNITS_CANDELA		      0x18
-#define RDM_UNITS_LUMEN			      0x19
-#define RDM_UNITS_LUX			      0x1A
-#define RDM_UNITS_IRE			      0x1B
-#define RDM_UNITS_BYTE			      0x1C
+#define RDM_UNITS_NONE                         0x00
+#define RDM_UNITS_CENTIGRADE                   0x01
+#define RDM_UNITS_VOLTS_DC                     0x02
+#define RDM_UNITS_VOLTS_AC_PEAK                0x03
+#define RDM_UNITS_VOLTS_AC_RMS                 0x04
+#define RDM_UNITS_AMPERE_DC                    0x05
+#define RDM_UNITS_AMPERE_AC_PEAK               0x06
+#define RDM_UNITS_AMPERE_AC_RMS                0x07
+#define RDM_UNITS_HERTZ                        0x08
+#define RDM_UNITS_OHM                          0x09
+#define RDM_UNITS_WATT                         0x0A
+#define RDM_UNITS_KILOGRAM                     0x0B
+#define RDM_UNITS_METERS                       0x0C
+#define RDM_UNITS_METERS_SQUARED               0x0D
+#define RDM_UNITS_METERS_CUBED                 0x0E
+#define RDM_UNITS_KILOGRAMMES_PER_METER_CUBED  0x0F
+#define RDM_UNITS_METERS_PER_SECOND            0x10
+#define RDM_UNITS_METERS_PER_SECOND_SQUARED    0x11
+#define RDM_UNITS_NEWTON                       0x12
+#define RDM_UNITS_JOULE                        0x13
+#define RDM_UNITS_PASCAL                       0x14
+#define RDM_UNITS_SECOND                       0x15
+#define RDM_UNITS_DEGREE                       0x16
+#define RDM_UNITS_STERADIAN                    0x17
+#define RDM_UNITS_CANDELA                      0x18
+#define RDM_UNITS_LUMEN                        0x19
+#define RDM_UNITS_LUX                          0x1A
+#define RDM_UNITS_IRE                          0x1B
+#define RDM_UNITS_BYTE                         0x1C
 
 static const value_string rdm_unit_vals[] = {
-	{ RDM_UNITS_NONE,			 "NONE" },
-	{ RDM_UNITS_CENTIGRADE,			 "Centigrade" },
-	{ RDM_UNITS_VOLTS_DC,			 "Volts DC" },
-	{ RDM_UNITS_VOLTS_AC_PEAK,		 "Volts AC Peak" },
-	{ RDM_UNITS_VOLTS_AC_RMS,		 "Volts AC RMS" },
-	{ RDM_UNITS_AMPERE_DC,			 "Ampere DC" },
-	{ RDM_UNITS_AMPERE_AC_PEAK,		 "Ampere AC Peak" },
-	{ RDM_UNITS_AMPERE_AC_RMS,		 "Ampere AC RMS" },
-	{ RDM_UNITS_HERTZ,			 "Hertz" },
-	{ RDM_UNITS_OHM,			 "Ohm" },
-	{ RDM_UNITS_WATT,			 "Watt" },
-	{ RDM_UNITS_KILOGRAM,			 "Kilogram" },
-	{ RDM_UNITS_METERS,			 "Meters" },
-	{ RDM_UNITS_METERS_SQUARED,		 "Meters Squared" },
-	{ RDM_UNITS_METERS_CUBED,		 "Meters Cubed" },
-	{ RDM_UNITS_KILOGRAMMES_PER_METER_CUBED, "Kilogrammes per Meter Cubed" },
-	{ RDM_UNITS_METERS_PER_SECOND,		 "Meters per Second" },
-	{ RDM_UNITS_METERS_PER_SECOND_SQUARED,	 "Meters per Second Squared" },
-	{ RDM_UNITS_NEWTON,			 "Newton" },
-	{ RDM_UNITS_JOULE,			 "Joule" },
-	{ RDM_UNITS_PASCAL,			 "Pascal" },
-	{ RDM_UNITS_SECOND,			 "Second" },
-	{ RDM_UNITS_DEGREE,			 "Degree" },
-	{ RDM_UNITS_STERADIAN,			 "Steradian" },
-	{ RDM_UNITS_CANDELA,			 "Candela" },
-	{ RDM_UNITS_LUMEN,			 "Lumen" },
-	{ RDM_UNITS_LUX,			 "Lux" },
-	{ RDM_UNITS_IRE,			 "Ire" },
-	{ RDM_UNITS_BYTE,			 "Byte" },
-	{ 0, NULL },
+  { RDM_UNITS_NONE,                         "NONE" },
+  { RDM_UNITS_CENTIGRADE,                   "Centigrade" },
+  { RDM_UNITS_VOLTS_DC,                     "Volts DC" },
+  { RDM_UNITS_VOLTS_AC_PEAK,                "Volts AC Peak" },
+  { RDM_UNITS_VOLTS_AC_RMS,                 "Volts AC RMS" },
+  { RDM_UNITS_AMPERE_DC,                    "Ampere DC" },
+  { RDM_UNITS_AMPERE_AC_PEAK,               "Ampere AC Peak" },
+  { RDM_UNITS_AMPERE_AC_RMS,                "Ampere AC RMS" },
+  { RDM_UNITS_HERTZ,                        "Hertz" },
+  { RDM_UNITS_OHM,                          "Ohm" },
+  { RDM_UNITS_WATT,                         "Watt" },
+  { RDM_UNITS_KILOGRAM,                     "Kilogram" },
+  { RDM_UNITS_METERS,                       "Meters" },
+  { RDM_UNITS_METERS_SQUARED,               "Meters Squared" },
+  { RDM_UNITS_METERS_CUBED,                 "Meters Cubed" },
+  { RDM_UNITS_KILOGRAMMES_PER_METER_CUBED,  "Kilogrammes per Meter Cubed" },
+  { RDM_UNITS_METERS_PER_SECOND,            "Meters per Second" },
+  { RDM_UNITS_METERS_PER_SECOND_SQUARED,    "Meters per Second Squared" },
+  { RDM_UNITS_NEWTON,                       "Newton" },
+  { RDM_UNITS_JOULE,                        "Joule" },
+  { RDM_UNITS_PASCAL,                       "Pascal" },
+  { RDM_UNITS_SECOND,                       "Second" },
+  { RDM_UNITS_DEGREE,                       "Degree" },
+  { RDM_UNITS_STERADIAN,                    "Steradian" },
+  { RDM_UNITS_CANDELA,                      "Candela" },
+  { RDM_UNITS_LUMEN,                        "Lumen" },
+  { RDM_UNITS_LUX,                          "Lux" },
+  { RDM_UNITS_IRE,                          "Ire" },
+  { RDM_UNITS_BYTE,                         "Byte" },
+  { 0, NULL },
 };
 static value_string_ext rdm_unit_vals_ext = VALUE_STRING_EXT_INIT(rdm_unit_vals);
 
-#define RDM_SENS_TEMPERATURE	    0x00
-#define RDM_SENS_VOLTAGE	    0x01
-#define RDM_SENS_CURRENT	    0x02
-#define RDM_SENS_FREQUENCY	    0x03
-#define RDM_SENS_RESISTANCE	    0x04
-#define RDM_SENS_POWER		    0x05
-#define RDM_SENS_MASS		    0x06
-#define RDM_SENS_LENGTH		    0x07
-#define RDM_SENS_AREA		    0x08
-#define RDM_SENS_VOLUME		    0x09
-#define RDM_SENS_DENSITY	    0x0A
-#define RDM_SENS_VELOCITY	    0x0B
-#define RDM_SENS_ACCELERATION	    0x0C
-#define RDM_SENS_FORCE		    0x0D
-#define RDM_SENS_ENERGY		    0x0E
-#define RDM_SENS_PRESSURE	    0x0F
-#define RDM_SENS_TIME		    0x10
-#define RDM_SENS_ANGLE		    0x11
-#define RDM_SENS_POSITION_X	    0x12
-#define RDM_SENS_POSITION_Y	    0x13
-#define RDM_SENS_POSITION_Z	    0x14
-#define RDM_SENS_ANGULAR_VELOCITY   0x15
-#define RDM_SENS_LUMINOUS_INTENSITY 0x16
-#define RDM_SENS_LUMINOUS_FLUX	    0x17
-#define RDM_SENS_ILLUMINANCE	    0x18
-#define RDM_SENS_CHROMINANCE_RED    0x19
-#define RDM_SENS_CHROMINANCE_GREEN  0x1A
-#define RDM_SENS_CHROMINANCE_BLUE   0x1B
-#define RDM_SENS_CONTACTS	    0x1C
-#define RDM_SENS_MEMORY		    0x1D
-#define RDM_SENS_ITEMS		    0x1E
-#define RDM_SENS_HUMIDITY	    0x1F
-#define RDM_SENS_COUNTER_16BIT	    0x20
-#define RDM_SENS_OTHER		    0x7F
+#define RDM_SENS_TEMPERATURE         0x00
+#define RDM_SENS_VOLTAGE             0x01
+#define RDM_SENS_CURRENT             0x02
+#define RDM_SENS_FREQUENCY           0x03
+#define RDM_SENS_RESISTANCE          0x04
+#define RDM_SENS_POWER               0x05
+#define RDM_SENS_MASS                0x06
+#define RDM_SENS_LENGTH              0x07
+#define RDM_SENS_AREA                0x08
+#define RDM_SENS_VOLUME              0x09
+#define RDM_SENS_DENSITY             0x0A
+#define RDM_SENS_VELOCITY            0x0B
+#define RDM_SENS_ACCELERATION        0x0C
+#define RDM_SENS_FORCE               0x0D
+#define RDM_SENS_ENERGY              0x0E
+#define RDM_SENS_PRESSURE            0x0F
+#define RDM_SENS_TIME                0x10
+#define RDM_SENS_ANGLE               0x11
+#define RDM_SENS_POSITION_X          0x12
+#define RDM_SENS_POSITION_Y          0x13
+#define RDM_SENS_POSITION_Z          0x14
+#define RDM_SENS_ANGULAR_VELOCITY    0x15
+#define RDM_SENS_LUMINOUS_INTENSITY  0x16
+#define RDM_SENS_LUMINOUS_FLUX       0x17
+#define RDM_SENS_ILLUMINANCE         0x18
+#define RDM_SENS_CHROMINANCE_RED     0x19
+#define RDM_SENS_CHROMINANCE_GREEN   0x1A
+#define RDM_SENS_CHROMINANCE_BLUE    0x1B
+#define RDM_SENS_CONTACTS            0x1C
+#define RDM_SENS_MEMORY              0x1D
+#define RDM_SENS_ITEMS               0x1E
+#define RDM_SENS_HUMIDITY            0x1F
+#define RDM_SENS_COUNTER_16BIT       0x20
+#define RDM_SENS_OTHER               0x7F
 
 static const value_string rdm_sensor_type_vals[] = {
-	{ RDM_SENS_TEMPERATURE,		"Temperature" },
-	{ RDM_SENS_VOLTAGE,		"Voltage" },
-	{ RDM_SENS_CURRENT,		"Current" },
-	{ RDM_SENS_FREQUENCY,		"Frequency" },
-	{ RDM_SENS_RESISTANCE,		"Resistance" },
-	{ RDM_SENS_POWER,		"Power" },
-	{ RDM_SENS_MASS,		"Mass" },
-	{ RDM_SENS_LENGTH,		"Length" },
-	{ RDM_SENS_AREA,		"Area" },
-	{ RDM_SENS_VOLUME,		"Volume" },
-	{ RDM_SENS_DENSITY,		"Density" },
-	{ RDM_SENS_VELOCITY,		"Velocity" },
-	{ RDM_SENS_ACCELERATION,	"Acceleration" },
-	{ RDM_SENS_FORCE,		"Force" },
-	{ RDM_SENS_ENERGY,		"Energy" },
-	{ RDM_SENS_PRESSURE,		"Pressure" },
-	{ RDM_SENS_TIME,		"Time" },
-	{ RDM_SENS_ANGLE,		"Angle" },
-	{ RDM_SENS_POSITION_X,		"Position X" },
-	{ RDM_SENS_POSITION_Y,		"Position Y" },
-	{ RDM_SENS_POSITION_Z,		"Position Z" },
-	{ RDM_SENS_ANGULAR_VELOCITY,	"Angular Velocity" },
-	{ RDM_SENS_LUMINOUS_INTENSITY,	"Luminous Intensity" },
-	{ RDM_SENS_LUMINOUS_FLUX,	"Luminous Flux" },
-	{ RDM_SENS_ILLUMINANCE,		"Illuminance" },
-	{ RDM_SENS_CHROMINANCE_RED,	"Chrominance Red" },
-	{ RDM_SENS_CHROMINANCE_GREEN,	"Chrominance Green" },
-	{ RDM_SENS_CHROMINANCE_BLUE,	"Chrominance Blue" },
-	{ RDM_SENS_CONTACTS,		"Contacts" },
-	{ RDM_SENS_MEMORY,		"Memory" },
-	{ RDM_SENS_ITEMS,		"Items" },
-	{ RDM_SENS_HUMIDITY,		"Humidity" },
-	{ RDM_SENS_COUNTER_16BIT,	"Counter 16bit" },
-	{ RDM_SENS_OTHER,		"Other" },
-	{ 0, NULL} ,
+  { RDM_SENS_TEMPERATURE,          "Temperature" },
+  { RDM_SENS_VOLTAGE,             "Voltage" },
+  { RDM_SENS_CURRENT,             "Current" },
+  { RDM_SENS_FREQUENCY,           "Frequency" },
+  { RDM_SENS_RESISTANCE,          "Resistance" },
+  { RDM_SENS_POWER,               "Power" },
+  { RDM_SENS_MASS,                "Mass" },
+  { RDM_SENS_LENGTH,              "Length" },
+  { RDM_SENS_AREA,                "Area" },
+  { RDM_SENS_VOLUME,              "Volume" },
+  { RDM_SENS_DENSITY,             "Density" },
+  { RDM_SENS_VELOCITY,            "Velocity" },
+  { RDM_SENS_ACCELERATION,        "Acceleration" },
+  { RDM_SENS_FORCE,               "Force" },
+  { RDM_SENS_ENERGY,              "Energy" },
+  { RDM_SENS_PRESSURE,            "Pressure" },
+  { RDM_SENS_TIME,                "Time" },
+  { RDM_SENS_ANGLE,               "Angle" },
+  { RDM_SENS_POSITION_X,          "Position X" },
+  { RDM_SENS_POSITION_Y,          "Position Y" },
+  { RDM_SENS_POSITION_Z,          "Position Z" },
+  { RDM_SENS_ANGULAR_VELOCITY,    "Angular Velocity" },
+  { RDM_SENS_LUMINOUS_INTENSITY,  "Luminous Intensity" },
+  { RDM_SENS_LUMINOUS_FLUX,       "Luminous Flux" },
+  { RDM_SENS_ILLUMINANCE,         "Illuminance" },
+  { RDM_SENS_CHROMINANCE_RED,     "Chrominance Red" },
+  { RDM_SENS_CHROMINANCE_GREEN,   "Chrominance Green" },
+  { RDM_SENS_CHROMINANCE_BLUE,    "Chrominance Blue" },
+  { RDM_SENS_CONTACTS,            "Contacts" },
+  { RDM_SENS_MEMORY,              "Memory" },
+  { RDM_SENS_ITEMS,               "Items" },
+  { RDM_SENS_HUMIDITY,            "Humidity" },
+  { RDM_SENS_COUNTER_16BIT,       "Counter 16bit" },
+  { RDM_SENS_OTHER,               "Other" },
+  { 0, NULL} ,
 };
 static value_string_ext rdm_sensor_type_vals_ext = VALUE_STRING_EXT_INIT(rdm_sensor_type_vals);
 
-#define RDM_PRODUCT_CATEGORY_NOT_DECLARED		0x0000
-#define RDM_PRODUCT_CATEGORY_FIXTURE			0x0100
-#define RDM_PRODUCT_CATEGORY_FIXTURE_FIXED		0x0101
-#define RDM_PRODUCT_CATEGORY_FIXTURE_MOVING_YOKE	0x0102
-#define RDM_PRODUCT_CATEGORY_FIXTURE_MOVING_MIRROR	0x0103
-#define RDM_PRODUCT_CATEGORY_FIXTURE_OTHER		0x01FF
-#define RDM_PRODUCT_CATEGORY_FIXTURE_ACCESSORY		0x0200
-#define RDM_PRODUCT_CATEGORY_FIXTURE_ACCESSORY_COLOR	0x0201
-#define RDM_PRODUCT_CATEGORY_FIXTURE_ACCESSORY_YOKE	0x0202
-#define RDM_PRODUCT_CATEGORY_FIXTURE_ACCESSORY_MIRROR	0x0203
-#define RDM_PRODUCT_CATEGORY_FIXTURE_ACCESSORY_EFFECT	0x0204
-#define RDM_PRODUCT_CATEGORY_FIXTURE_ACCESSORY_BEAM	0x0205
-#define RDM_PRODUCT_CATEGORY_FIXTURE_ACCESSORY_OTHER	0x02FF
-#define RDM_PRODUCT_CATEGORY_PROJECTOR			0x0300
-#define RDM_PRODUCT_CATEGORY_PROJECTOR_FIXED		0x0301
-#define RDM_PRODUCT_CATEGORY_PROJECTOR_MOVING_YOKE	0x0302
-#define RDM_PRODUCT_CATEGORY_PROJECTOR_MOVING_MIRROR	0x0303
-#define RDM_PRODUCT_CATEGORY_PROJECTOR_OTHER		0x03FF
-#define RDM_PRODUCT_CATEGORY_ATMOSPHERIC		0x0400
-#define RDM_PRODUCT_CATEGORY_ATMOSPHERIC_EFFECT		0x0401
-#define RDM_PRODUCT_CATEGORY_ATMOSPHERIC_PYRO		0x0402
-#define RDM_PRODUCT_CATEGORY_ATMOSPHERIC_OTHER		0x04FF
-#define RDM_PRODUCT_CATEGORY_DIMMER			0x0500
-#define RDM_PRODUCT_CATEGORY_DIMMER_AC_INCANDESCENT	0x0501
-#define RDM_PRODUCT_CATEGORY_DIMMER_AC_FLUORESCENT	0x0502
-#define RDM_PRODUCT_CATEGORY_DIMMER_AC_COLDCATHODE	0x0503
-#define RDM_PRODUCT_CATEGORY_DIMMER_AC_NONDIM		0x0504
-#define RDM_PRODUCT_CATEGORY_DIMMER_AC_ELV		0x0505
-#define RDM_PRODUCT_CATEGORY_DIMMER_AC_OTHER		0x0506
-#define RDM_PRODUCT_CATEGORY_DIMMER_DC_LEVEL		0x0507
-#define RDM_PRODUCT_CATEGORY_DIMMER_DC_PWM		0x0508
-#define RDM_PRODUCT_CATEGORY_DIMMER_CS_LED		0x0509
-#define RDM_PRODUCT_CATEGORY_DIMMER_OTHER		0x05FF
-#define RDM_PRODUCT_CATEGORY_POWER			0x0600
-#define RDM_PRODUCT_CATEGORY_POWER_CONTROL		0x0601
-#define RDM_PRODUCT_CATEGORY_POWER_SOURCE		0x0602
-#define RDM_PRODUCT_CATEGORY_POWER_OTHER		0x06FF
-#define RDM_PRODUCT_CATEGORY_SCENIC			0x0700
-#define RDM_PRODUCT_CATEGORY_SCENIC_DRIVE		0x0701
-#define RDM_PRODUCT_CATEGORY_SCENIC_OTHER		0x07FF
-#define RDM_PRODUCT_CATEGORY_DATA			0x0800
-#define RDM_PRODUCT_CATEGORY_DATA_DISTRIBUTION		0x0801
-#define RDM_PRODUCT_CATEGORY_DATA_CONVERSION		0x0802
-#define RDM_PRODUCT_CATEGORY_DATA_OTHER			0x08FF
-#define RDM_PRODUCT_CATEGORY_AV				0x0900
-#define RDM_PRODUCT_CATEGORY_AV_AUDIO			0x0901
-#define RDM_PRODUCT_CATEGORY_AV_VIDEO			0x0902
-#define RDM_PRODUCT_CATEGORY_AV_OTHER			0x09FF
-#define RDM_PRODUCT_CATEGORY_MONITOR			0x0A00
-#define RDM_PRODUCT_CATEGORY_MONITOR_ACLINEPOWER	0x0A01
-#define RDM_PRODUCT_CATEGORY_MONITOR_DCPOWER		0x0A02
-#define RDM_PRODUCT_CATEGORY_MONITOR_ENVIRONMENTAL	0x0A03
-#define RDM_PRODUCT_CATEGORY_MONITOR_OTHER		0x0AFF
-#define RDM_PRODUCT_CATEGORY_CONTROL			0x7000
-#define RDM_PRODUCT_CATEGORY_CONTROL_CONTROLLER		0x7001
-#define RDM_PRODUCT_CATEGORY_CONTROL_BACKUPDEVICE	0x7002
-#define RDM_PRODUCT_CATEGORY_CONTROL_OTHER		0x70FF
-#define RDM_PRODUCT_CATEGORY_TEST			0x7100
-#define RDM_PRODUCT_CATEGORY_TEST_EQUIPMENT		0x7101
-#define RDM_PRODUCT_CATEGORY_TEST_EQUIPMENT_OTHER	0x71FF
-#define RDM_PRODUCT_CATEGORY_OTHER			0x7FFF
+#define RDM_PRODUCT_CATEGORY_NOT_DECLARED              0x0000
+#define RDM_PRODUCT_CATEGORY_FIXTURE                   0x0100
+#define RDM_PRODUCT_CATEGORY_FIXTURE_FIXED             0x0101
+#define RDM_PRODUCT_CATEGORY_FIXTURE_MOVING_YOKE       0x0102
+#define RDM_PRODUCT_CATEGORY_FIXTURE_MOVING_MIRROR     0x0103
+#define RDM_PRODUCT_CATEGORY_FIXTURE_OTHER             0x01FF
+#define RDM_PRODUCT_CATEGORY_FIXTURE_ACCESSORY         0x0200
+#define RDM_PRODUCT_CATEGORY_FIXTURE_ACCESSORY_COLOR   0x0201
+#define RDM_PRODUCT_CATEGORY_FIXTURE_ACCESSORY_YOKE    0x0202
+#define RDM_PRODUCT_CATEGORY_FIXTURE_ACCESSORY_MIRROR  0x0203
+#define RDM_PRODUCT_CATEGORY_FIXTURE_ACCESSORY_EFFECT  0x0204
+#define RDM_PRODUCT_CATEGORY_FIXTURE_ACCESSORY_BEAM    0x0205
+#define RDM_PRODUCT_CATEGORY_FIXTURE_ACCESSORY_OTHER   0x02FF
+#define RDM_PRODUCT_CATEGORY_PROJECTOR                 0x0300
+#define RDM_PRODUCT_CATEGORY_PROJECTOR_FIXED           0x0301
+#define RDM_PRODUCT_CATEGORY_PROJECTOR_MOVING_YOKE     0x0302
+#define RDM_PRODUCT_CATEGORY_PROJECTOR_MOVING_MIRROR   0x0303
+#define RDM_PRODUCT_CATEGORY_PROJECTOR_OTHER           0x03FF
+#define RDM_PRODUCT_CATEGORY_ATMOSPHERIC               0x0400
+#define RDM_PRODUCT_CATEGORY_ATMOSPHERIC_EFFECT        0x0401
+#define RDM_PRODUCT_CATEGORY_ATMOSPHERIC_PYRO          0x0402
+#define RDM_PRODUCT_CATEGORY_ATMOSPHERIC_OTHER         0x04FF
+#define RDM_PRODUCT_CATEGORY_DIMMER                    0x0500
+#define RDM_PRODUCT_CATEGORY_DIMMER_AC_INCANDESCENT    0x0501
+#define RDM_PRODUCT_CATEGORY_DIMMER_AC_FLUORESCENT     0x0502
+#define RDM_PRODUCT_CATEGORY_DIMMER_AC_COLDCATHODE     0x0503
+#define RDM_PRODUCT_CATEGORY_DIMMER_AC_NONDIM          0x0504
+#define RDM_PRODUCT_CATEGORY_DIMMER_AC_ELV             0x0505
+#define RDM_PRODUCT_CATEGORY_DIMMER_AC_OTHER           0x0506
+#define RDM_PRODUCT_CATEGORY_DIMMER_DC_LEVEL           0x0507
+#define RDM_PRODUCT_CATEGORY_DIMMER_DC_PWM             0x0508
+#define RDM_PRODUCT_CATEGORY_DIMMER_CS_LED             0x0509
+#define RDM_PRODUCT_CATEGORY_DIMMER_OTHER              0x05FF
+#define RDM_PRODUCT_CATEGORY_POWER                     0x0600
+#define RDM_PRODUCT_CATEGORY_POWER_CONTROL             0x0601
+#define RDM_PRODUCT_CATEGORY_POWER_SOURCE              0x0602
+#define RDM_PRODUCT_CATEGORY_POWER_OTHER               0x06FF
+#define RDM_PRODUCT_CATEGORY_SCENIC                    0x0700
+#define RDM_PRODUCT_CATEGORY_SCENIC_DRIVE              0x0701
+#define RDM_PRODUCT_CATEGORY_SCENIC_OTHER              0x07FF
+#define RDM_PRODUCT_CATEGORY_DATA                      0x0800
+#define RDM_PRODUCT_CATEGORY_DATA_DISTRIBUTION         0x0801
+#define RDM_PRODUCT_CATEGORY_DATA_CONVERSION           0x0802
+#define RDM_PRODUCT_CATEGORY_DATA_OTHER                0x08FF
+#define RDM_PRODUCT_CATEGORY_AV                        0x0900
+#define RDM_PRODUCT_CATEGORY_AV_AUDIO                  0x0901
+#define RDM_PRODUCT_CATEGORY_AV_VIDEO                  0x0902
+#define RDM_PRODUCT_CATEGORY_AV_OTHER                  0x09FF
+#define RDM_PRODUCT_CATEGORY_MONITOR                   0x0A00
+#define RDM_PRODUCT_CATEGORY_MONITOR_ACLINEPOWER       0x0A01
+#define RDM_PRODUCT_CATEGORY_MONITOR_DCPOWER           0x0A02
+#define RDM_PRODUCT_CATEGORY_MONITOR_ENVIRONMENTAL     0x0A03
+#define RDM_PRODUCT_CATEGORY_MONITOR_OTHER             0x0AFF
+#define RDM_PRODUCT_CATEGORY_CONTROL                   0x7000
+#define RDM_PRODUCT_CATEGORY_CONTROL_CONTROLLER        0x7001
+#define RDM_PRODUCT_CATEGORY_CONTROL_BACKUPDEVICE      0x7002
+#define RDM_PRODUCT_CATEGORY_CONTROL_OTHER             0x70FF
+#define RDM_PRODUCT_CATEGORY_TEST                      0x7100
+#define RDM_PRODUCT_CATEGORY_TEST_EQUIPMENT            0x7101
+#define RDM_PRODUCT_CATEGORY_TEST_EQUIPMENT_OTHER      0x71FF
+#define RDM_PRODUCT_CATEGORY_OTHER                     0x7FFF
 
 static const value_string rdm_product_cat_vals[] = {
-	{ RDM_PRODUCT_CATEGORY_NOT_DECLARED,		 "Not Declared" },
-	{ RDM_PRODUCT_CATEGORY_FIXTURE,			 "Fixture" },
-	{ RDM_PRODUCT_CATEGORY_FIXTURE_FIXED,		 "Fixture Fixed" },
-	{ RDM_PRODUCT_CATEGORY_FIXTURE_MOVING_YOKE,	 "Fixture Moving Yoke" },
-	{ RDM_PRODUCT_CATEGORY_FIXTURE_MOVING_MIRROR,	 "Fixture Moving Mirror" },
-	{ RDM_PRODUCT_CATEGORY_FIXTURE_OTHER,		 "Fixture Other" },
-	{ RDM_PRODUCT_CATEGORY_FIXTURE_ACCESSORY,	 "Fixture Accessory" },
-	{ RDM_PRODUCT_CATEGORY_FIXTURE_ACCESSORY_COLOR,	 "Fixture Accessory Color" },
-	{ RDM_PRODUCT_CATEGORY_FIXTURE_ACCESSORY_YOKE,	 "Fixture Accessory Yoke" },
-	{ RDM_PRODUCT_CATEGORY_FIXTURE_ACCESSORY_MIRROR, "Fixture Accessory Mirror" },
-	{ RDM_PRODUCT_CATEGORY_FIXTURE_ACCESSORY_EFFECT, "Fixture Accessory Effect" },
-	{ RDM_PRODUCT_CATEGORY_FIXTURE_ACCESSORY_BEAM,	 "Fixture Accessory Beam" },
-	{ RDM_PRODUCT_CATEGORY_FIXTURE_ACCESSORY_OTHER,	 "Fixture Accessory Other" },
-	{ RDM_PRODUCT_CATEGORY_PROJECTOR,		 "Projector" },
-	{ RDM_PRODUCT_CATEGORY_PROJECTOR_FIXED,		 "Projector Fixed" },
-	{ RDM_PRODUCT_CATEGORY_PROJECTOR_MOVING_YOKE,	 "Projector Moving Yoke" },
-	{ RDM_PRODUCT_CATEGORY_PROJECTOR_MOVING_MIRROR,	 "Projector Moving Mirror" },
-	{ RDM_PRODUCT_CATEGORY_PROJECTOR_OTHER,		 "Projector Other" },
-	{ RDM_PRODUCT_CATEGORY_ATMOSPHERIC,		 "Atmospheric" },
-	{ RDM_PRODUCT_CATEGORY_ATMOSPHERIC_EFFECT,	 "Atmospheric Effect" },
-	{ RDM_PRODUCT_CATEGORY_ATMOSPHERIC_PYRO,	 "Atmospheric Pyro" },
-	{ RDM_PRODUCT_CATEGORY_ATMOSPHERIC_OTHER,	 "Atmospheric Other" },
-	{ RDM_PRODUCT_CATEGORY_DIMMER,			 "Dimmer" },
-	{ RDM_PRODUCT_CATEGORY_DIMMER_AC_INCANDESCENT,	 "Dimmer AC Incandescent" },
-	{ RDM_PRODUCT_CATEGORY_DIMMER_AC_FLUORESCENT,	 "Dimmer AC Fluorescent" },
-	{ RDM_PRODUCT_CATEGORY_DIMMER_AC_COLDCATHODE,	 "Dimmer AC Coldcathode" },
-	{ RDM_PRODUCT_CATEGORY_DIMMER_AC_NONDIM,	 "Dimmer AC Nondim" },
-	{ RDM_PRODUCT_CATEGORY_DIMMER_AC_ELV,		 "Dimmer AC ELV" },
-	{ RDM_PRODUCT_CATEGORY_DIMMER_AC_OTHER,		 "Dimmer AC Other" },
-	{ RDM_PRODUCT_CATEGORY_DIMMER_DC_LEVEL,		 "Dimmer DC Level" },
-	{ RDM_PRODUCT_CATEGORY_DIMMER_DC_PWM,		 "Dimmer DC PWM" },
-	{ RDM_PRODUCT_CATEGORY_DIMMER_CS_LED,		 "Dimmer CS LED" },
-	{ RDM_PRODUCT_CATEGORY_DIMMER_OTHER,		 "Dimmer Other" },
-	{ RDM_PRODUCT_CATEGORY_POWER,			 "Power" },
-	{ RDM_PRODUCT_CATEGORY_POWER_CONTROL,		 "Power Control" },
-	{ RDM_PRODUCT_CATEGORY_POWER_SOURCE,		 "Power Source" },
-	{ RDM_PRODUCT_CATEGORY_POWER_OTHER,		 "Power Other" },
-	{ RDM_PRODUCT_CATEGORY_SCENIC,			 "Scenic" },
-	{ RDM_PRODUCT_CATEGORY_SCENIC_DRIVE,		 "Scenic Drive" },
-	{ RDM_PRODUCT_CATEGORY_SCENIC_OTHER,		 "Scenic Other" },
-	{ RDM_PRODUCT_CATEGORY_DATA,			 "Data" },
-	{ RDM_PRODUCT_CATEGORY_DATA_DISTRIBUTION,	 "Data Distribution" },
-	{ RDM_PRODUCT_CATEGORY_DATA_CONVERSION,		 "Data Conversion" },
-	{ RDM_PRODUCT_CATEGORY_DATA_OTHER,		 "Data Other" },
-	{ RDM_PRODUCT_CATEGORY_AV,			 "AV" },
-	{ RDM_PRODUCT_CATEGORY_AV_AUDIO,		 "AV Audio" },
-	{ RDM_PRODUCT_CATEGORY_AV_VIDEO,		 "AV Video" },
-	{ RDM_PRODUCT_CATEGORY_AV_OTHER,		 "AV Other" },
-	{ RDM_PRODUCT_CATEGORY_MONITOR,			 "Monitor" },
-	{ RDM_PRODUCT_CATEGORY_MONITOR_ACLINEPOWER,	 "Monitor AC Line Power" },
-	{ RDM_PRODUCT_CATEGORY_MONITOR_DCPOWER,		 "Monitor DC Power" },
-	{ RDM_PRODUCT_CATEGORY_MONITOR_ENVIRONMENTAL,	 "Monitor Environmental" },
-	{ RDM_PRODUCT_CATEGORY_MONITOR_OTHER,		 "Monitor Other" },
-	{ RDM_PRODUCT_CATEGORY_CONTROL,			 "Control" },
-	{ RDM_PRODUCT_CATEGORY_CONTROL_CONTROLLER,	 "Control Controller" },
-	{ RDM_PRODUCT_CATEGORY_CONTROL_BACKUPDEVICE,	 "Control Backup Device" },
-	{ RDM_PRODUCT_CATEGORY_CONTROL_OTHER,		 "Control Other" },
-	{ RDM_PRODUCT_CATEGORY_TEST,			 "Test" },
-	{ RDM_PRODUCT_CATEGORY_TEST_EQUIPMENT,		 "Test Equipment" },
-	{ RDM_PRODUCT_CATEGORY_TEST_EQUIPMENT_OTHER,	 "Test Equipment Other" },
-	{ RDM_PRODUCT_CATEGORY_OTHER,			 "Other" },
-	{ 0, NULL },
+  { RDM_PRODUCT_CATEGORY_NOT_DECLARED,              "Not Declared" },
+  { RDM_PRODUCT_CATEGORY_FIXTURE,                   "Fixture" },
+  { RDM_PRODUCT_CATEGORY_FIXTURE_FIXED,             "Fixture Fixed" },
+  { RDM_PRODUCT_CATEGORY_FIXTURE_MOVING_YOKE,       "Fixture Moving Yoke" },
+  { RDM_PRODUCT_CATEGORY_FIXTURE_MOVING_MIRROR,     "Fixture Moving Mirror" },
+  { RDM_PRODUCT_CATEGORY_FIXTURE_OTHER,             "Fixture Other" },
+  { RDM_PRODUCT_CATEGORY_FIXTURE_ACCESSORY,         "Fixture Accessory" },
+  { RDM_PRODUCT_CATEGORY_FIXTURE_ACCESSORY_COLOR,   "Fixture Accessory Color" },
+  { RDM_PRODUCT_CATEGORY_FIXTURE_ACCESSORY_YOKE,    "Fixture Accessory Yoke" },
+  { RDM_PRODUCT_CATEGORY_FIXTURE_ACCESSORY_MIRROR,  "Fixture Accessory Mirror" },
+  { RDM_PRODUCT_CATEGORY_FIXTURE_ACCESSORY_EFFECT,  "Fixture Accessory Effect" },
+  { RDM_PRODUCT_CATEGORY_FIXTURE_ACCESSORY_BEAM,    "Fixture Accessory Beam" },
+  { RDM_PRODUCT_CATEGORY_FIXTURE_ACCESSORY_OTHER,   "Fixture Accessory Other" },
+  { RDM_PRODUCT_CATEGORY_PROJECTOR,                 "Projector" },
+  { RDM_PRODUCT_CATEGORY_PROJECTOR_FIXED,           "Projector Fixed" },
+  { RDM_PRODUCT_CATEGORY_PROJECTOR_MOVING_YOKE,     "Projector Moving Yoke" },
+  { RDM_PRODUCT_CATEGORY_PROJECTOR_MOVING_MIRROR,   "Projector Moving Mirror" },
+  { RDM_PRODUCT_CATEGORY_PROJECTOR_OTHER,           "Projector Other" },
+  { RDM_PRODUCT_CATEGORY_ATMOSPHERIC,               "Atmospheric" },
+  { RDM_PRODUCT_CATEGORY_ATMOSPHERIC_EFFECT,        "Atmospheric Effect" },
+  { RDM_PRODUCT_CATEGORY_ATMOSPHERIC_PYRO,          "Atmospheric Pyro" },
+  { RDM_PRODUCT_CATEGORY_ATMOSPHERIC_OTHER,         "Atmospheric Other" },
+  { RDM_PRODUCT_CATEGORY_DIMMER,                    "Dimmer" },
+  { RDM_PRODUCT_CATEGORY_DIMMER_AC_INCANDESCENT,    "Dimmer AC Incandescent" },
+  { RDM_PRODUCT_CATEGORY_DIMMER_AC_FLUORESCENT,     "Dimmer AC Fluorescent" },
+  { RDM_PRODUCT_CATEGORY_DIMMER_AC_COLDCATHODE,     "Dimmer AC Coldcathode" },
+  { RDM_PRODUCT_CATEGORY_DIMMER_AC_NONDIM,          "Dimmer AC Nondim" },
+  { RDM_PRODUCT_CATEGORY_DIMMER_AC_ELV,             "Dimmer AC ELV" },
+  { RDM_PRODUCT_CATEGORY_DIMMER_AC_OTHER,           "Dimmer AC Other" },
+  { RDM_PRODUCT_CATEGORY_DIMMER_DC_LEVEL,           "Dimmer DC Level" },
+  { RDM_PRODUCT_CATEGORY_DIMMER_DC_PWM,             "Dimmer DC PWM" },
+  { RDM_PRODUCT_CATEGORY_DIMMER_CS_LED,             "Dimmer CS LED" },
+  { RDM_PRODUCT_CATEGORY_DIMMER_OTHER,              "Dimmer Other" },
+  { RDM_PRODUCT_CATEGORY_POWER,                     "Power" },
+  { RDM_PRODUCT_CATEGORY_POWER_CONTROL,             "Power Control" },
+  { RDM_PRODUCT_CATEGORY_POWER_SOURCE,              "Power Source" },
+  { RDM_PRODUCT_CATEGORY_POWER_OTHER,               "Power Other" },
+  { RDM_PRODUCT_CATEGORY_SCENIC,                    "Scenic" },
+  { RDM_PRODUCT_CATEGORY_SCENIC_DRIVE,              "Scenic Drive" },
+  { RDM_PRODUCT_CATEGORY_SCENIC_OTHER,              "Scenic Other" },
+  { RDM_PRODUCT_CATEGORY_DATA,                      "Data" },
+  { RDM_PRODUCT_CATEGORY_DATA_DISTRIBUTION,         "Data Distribution" },
+  { RDM_PRODUCT_CATEGORY_DATA_CONVERSION,           "Data Conversion" },
+  { RDM_PRODUCT_CATEGORY_DATA_OTHER,                "Data Other" },
+  { RDM_PRODUCT_CATEGORY_AV,                        "AV" },
+  { RDM_PRODUCT_CATEGORY_AV_AUDIO,                  "AV Audio" },
+  { RDM_PRODUCT_CATEGORY_AV_VIDEO,                  "AV Video" },
+  { RDM_PRODUCT_CATEGORY_AV_OTHER,                  "AV Other" },
+  { RDM_PRODUCT_CATEGORY_MONITOR,                   "Monitor" },
+  { RDM_PRODUCT_CATEGORY_MONITOR_ACLINEPOWER,       "Monitor AC Line Power" },
+  { RDM_PRODUCT_CATEGORY_MONITOR_DCPOWER,           "Monitor DC Power" },
+  { RDM_PRODUCT_CATEGORY_MONITOR_ENVIRONMENTAL,     "Monitor Environmental" },
+  { RDM_PRODUCT_CATEGORY_MONITOR_OTHER,             "Monitor Other" },
+  { RDM_PRODUCT_CATEGORY_CONTROL,                   "Control" },
+  { RDM_PRODUCT_CATEGORY_CONTROL_CONTROLLER,        "Control Controller" },
+  { RDM_PRODUCT_CATEGORY_CONTROL_BACKUPDEVICE,      "Control Backup Device" },
+  { RDM_PRODUCT_CATEGORY_CONTROL_OTHER,             "Control Other" },
+  { RDM_PRODUCT_CATEGORY_TEST,                      "Test" },
+  { RDM_PRODUCT_CATEGORY_TEST_EQUIPMENT,            "Test Equipment" },
+  { RDM_PRODUCT_CATEGORY_TEST_EQUIPMENT_OTHER,      "Test Equipment Other" },
+  { RDM_PRODUCT_CATEGORY_OTHER,                     "Other" },
+  { 0, NULL },
 };
 static value_string_ext rdm_product_cat_vals_ext = VALUE_STRING_EXT_INIT(rdm_product_cat_vals);
 
+/* E1.37-1 */
+#define RDM_PRESET_NOT_PROGRAMMED        0x00
+#define RDM_PRESET_PROGRAMMED            0x01
+#define RDM_PRESET_PROGRAMMED_READ_ONLY  0x02
+
+static const value_string rdm_preset_programmed_vals[] = {
+  { RDM_PRESET_NOT_PROGRAMMED,        "Preset Not Programmed" },
+  { RDM_PRESET_PROGRAMMED,            "Preset Programmed" },
+  { RDM_PRESET_PROGRAMMED_READ_ONLY,  "Preset Programmed Read Only" },
+  { 0, NULL },
+};
+
+/* E1.37-1 */
+#define RDM_MERGEMODE_DEFAULT   0x00
+#define RDM_MERGEMODE_HTP       0x01
+#define RDM_MERGEMODE_LTP       0x02
+#define RDM_MERGEMODE_DMX_ONLY  0x03
+#define RDM_MERGEMODE_OTHER     0xFF
+
+static const value_string rdm_mergemode_vals[] = {
+  { RDM_MERGEMODE_DEFAULT,   "Mergemode Default" },
+  { RDM_MERGEMODE_HTP,       "Mergemode Highest Takes Precedence" },
+  { RDM_MERGEMODE_LTP,       "Mergemode Last Takes Precedence" },
+  { RDM_MERGEMODE_DMX_ONLY,  "Mergemode DMX Only" },
+  { RDM_MERGEMODE_OTHER,     "Mergemode Other" },
+  { 0, NULL },
+};
+
+/* E1.37-2 */
+#define RDM_DHCP_STATUS_INACTIVE  0x00
+#define RDM_DHCP_STATUS_ACTIVE    0x01
+#define RDM_DHCP_STATUS_UNKNOWN   0x02
+
+static const value_string rdm_dhcp_status_vals[] = {
+  { RDM_DHCP_STATUS_INACTIVE,  "DHCP Status Inactive" },
+  { RDM_DHCP_STATUS_ACTIVE,    "DHCP Status Active" },
+  { RDM_DHCP_STATUS_UNKNOWN,   "DHCP Status Unknown" },
+  { 0, NULL },
+};
+
+/* E1.37-7 */
+#define RDM_DISCOVERY_STATE_INCOMPLETE   0x00
+#define RDM_DISCOVERY_STATE_INCREMENTAL  0x01
+#define RDM_DISCOVERY_STATE_FULL         0x02
+                                 /* skip 0x03 */
+#define RDM_DISCOVERY_STATE_NOT_ACTIVE   0x04
+
+static const value_string rdm_discovery_state_vals[] = {
+  { RDM_DISCOVERY_STATE_INCOMPLETE,   "Incomplete" },
+  { RDM_DISCOVERY_STATE_INCREMENTAL,  "Incremental" },
+  { RDM_DISCOVERY_STATE_FULL,         "Full" },
+  { RDM_DISCOVERY_STATE_NOT_ACTIVE,   "Not Active" },
+  { 0, NULL },
+};
+
+/* E1.37-7 */
+#define RDM_ENDPOINT_MODE_DISABLED  0x00
+#define RDM_ENDPOINT_MODE_INPUT     0x01
+#define RDM_ENDPOINT_MODE_OUTPUT    0x02
+
+static const value_string rdm_endpoint_mode_vals[] = {
+  { RDM_ENDPOINT_MODE_DISABLED,  "Disabled" },
+  { RDM_ENDPOINT_MODE_INPUT,     "Input" },
+  { RDM_ENDPOINT_MODE_OUTPUT,    "Output" },
+  { 0, NULL },
+};
+
+/* E1.37-7 */
+#define RDM_ENDPOINT_TYPE_VIRTUAL   0x00
+#define RDM_ENDPOINT_TYPE_PHYSICAL  0x01
+
+static const value_string rdm_endpoint_type_vals[] = {
+  { RDM_ENDPOINT_TYPE_VIRTUAL,   "Virtual" },
+  { RDM_ENDPOINT_TYPE_PHYSICAL,  "Physical" },
+  { 0, NULL },
+};
+
+/* E1.33 Table A-17 Static Config Types for Component Scope Messages */
+#define RDMNET_COMPONENT_SCOPE_NO_STATIC_CONFIG    0x00
+#define RDMNET_COMPONENT_SCOPE_STATIC_CONFIG_IPV4  0x01
+#define RDMNET_COMPONENT_SCOPE_STATIC_CONFIG_IPV6  0x02
+
+static const value_string rdmnet_component_scope_static_config_type_vals[] = {
+  { RDMNET_COMPONENT_SCOPE_NO_STATIC_CONFIG,   "No Static Config" },
+  { RDMNET_COMPONENT_SCOPE_STATIC_CONFIG_IPV4, "Static Config IPv4" },
+  { RDMNET_COMPONENT_SCOPE_STATIC_CONFIG_IPV6, "Static Config IPv6" },
+  { 0, NULL }
+};
+/* E1.33 Table A-18 Broker States for Broker Status Messages */
+#define RDMNET_BROKER_STATE_DISABLED  0x00
+#define RDMNET_BROKER_STATE_ACTIVE    0x01
+#define RDMNET_BROKER_STATE_STANDBY   0x02
+
+static const value_string rdmnet_broker_status_states_vals[] = {
+  { RDMNET_BROKER_STATE_DISABLED, "Broker State Disabled" },
+  { RDMNET_BROKER_STATE_ACTIVE,   "Broker State Active" },
+  { RDMNET_BROKER_STATE_STANDBY,  "Broker State Standby" },
+  { 0, NULL }
+};
+
+static const value_string true_false_vals[] = {
+  { 0x00,  "False" },
+  { 0x01,  "True" },
+  { 0, NULL },
+};
+
+static const value_string enabled_disabled_vals[] = {
+  { 0x00,  "Disabled" },
+  { 0x01,  "Enabled" },
+  { 0, NULL },
+};
+
+static const value_string on_off_vals[] = {
+  { 0x00,  "Off" },
+  { 0x01,  "On" },
+  { 0, NULL },
+};
+
 static int proto_rdm = -1;
 
 static int hf_rdm_sub_start_code = -1;
@@ -669,2207 +947,5972 @@ static int hf_rdm_pd_status_id_description = -1;
 static int hf_rdm_pd_sub_device_status_report_threshold_status_type = -1;
 static int hf_rdm_pd_product_detail_id_list = -1;
 static int hf_rdm_pd_factory_defaults = -1;
+static int hf_rdm_pd_background_discovery_endpoint_id = -1;
+static int hf_rdm_pd_background_discovery_enabled = -1;
+static int hf_rdm_pd_background_queued_status_policy_current_policy = -1;
+static int hf_rdm_pd_background_queued_status_policy_number_of_policies = -1;
+static int hf_rdm_pd_background_queued_status_policy_description_policy = -1;
+static int hf_rdm_pd_background_queued_status_policy_description_description = -1;
+static int hf_rdm_pd_binding_control_fields_endpoint_id = -1;
+static int hf_rdm_pd_binding_control_fields_uid = -1;
+static int hf_rdm_pd_binding_control_fields_control_field = -1;
+static int hf_rdm_pd_binding_control_fields_binding_uid = -1;
+static int hf_rem_pd_broker_status_set_allowed = -1;
+static int hf_rem_pd_broker_status_state = -1;
+static int hf_rdm_pd_burn_in = -1;
+static int hf_rdm_pd_component_scope_scope_slot = -1;
+static int hf_rdm_pd_component_scope_scope_string = -1;
+static int hf_rdm_pd_component_scope_scope_static_config_type = -1;
+static int hf_rdm_pd_component_scope_scope_static_ipv4_address = -1;
+static int hf_rdm_pd_component_scope_scope_static_ipv6_address = -1;
+static int hf_rdm_pd_component_scope_scope_static_port = -1;
+static int hf_rdm_pd_current_address_interface_identifier = -1;
+static int hf_rdm_pd_current_address_ipv4_address = -1;
+static int hf_rdm_pd_current_address_netmask = -1;
+static int hf_rdm_pd_current_address_dhcp_status = -1;
+static int hf_rdm_pd_curve_curve = -1;
+static int hf_rdm_pd_curve_number_of_curves = -1;
+static int hf_rdm_pd_curve_description_curve = -1;
+static int hf_rdm_pd_curve_description_text = -1;
+static int hf_rdm_pd_dhcp_mode_interface_identifier = -1;
+static int hf_rdm_pd_dhcp_mode_enabled = -1;
+static int hf_rdm_pd_dimmer_info_minimum_level_lower_limit = -1;
+static int hf_rdm_pd_dimmer_info_minimum_level_upper_limit = -1;
+static int hf_rdm_pd_dimmer_info_maximum_level_lower_limit = -1;
+static int hf_rdm_pd_dimmer_info_maximum_level_upper_limit = -1;
+static int hf_rdm_pd_dimmer_info_number_of_supported_curves = -1;
+static int hf_rdm_pd_dimmer_info_levels_resolution = -1;
+static int hf_rdm_pd_dimmer_info_minimum_level_split_levels_supported = -1;
+static int hf_rdm_pd_discovery_state_endpoint_id = -1;
+static int hf_rdm_pd_discovery_state_device_count = -1;
+static int hf_rdm_pd_discovery_state_discovery_state = -1;
+static int hf_rdm_pd_dmx_block_address_base_dmx_address = -1;
+static int hf_rdm_pd_dmx_block_address_subdevice_footprint = -1;
+static int hf_rdm_pd_dmx_fail_mode_scene_number = -1;
+static int hf_rdm_pd_dmx_fail_mode_loss_of_signal_delay = -1;
+static int hf_rdm_pd_dmx_fail_mode_hold_time = -1;
+static int hf_rdm_pd_dmx_fail_mode_level = -1;
 static int hf_rdm_pd_dmx_pers_nr = -1;
 static int hf_rdm_pd_dmx_pers_count = -1;
 static int hf_rdm_pd_dmx_pers_requested = -1;
 static int hf_rdm_pd_dmx_pers_slots = -1;
 static int hf_rdm_pd_dmx_pers_text = -1;
+static int hf_rdm_pd_dmx_startup_mode_scene_number = -1;
+static int hf_rdm_pd_dmx_startup_mode_loss_of_signal_delay = -1;
+static int hf_rdm_pd_dmx_startup_mode_hold_time = -1;
+static int hf_rdm_pd_dmx_startup_mode_level = -1;
+static int hf_rdm_pd_dns_domain_name = -1;
+static int hf_rdm_pd_dns_hostname = -1;
+static int hf_rdm_pd_dns_ipv4_name_server_index = -1;
+static int hf_rdm_pd_dns_ipv4_name_server_address = -1;
+static int hf_rdm_pd_endpoint_label_endpoint_id = -1;
+static int hf_rdm_pd_endpoint_label_label = -1;
+static int hf_rdm_pd_endpoint_list_change_number = -1;
+static int hf_rdm_pd_endpoint_list_endpoint_id = -1;
+static int hf_rdm_pd_endpoint_list_endpoint_type = -1;
+static int hf_rdm_pd_endpoint_list_change_change_number = -1;
+static int hf_rdm_pd_endpoint_mode_endpoint_id = -1;
+static int hf_rdm_pd_endpoint_mode_endpoint_mode = -1;
+static int hf_rdm_pd_endpoint_responder_list_change_endpoint_id = -1;
+static int hf_rdm_pd_endpoint_responder_list_change_change_number = -1;
+static int hf_rdm_pd_endpoint_responders_endpoint_id = -1;
+static int hf_rdm_pd_endpoint_responders_change_number = -1;
+static int hf_rdm_pd_endpoint_responders_uid = -1;
+static int hf_rdm_pd_endpoint_timing_endpoint_id = -1;
+static int hf_rdm_pd_endpoint_timing_setting = -1;
+static int hf_rdm_pd_endpoint_timing_number_of_settings = -1;
+static int hf_rdm_pd_endpoint_timing_description_setting = -1;
+static int hf_rdm_pd_endpoint_timing_description_description = -1;
+static int hf_rdm_pd_endpoint_to_universe_endpoint_id = -1;
+static int hf_rdm_pd_endpoint_to_universe_universe_number = -1;
+static int hf_rdm_pd_hardware_address_type1_interface_identifier = -1;
+static int hf_rdm_pd_hardware_address_type1_hardware_address = -1;
+static int hf_rdm_pd_identify_endpoint_endpoint_id = -1;
+static int hf_rdm_pd_identify_endpoint_identify_state = -1;
+static int hf_rdm_pd_identify_mode = -1;
+static int hf_rdm_pd_interface_apply_configuration_interface_identifier = -1;
+static int hf_rdm_pd_interface_label_interface_identifier = -1;
+static int hf_rdm_pd_interface_label_label = -1;
+static int hf_rdm_pd_interface_release_dhcp_interface_identifier = -1;
+static int hf_rdm_pd_interface_renew_dhcp_interface_identifier = -1;
+static int hf_rdm_pd_ipv4_default_route_interface_identifier = -1;
+static int hf_rdm_pd_ipv4_default_route_ipv4_default_route = -1;
+static int hf_rdm_pd_list_interfaces_interface_identifier = -1;
+static int hf_rdm_pd_list_interfaces_interface_hardware_type = -1;
+static int hf_rdm_pd_lock_pin_pin_code = -1;
+static int hf_rdm_pd_lock_pin_new_pin_code = -1;
+static int hf_rdm_pd_lock_state_lock_state = -1;
+static int hf_rdm_pd_lock_state_number_of_lock_states = -1;
+static int hf_rdm_pd_lock_state_pin_code = -1;
+static int hf_rdm_pd_lock_state_description_lock_state = -1;
+static int hf_rdm_pd_lock_state_description_text = -1;
+static int hf_rdm_pd_maximum_level_level = -1;
+static int hf_rdm_pd_preset_mergemode = -1;
+static int hf_rdm_pd_power_on_self_test = -1;
+static int hf_rdm_pd_minimum_level_increasing = -1;
+static int hf_rdm_pd_minimum_level_decreasing = -1;
+static int hf_rdm_pd_minimum_level_on_below_minimum = -1;
+static int hf_rdm_pd_modulation_frequency_modulation_frequency = -1;
+static int hf_rdm_pd_modulation_frequency_number_of_modulation_frequencies = -1;
+static int hf_rdm_pd_modulation_frequency_description_modulation_frequency = -1;
+static int hf_rdm_pd_modulation_frequency_description_text = -1;
+static int hf_rdm_pd_output_response_time_response_time = -1;
+static int hf_rdm_pd_output_response_time_number_of_response_times = -1;
+static int hf_rdm_pd_output_response_time_description_output_response_time = -1;
+static int hf_rdm_pd_output_response_time_description_text = -1;
+static int hf_rdm_pd_preset_info_level_field_supported = -1;
+static int hf_rdm_pd_preset_info_preset_sequence_supported = -1;
+static int hf_rdm_pd_preset_info_split_times_supported = -1;
+static int hf_rdm_pd_preset_info_dmx_fail_infinite_delay_time_supported = -1;
+static int hf_rdm_pd_preset_info_dmx_fail_infinite_hold_time_supported = -1;
+static int hf_rdm_pd_preset_info_start_up_infinite_hold_time_supported = -1;
+static int hf_rdm_pd_preset_info_maximum_scene_number = -1;
+static int hf_rdm_pd_preset_info_minimum_preset_fade_time_supported = -1;
+static int hf_rdm_pd_preset_info_maximum_preset_fade_time_supported = -1;
+static int hf_rdm_pd_preset_info_minimum_preset_wait_time_supported = -1;
+static int hf_rdm_pd_preset_info_maximum_preset_wait_time_supported = -1;
+static int hf_rdm_pd_preset_info_minimum_dmx_fail_delay_time_supported = -1;
+static int hf_rdm_pd_preset_info_maximum_dmx_fail_delay_time_supported = -1;
+static int hf_rdm_pd_preset_info_minimum_dmx_fail_hold_time_supported = -1;
+static int hf_rdm_pd_preset_info_maximum_dmx_fail_hold_time_supported = -1;
+static int hf_rdm_pd_preset_info_minimum_start_up_delay_time_supported = -1;
+static int hf_rdm_pd_preset_info_maximum_start_up_delay_time_supported = -1;
+static int hf_rdm_pd_preset_info_minimum_start_up_hold_time_supported = -1;
+static int hf_rdm_pd_preset_info_maximum_start_up_hold_time_supported = -1;
+static int hf_rdm_pd_preset_status_scene_number = -1;
+static int hf_rdm_pd_preset_status_up_fade_time = -1;
+static int hf_rdm_pd_preset_status_down_fade_time = -1;
+static int hf_rdm_pd_preset_status_wait_time = -1;
+static int hf_rdm_pd_preset_status_programmed = -1;
+static int hf_rdm_pd_preset_status_clear_preset = -1;
+static int hf_rdm_pd_rdm_traffic_enable_endpoint_id = -1;
+static int hf_rdm_pd_rdm_traffic_enable_rdm_enabled = -1;
+static int hf_rdm_pd_search_domain_dns_domain_name = -1;
 static int hf_rdm_pd_slot_offset = -1;
 static int hf_rdm_pd_slot_type = -1;
 static int hf_rdm_pd_slot_label_id = -1;
 static int hf_rdm_pd_slot_nr = -1;
 static int hf_rdm_pd_slot_description = -1;
 static int hf_rdm_pd_slot_value = -1;
+static int hf_rdm_pd_static_address_interface_identifier = -1;
+static int hf_rdm_pd_static_address_ipv4_address = -1;
+static int hf_rdm_pd_static_address_netmask = -1;
+static int hf_rdm_pd_tcp_comms_status_scope_string = -1;
+static int hf_rdm_pd_tcp_comms_status_broker_ipv4_address = -1;
+static int hf_rdm_pd_tcp_comms_status_broker_ipv6_address = -1;
+static int hf_rdm_pd_tcp_comms_status_broker_port = -1;
+static int hf_rdm_pd_tcp_comms_status_unhealthy_tcp_events = -1;
+static int hf_rdm_pd_zeroconf_mode_interface_identifier = -1;
+static int hf_rdm_pd_zeroconf_mode_enabled = -1;
 static int hf_rdm_pd_rec_value_support = -1;
 
 static int ett_rdm = -1;
 
 static expert_field ei_rdm_checksum = EI_INIT;
 
+/* begin manufacturer-specific constants and variables */
+/* begin ETC */
+
+/* ETC manufacturer-specific PIDs */
+#define ETC_PARAM_ID_LED_CURVE                             0x8101
+#define ETC_PARAM_ID_LED_CURVE_DESCRIPTION                 0x8102
+#define ETC_PARAM_ID_LED_STROBE                            0x8103
+#define ETC_PARAM_ID_LED_OUTPUT_MODE                       0x8104
+#define ETC_PARAM_ID_LED_OUTPUT_MODE_DESCRIPTION           0x8105
+#define ETC_PARAM_ID_LED_RED_SHIFT                         0x8106
+#define ETC_PARAM_ID_LED_WHITE_POINT                       0x8107
+#define ETC_PARAM_ID_LED_WHITE_POINT_DESCRIPTION           0x8108
+#define ETC_PARAM_ID_LED_FREQUENCY                         0x8109
+#define ETC_PARAM_ID_DMX_LOSS_BEHAVIOR                     0x810A
+#define ETC_PARAM_ID_DMX_LOSS_BEHAVIOR_DESCRIPTION         0x810B
+#define ETC_PARAM_ID_LED_PLUS_SEVEN                        0x810C
+#define ETC_PARAM_ID_BACKLIGHT_BRIGHTNESS                  0x810D
+#define ETC_PARAM_ID_BACKLIGHT_TIMEOUT                     0x810E
+#define ETC_PARAM_ID_STATUS_INDICATORS                     0x810F
+#define ETC_PARAM_ID_RECALIBRATE_FIXTURE                   0x8110
+#define ETC_PARAM_ID_OVERTEMPMODE                          0x8111
+#define ETC_PARAM_ID_SIMPLESETUPMODE                       0x8112
+#define ETC_PARAM_ID_LED_STROBE_DESCRIPTION                0x8113
+#define ETC_PARAM_ID_LED_RED_SHIFT_DESCRIPTION             0x8114
+#define ETC_PARAM_ID_LED_PLUS_SEVEN_DESCRIPTION            0x8115
+#define ETC_PARAM_ID_BACKLIGHT_TIMEOUT_DESCRIPTION         0x8116
+#define ETC_PARAM_ID_SIMPLESETUPMODE_DESCRIPTION           0x8117
+#define ETC_PARAM_ID_OVERTEMPMODE_DESCRIPTION              0x8118
+#define ETC_PARAM_ID_LED_REQUESTED_XY                      0x8119
+#define ETC_PARAM_ID_LED_CURRENT_XY                        0x811A
+#define ETC_PARAM_ID_LED_CURRENT_PWM                       0x811B
+#define ETC_PARAM_ID_LED_TRISTIMULUS                       0x811C
+#define ETC_PARAM_ID_LED_INFORMATION                       0x811D
+#define ETC_PARAM_ID_PRESETCONFIG                          0x811E
+#define ETC_PARAM_ID_SEQUENCE_PLAYBACK                     0x811F
+#define ETC_PARAM_ID_SEQUENCE_CONFIG                       0x8120
+#define ETC_PARAM_ID_LOW_POWER_TIMEOUT                     0x8121
+#define ETC_PARAM_ID_LOW_POWER_TIMEOUT_DESCRIPTION         0x8122
+#define ETC_PARAM_ID_LED_ENUM_FREQUENCY                    0x8123
+#define ETC_PARAM_ID_LED_ENUM_FREQUENCY_DESCRIPTION        0x8124
+#define ETC_PARAM_ID_RGBI_PRESETCONFIG                     0x8125
+#define ETC_PARAM_ID_CCT_PRESETCONFIG                      0x8126
+#define ETC_PARAM_ID_SUPPLEMENTARY_DEVICE_VERSION          0x8130
+/* do not display
+#define ETC_PARAM_ID_START_UWB_DISCOVER                    0x8150
+#define ETC_PARAM_ID_START_UWB_MEASURE                     0x8151
+#define ETC_PARAM_ID_POSITION                              0x8152
+*/
+#define ETC_PARAM_ID_S4DIM_CALIBRATE                       0x9000
+#define ETC_PARAM_ID_S4DIM_CALIBRATE_DESCRIPTION           0x9001
+#define ETC_PARAM_ID_S4DIM_TEST_MODE                       0x9002
+#define ETC_PARAM_ID_S4DIM_TEST_MODE_DESCRIPTION           0x9003
+#define ETC_PARAM_ID_S4DIM_MAX_OUTPUT_VOLTAGE              0x9004
+#define ETC_PARAM_ID_S4DIM_MAX_OUTPUT_VOLTAGE_DESCRIPTION  0x9005
+#define ETC_PARAM_ID_POWER_COMMAND                         0xA000
+#define ETC_PARAM_ID_POWER_COMMAND_DESCRIPTION             0xA001
+#define ETC_PARAM_ID_THRESHOLD_COMMAND                     0xA002
+#define ETC_PARAM_ID_TURNON_DELAY_COMMAND                  0xA003
+#define ETC_PARAM_ID_SET_DALI_SHORTADDRESS                 0xA004
+#define ETC_PARAM_ID_DALI_GROUP_MEMBERSHIP                 0xA005
+#define ETC_PARAM_ID_AUTOBIND                              0xA006
+#define ETC_PARAM_ID_DELETE_SUBDEVICE                      0xA007
+#define ETC_PARAM_ID_PACKET_DELAY                          0xB000
+#define ETC_PARAM_ID_HAS_ENUM_TEXT                         0xE000
+#define ETC_PARAM_ID_GET_ENUM_TEXT                         0xE001
+#define ETC_PARAM_ID_PREPAREFORSOFTWAREDOWNLOAD            0xF000
+
+static const value_string etc_param_id_vals[] = {
+  { ETC_PARAM_ID_LED_CURVE,                             "LED Curve" },
+  { ETC_PARAM_ID_LED_CURVE_DESCRIPTION,                 "LED Curve Description" },
+  { ETC_PARAM_ID_LED_STROBE,                            "LED Strobe" },
+  { ETC_PARAM_ID_LED_OUTPUT_MODE,                       "LED Output Mode" },
+  { ETC_PARAM_ID_LED_OUTPUT_MODE_DESCRIPTION,           "LED Output Mode Description" },
+  { ETC_PARAM_ID_LED_RED_SHIFT,                         "LED Red Shift" },
+  { ETC_PARAM_ID_LED_WHITE_POINT,                       "LED White Point" },
+  { ETC_PARAM_ID_LED_WHITE_POINT_DESCRIPTION,           "LED White Point Description" },
+  { ETC_PARAM_ID_LED_FREQUENCY,                         "LED Frequency" },
+  { ETC_PARAM_ID_DMX_LOSS_BEHAVIOR,                     "DMX Loss Behavior" },
+  { ETC_PARAM_ID_DMX_LOSS_BEHAVIOR_DESCRIPTION,         "DMX Loss Behavior Description" },
+  { ETC_PARAM_ID_LED_PLUS_SEVEN,                        "LED Plus Seven" },
+  { ETC_PARAM_ID_BACKLIGHT_BRIGHTNESS,                  "Backlight Brightness" },
+  { ETC_PARAM_ID_BACKLIGHT_TIMEOUT,                     "Backlight Timeout" },
+  { ETC_PARAM_ID_STATUS_INDICATORS,                     "Status Indicators" },
+  { ETC_PARAM_ID_RECALIBRATE_FIXTURE,                   "Recalibrate Fixture" },
+  { ETC_PARAM_ID_OVERTEMPMODE,                          "Overtemp Mode" },
+  { ETC_PARAM_ID_SIMPLESETUPMODE,                       "Simple Setup Mode" },
+  { ETC_PARAM_ID_LED_STROBE_DESCRIPTION,                "LED Strobe Description" },
+  { ETC_PARAM_ID_LED_RED_SHIFT_DESCRIPTION,             "LED Red Shift Description" },
+  { ETC_PARAM_ID_LED_PLUS_SEVEN_DESCRIPTION,            "LED Plus Seven Description" },
+  { ETC_PARAM_ID_BACKLIGHT_TIMEOUT_DESCRIPTION,         "Backlight Timeout Description" },
+  { ETC_PARAM_ID_SIMPLESETUPMODE_DESCRIPTION,           "Simple Setup Mode Description" },
+  { ETC_PARAM_ID_OVERTEMPMODE_DESCRIPTION,              "Overtemp Mode Description" },
+  { ETC_PARAM_ID_LED_REQUESTED_XY,                      "LED Requested XY" },
+  { ETC_PARAM_ID_LED_CURRENT_XY,                        "LED Current XY" },
+  { ETC_PARAM_ID_LED_CURRENT_PWM,                       "LED Current PWM" },
+  { ETC_PARAM_ID_LED_TRISTIMULUS,                       "LED Tristimulus" },
+  { ETC_PARAM_ID_LED_INFORMATION,                       "LED Information" },
+  { ETC_PARAM_ID_PRESETCONFIG,                          "Preset Config" },
+  { ETC_PARAM_ID_SEQUENCE_PLAYBACK,                     "Sequence Playback" },
+  { ETC_PARAM_ID_SEQUENCE_CONFIG,                       "Sequence Config" },
+  { ETC_PARAM_ID_LOW_POWER_TIMEOUT,                     "Low Power Timeout" },
+  { ETC_PARAM_ID_LOW_POWER_TIMEOUT_DESCRIPTION,         "Low Power Timeout Description" },
+  { ETC_PARAM_ID_LED_ENUM_FREQUENCY,                    "LED Enum Frequency" },
+  { ETC_PARAM_ID_LED_ENUM_FREQUENCY_DESCRIPTION,        "LED Enum Frequency Description" },
+  { ETC_PARAM_ID_RGBI_PRESETCONFIG,                     "RGBI Preset Config" },
+  { ETC_PARAM_ID_CCT_PRESETCONFIG,                      "CCT Preset Config" },
+  { ETC_PARAM_ID_SUPPLEMENTARY_DEVICE_VERSION,          "Supplementary Device Version" },
+  /* do not display
+  { ETC_PARAM_ID_START_UWB_DISCOVER,                    "Start UWB Discover" },
+  { ETC_PARAM_ID_START_UWB_MEASURE,                     "Start UWB Measure" },
+  { ETC_PARAM_ID_POSITION,                              "Position" },
+  */
+  { ETC_PARAM_ID_S4DIM_CALIBRATE,                       "S4Dimmer Calibrate" },
+  { ETC_PARAM_ID_S4DIM_CALIBRATE_DESCRIPTION,           "S4Dimmer Calibrate Description" },
+  { ETC_PARAM_ID_S4DIM_TEST_MODE,                       "S4Dimmer Test Mode" },
+  { ETC_PARAM_ID_S4DIM_TEST_MODE_DESCRIPTION,           "S4Dimmer Test Mode Description" },
+  { ETC_PARAM_ID_S4DIM_MAX_OUTPUT_VOLTAGE,              "S4Dimmer Max Output Voltage" },
+  { ETC_PARAM_ID_S4DIM_MAX_OUTPUT_VOLTAGE_DESCRIPTION,  "S4Dimmer Max Output Voltage Description" },
+  { ETC_PARAM_ID_POWER_COMMAND,                         "Power Command" },
+  { ETC_PARAM_ID_POWER_COMMAND_DESCRIPTION,             "Power Command Description" },
+  { ETC_PARAM_ID_THRESHOLD_COMMAND,                     "Threshold Command" },
+  { ETC_PARAM_ID_TURNON_DELAY_COMMAND,                  "Turn On Delay Command" },
+  { ETC_PARAM_ID_SET_DALI_SHORTADDRESS,                 "Set DALI Short Address" },
+  { ETC_PARAM_ID_DALI_GROUP_MEMBERSHIP,                 "DALI Group Membership" },
+  { ETC_PARAM_ID_AUTOBIND,                              "Auto Bind" },
+  { ETC_PARAM_ID_DELETE_SUBDEVICE,                      "Delete Subdevice" },
+  { ETC_PARAM_ID_PACKET_DELAY,                          "Packet Delay" },
+  { ETC_PARAM_ID_HAS_ENUM_TEXT,                         "Has Enum Text" },
+  { ETC_PARAM_ID_GET_ENUM_TEXT,                         "Get Enum Text" },
+  { ETC_PARAM_ID_PREPAREFORSOFTWAREDOWNLOAD,            "Prepare For Software Load" },
+  { 0, NULL },
+};
+
+value_string_ext etc_param_id_vals_ext = VALUE_STRING_EXT_INIT(etc_param_id_vals);
+
+#define ETC_LED_CURVE_STANDARD      0x00
+#define ETC_LED_CURVE_INCANDESCENT  0x01
+#define ETC_LED_CURVE_LINEAR        0x02
+#define ETC_LED_CURVE_QUICK         0x03
+
+static const value_string etc_led_curve_vals[] = {
+  { ETC_LED_CURVE_STANDARD,      "Standard" },
+  { ETC_LED_CURVE_INCANDESCENT,  "Incandescent" },
+  { ETC_LED_CURVE_LINEAR,        "Linear" },
+  { ETC_LED_CURVE_QUICK,         "Quick" },
+  { 0, NULL },
+};
+
+#define ETC_LED_OUTPUT_MODE_REGULATED  0x00
+#define ETC_LED_OUTPUT_MODE_BOOST      0x01
+#define ETC_LED_OUTPUT_MODE_PROTECTED  0x02
+
+static const value_string etc_led_output_mode_vals[] = {
+  { ETC_LED_OUTPUT_MODE_REGULATED,  "Regulated" },
+  { ETC_LED_OUTPUT_MODE_BOOST,      "Boost" },
+  { ETC_LED_OUTPUT_MODE_PROTECTED,  "Protected" },
+  { 0, NULL },
+};
+
+#define ETC_LED_WHITE_POINT_2950K    0x00
+#define ETC_LED_WHITE_POINT_3200K    0x01
+#define ETC_LED_WHITE_POINT_5600K    0x02
+#define ETC_LED_WHITE_POINT_6500K    0x03
+
+static const value_string etc_led_white_point_vals[] = {
+  { ETC_LED_WHITE_POINT_2950K,    "2950 K" },
+  { ETC_LED_WHITE_POINT_3200K,    "3200 K" },
+  { ETC_LED_WHITE_POINT_5600K,    "5600 K" },
+  { ETC_LED_WHITE_POINT_6500K,    "6500 K" },
+  { 0, NULL },
+};
+
+#define ETC_DMX_LOSS_BEHAVIOR_INSTANT   0x00
+#define ETC_DMX_LOSS_BEHAVIOR_WAIT2MIN  0x01
+#define ETC_DMX_LOSS_BEHAVIOR_HLL       0x02
+
+static const value_string etc_dmx_data_loss_vals[] = {
+  { ETC_DMX_LOSS_BEHAVIOR_INSTANT,   "Instant" },
+  { ETC_DMX_LOSS_BEHAVIOR_WAIT2MIN,  "Hold Last Look 2 Minutes" },
+  { ETC_DMX_LOSS_BEHAVIOR_HLL,       "Hold Last Look Forever" },
+  { 0, NULL },
+};
+
+#define ETC_DMX_BACKLIGHT_TIMEOUT_NEVER  0x00
+#define ETC_DMX_BACKLIGHT_TIMEOUT_30SEC  0x01
+#define ETC_DMX_BACKLIGHT_TIMEOUT_1MIN   0x02
+#define ETC_DMX_BACKLIGHT_TIMEOUT_5MIN   0x03
+#define ETC_DMX_BACKLIGHT_TIMEOUT_15MIN  0x04
+
+static const value_string etc_backlight_timeout_vals[] = {
+  { ETC_DMX_BACKLIGHT_TIMEOUT_NEVER,  "Never" },
+  { ETC_DMX_BACKLIGHT_TIMEOUT_30SEC,  "30 Seconds" },
+  { ETC_DMX_BACKLIGHT_TIMEOUT_1MIN,   "1 Minute" },
+  { ETC_DMX_BACKLIGHT_TIMEOUT_5MIN,   "5 Minute" },
+  { ETC_DMX_BACKLIGHT_TIMEOUT_15MIN,  "15 Minute" },
+  { 0, NULL },
+};
+
+#define ETC_OVERTEMP_MODE_DARK     0x00
+#define ETC_OVERTEMP_MODE_VISIBLE  0x01
+
+static const value_string etc_overtemp_mode_vals[] = {
+  { ETC_OVERTEMP_MODE_DARK,     "Dark When Overtemp" },
+  { ETC_OVERTEMP_MODE_VISIBLE,  "Red When Overtemp" },
+  { 0, NULL },
+};
+
+#define ETC_EASY_MODE_GENERAL   0x00
+#define ETC_EASY_MODE_STAGE     0x01
+#define ETC_EASY_MODE_ARCH      0x02
+#define ETC_EASY_MODE_EFFECTS   0x03
+#define ETC_EASY_MODE_STUDIO    0x04
+#define ETC_EASY_MODE_ADVANCED  0x05
+
+static const value_string etc_simple_setup_mode_vals[] = {
+  { ETC_EASY_MODE_GENERAL,   "General Use" },
+  { ETC_EASY_MODE_STAGE,     "Stage Setup" },
+  { ETC_EASY_MODE_ARCH,      "Arch Setup" },
+  { ETC_EASY_MODE_EFFECTS,   "Effects Setup" },
+  { ETC_EASY_MODE_STUDIO,    "Studio Setup" },
+  { ETC_EASY_MODE_ADVANCED,  "Advanced Setup" },
+  { 0, NULL },
+};
+
+#define ETC_LOW_POWER_TIMEOUT_NEVER   0x00
+#define ETC_LOW_POWER_TIMEOUT_15MIN   0x01
+#define ETC_LOW_POWER_TIMEOUT_30MIN   0x02
+#define ETC_LOW_POWER_TIMEOUT_1HOUR   0x03
+#define ETC_LOW_POWER_TIMEOUT_4HOURS  0x04
+#define ETC_LOW_POWER_TIMEOUT_8HOURS  0x05
+
+static const value_string etc_low_power_timeout_vals[] = {
+  { ETC_LOW_POWER_TIMEOUT_NEVER,   "Never" },
+  { ETC_LOW_POWER_TIMEOUT_15MIN,   "15 Minutes" },
+  { ETC_LOW_POWER_TIMEOUT_30MIN,   "30 Minutes" },
+  { ETC_LOW_POWER_TIMEOUT_1HOUR,   "1 Hour" },
+  { ETC_LOW_POWER_TIMEOUT_4HOURS,  "4 Hours" },
+  { ETC_LOW_POWER_TIMEOUT_8HOURS,  "8 Hours" },
+  { 0, NULL },
+};
+
+#define ETC_LED_FREQ_ENUM_1200HZ   0x00
+#define ETC_LED_FREQ_ENUM_25000HZ  0x01
+
+static const value_string etc_led_frequency_enum_vals[] = {
+  { ETC_LED_FREQ_ENUM_1200HZ,   "1.2 kHz" },
+  { ETC_LED_FREQ_ENUM_25000HZ,  "25 kHz" },
+  { 0, NULL },
+};
+
+#define ETC_MODEL_ID_SMARTBAR                           0x0001
+#define ETC_MODEL_ID_SOURCE_4_LED_LUSTR_PLUS            0x0101
+#define ETC_MODEL_ID_DESIRE_ICE_40_LED                  0x0102
+#define ETC_MODEL_ID_DESIRE_FIRE_40_LED                 0x0103
+#define ETC_MODEL_ID_SOURCE_4_LED_TUNGSTEN              0x0107
+#define ETC_MODEL_ID_SOURCE_4_LED_DAYLIGHT              0x0108
+#define ETC_MODEL_ID_DESIRE_VIVID_40_LED                0x0109
+#define ETC_MODEL_ID_DESIRE_LUSTR_60_LED_OBS            0x0111
+#define ETC_MODEL_ID_DESIRE_ICE_60_LED                  0x0112
+#define ETC_MODEL_ID_DESIRE_FIRE_60_LED                 0x0113
+#define ETC_MODEL_ID_DESIRE_VIVID_60_LED                0x0119
+#define ETC_MODEL_ID_DESIRE_STUDIO_40_LED               0x0121
+#define ETC_MODEL_ID_DESIRE_STUDIO_60_LED               0x0129
+#define ETC_MODEL_ID_DESIRE_LUSTR_40_LED                0x0131
+#define ETC_MODEL_ID_DESIRE_LUSTR_60_LED                0x0139
+#define ETC_MODEL_ID_DESIRE_DAYLIGHT_40_LED             0x0141
+#define ETC_MODEL_ID_DESIRE_TUNGSTEN_40_LED             0x0142
+#define ETC_MODEL_ID_DESIRE_DAYLIGHT_60_LED             0x0149
+#define ETC_MODEL_ID_DESIRE_TUNGSTEN_60_LED             0x014A
+#define ETC_MODEL_ID_DESIRE_D22_LUSTR_PLUS_LED          0x0151
+#define ETC_MODEL_ID_DESIRE_D22_DAYLIGHT_LED            0x0159
+#define ETC_MODEL_ID_DESIRE_D22_TUNGSTEN_LED            0x015A
+#define ETC_MODEL_ID_SOURCE_4_LED_STUDIO_HD             0x0179
+#define ETC_MODEL_ID_SOURCE_4_LED_SERIES_2_LUSTR        0x0181
+#define ETC_MODEL_ID_DESIRE_D22_STUDIO_HD               0x0189
+#define ETC_MODEL_ID_SOURCE_4_LED_SERIES_2_TUNGSTEN_HD  0x0191
+#define ETC_MODEL_ID_SOURCE_4_LED_SERIES_2_DAYLIGHT_HD  0x0199
+#define ETC_MODEL_ID_COLORSOURCE_BOOTLOADER             0x0200
+#define ETC_MODEL_ID_COLORSOURCE_PAR                    0x0201
+#define ETC_MODEL_ID_COLORSOURCE_PAR_DEEP_BLUE          0x0202
+#define ETC_MODEL_ID_COLORSOURCE_PAR_PEARL              0x0203
+#define ETC_MODEL_ID_COLORSOURCE_SPOT                   0x0205
+#define ETC_MODEL_ID_COLORSOURCE_SPOT_DEEP_BLUE         0x0206
+#define ETC_MODEL_ID_COLORSOURCE_SPOT_PEARL             0x0207
+#define ETC_MODEL_ID_COLORSOURCE_LINEAR_1               0x0209
+#define ETC_MODEL_ID_COLORSOURCE_LINEAR_1_DEEP_BLUE     0x020A
+#define ETC_MODEL_ID_COLORSOURCE_LINEAR_1_PEARL         0x020B
+#define ETC_MODEL_ID_COLORSOURCE_LINEAR_2               0x020D
+#define ETC_MODEL_ID_COLORSOURCE_LINEAR_2_DEEP_BLUE     0x020E
+#define ETC_MODEL_ID_COLORSOURCE_LINEAR_2_PEARL         0x020F
+#define ETC_MODEL_ID_COLORSOURCE_LINEAR_4               0x0211
+#define ETC_MODEL_ID_COLORSOURCE_LINEAR_4_DEEP_BLUE     0x0212
+#define ETC_MODEL_ID_COLORSOURCE_LINEAR_4_PEARL         0x0213
+#define ETC_MODEL_ID_COLORSOURCE_CYC                    0x0215
+#define ETC_MODEL_ID_SOURCE_FORWARD_120V                0x0800
+#define ETC_MODEL_ID_SOURCE_FORWARD_230V                0x0801
+#define ETC_MODEL_ID_IRIDEON_FPZ                        0x0900
+#define ETC_MODEL_ID_SOURCE_FOUR_DIMMER                 0x1001
+#define ETC_MODEL_ID_KILLSWITCH_WIRELESS                0x1002
+#define ETC_MODEL_ID_KILLSWITCH_DMX                     0x1003
+#define ETC_MODEL_ID_KILLSWITCH_ETHERNET                0x1004
+#define ETC_MODEL_ID_KILLSWITCH_TRANSMITTER             0x1005
+#define ETC_MODEL_ID_DMX_ZONE_CONTROLLER_SINGLE_DIMMER  0x1006
+#define ETC_MODEL_ID_DMX_ZONE_CONTROLLER_RELAY          0x1007
+#define ETC_MODEL_ID_DMX_ZONE_CONTROLLER__4_8_CH        0x1008
+#define ETC_MODEL_ID_COLORSOURCE_THRUPOWER_DIMMER       0x1101
+#define ETC_MODEL_ID_DMX_DALI_GATEWAY_DIN_RAIL          0x1110
+
+static const value_string etc_model_id_vals[] = {
+  { ETC_MODEL_ID_SMARTBAR,                           "Smartbar" },
+  { ETC_MODEL_ID_SOURCE_4_LED_LUSTR_PLUS,            "Source 4 LED Lustr+" },
+  { ETC_MODEL_ID_DESIRE_ICE_40_LED,                  "Desire Ice 40 LED" },
+  { ETC_MODEL_ID_DESIRE_FIRE_40_LED,                 "Desire Fire 40 LED" },
+  { ETC_MODEL_ID_SOURCE_4_LED_TUNGSTEN,              "Source 4 LED Tungsten" },
+  { ETC_MODEL_ID_SOURCE_4_LED_DAYLIGHT,              "Source 4 LED Daylight" },
+  { ETC_MODEL_ID_DESIRE_VIVID_40_LED,                "Desire Vivid 40 LED" },
+  { ETC_MODEL_ID_DESIRE_LUSTR_60_LED_OBS,            "Desire Lustr 60 LED (obsolete)" },
+  { ETC_MODEL_ID_DESIRE_ICE_60_LED,                  "Desire Ice 60 LED" },
+  { ETC_MODEL_ID_DESIRE_FIRE_60_LED,                 "Desire Fire 60 LED" },
+  { ETC_MODEL_ID_DESIRE_VIVID_60_LED,                "Desire Vivid 60 LED" },
+  { ETC_MODEL_ID_DESIRE_STUDIO_40_LED,               "Desire Studio 40 LED" },
+  { ETC_MODEL_ID_DESIRE_STUDIO_60_LED,               "Desire Studio 60 LED" },
+  { ETC_MODEL_ID_DESIRE_LUSTR_40_LED,                "Desire Lustr 40 LED" },
+  { ETC_MODEL_ID_DESIRE_LUSTR_60_LED,                "Desire Lustr 60 LED" },
+  { ETC_MODEL_ID_DESIRE_DAYLIGHT_40_LED,             "Desire Daylight 40 LED" },
+  { ETC_MODEL_ID_DESIRE_TUNGSTEN_40_LED,             "Desire Tungsten 40 LED" },
+  { ETC_MODEL_ID_DESIRE_DAYLIGHT_60_LED,             "Desire Daylight 60 LED" },
+  { ETC_MODEL_ID_DESIRE_TUNGSTEN_60_LED,             "Desire Tungsten 60 LED" },
+  { ETC_MODEL_ID_DESIRE_D22_LUSTR_PLUS_LED,          "Desire D22 Lustr+ LED" },
+  { ETC_MODEL_ID_DESIRE_D22_DAYLIGHT_LED,            "Desire D22 Daylight LED" },
+  { ETC_MODEL_ID_DESIRE_D22_TUNGSTEN_LED,            "Desire D22 Tungsten LED" },
+  { ETC_MODEL_ID_SOURCE_4_LED_STUDIO_HD,             "Source 4 LED Studio HD" },
+  { ETC_MODEL_ID_SOURCE_4_LED_SERIES_2_LUSTR,        "Source 4 LED Series 2 Lustr" },
+  { ETC_MODEL_ID_DESIRE_D22_STUDIO_HD,               "Desire D22 Studio HD" },
+  { ETC_MODEL_ID_SOURCE_4_LED_SERIES_2_TUNGSTEN_HD,  "Source 4 LED Series 2 Tungsten HD" },
+  { ETC_MODEL_ID_SOURCE_4_LED_SERIES_2_DAYLIGHT_HD,  "Source 4 LED Series 2 Daylight HD" },
+  { ETC_MODEL_ID_COLORSOURCE_BOOTLOADER,             "ColorSource Bootloader" },
+  { ETC_MODEL_ID_COLORSOURCE_PAR,                    "ColorSource Par" },
+  { ETC_MODEL_ID_COLORSOURCE_PAR_DEEP_BLUE,          "ColorSource Par DeepBlue" },
+  { ETC_MODEL_ID_COLORSOURCE_PAR_PEARL,              "ColorSource Par Pearl" },
+  { ETC_MODEL_ID_COLORSOURCE_SPOT,                   "ColorSource Spot" },
+  { ETC_MODEL_ID_COLORSOURCE_SPOT_DEEP_BLUE,         "ColorSource Spot DeepBlue" },
+  { ETC_MODEL_ID_COLORSOURCE_SPOT_PEARL,             "ColorSource Spot Pearl" },
+  { ETC_MODEL_ID_COLORSOURCE_LINEAR_1,               "ColorSource Linear 1" },
+  { ETC_MODEL_ID_COLORSOURCE_LINEAR_1_DEEP_BLUE,     "ColorSource Linear 1 DeepBlue" },
+  { ETC_MODEL_ID_COLORSOURCE_LINEAR_1_PEARL,         "ColorSource Linear 1 Pearl" },
+  { ETC_MODEL_ID_COLORSOURCE_LINEAR_2,               "ColorSource Linear 2" },
+  { ETC_MODEL_ID_COLORSOURCE_LINEAR_2_DEEP_BLUE,     "ColorSource Linear 2 DeepBlue" },
+  { ETC_MODEL_ID_COLORSOURCE_LINEAR_2_PEARL,         "ColorSource Linear 2 Pearl" },
+  { ETC_MODEL_ID_COLORSOURCE_LINEAR_4,               "ColorSource Linear 4" },
+  { ETC_MODEL_ID_COLORSOURCE_LINEAR_4_DEEP_BLUE,     "ColorSource Linear 4 DeepBlue" },
+  { ETC_MODEL_ID_COLORSOURCE_LINEAR_4_PEARL,         "ColorSource Linear 4 Pearl" },
+  { ETC_MODEL_ID_COLORSOURCE_CYC,                    "ColorSource Cyc" },
+  { ETC_MODEL_ID_SOURCE_FORWARD_120V,                "Source Forward 120v" },
+  { ETC_MODEL_ID_SOURCE_FORWARD_230V,                "Source Forward 230v" },
+  { ETC_MODEL_ID_IRIDEON_FPZ,                        "Irideon FPZ" },
+  { ETC_MODEL_ID_SOURCE_FOUR_DIMMER,                 "Source Four Dimmer" },
+  { ETC_MODEL_ID_KILLSWITCH_WIRELESS,                "Killswitch Wireless" },
+  { ETC_MODEL_ID_KILLSWITCH_DMX,                     "Killswitch DMX" },
+  { ETC_MODEL_ID_KILLSWITCH_ETHERNET,                "Killswitch Etherner" },
+  { ETC_MODEL_ID_KILLSWITCH_TRANSMITTER,             "Killswitch Transmitter" },
+  { ETC_MODEL_ID_DMX_ZONE_CONTROLLER_SINGLE_DIMMER,  "DMX Zone Controller, Single Dimmer" },
+  { ETC_MODEL_ID_DMX_ZONE_CONTROLLER_RELAY,          "DMX Zone Controller, Relay" },
+  { ETC_MODEL_ID_DMX_ZONE_CONTROLLER__4_8_CH,        "DMX Zone Controller, 4-8 Channel Room Controller" },
+  { ETC_MODEL_ID_COLORSOURCE_THRUPOWER_DIMMER,       "ColorSource Thrupower Dimmer" },
+  { ETC_MODEL_ID_DMX_DALI_GATEWAY_DIN_RAIL,          "DMX-DALI Gateway, DIN Rail" },
+  { 0, NULL },
+};
+
+static int hf_etc_parameter_id = -1;       /* every manufacturer needs one of these */
+static int hf_etc_pd_parameter_id = -1;    /* every manufacturer needs one of these */
+static int hf_etc_pd_device_model_id = -1;
+static int hf_etc_pd_led_curve = -1;
+static int hf_etc_pd_led_curve_description_curve = -1;
+static int hf_etc_pd_led_curve_description_text = -1;
+static int hf_etc_pd_led_strobe = -1;
+static int hf_etc_pd_led_output_mode = -1;
+static int hf_etc_pd_led_output_mode_description_mode = -1;
+static int hf_etc_pd_led_output_mode_description_text = -1;
+static int hf_etc_pd_led_red_shift = -1;
+static int hf_etc_pd_led_white_point = -1;
+static int hf_etc_pd_led_white_point_description_white_point = -1;
+static int hf_etc_pd_led_white_point_description_text = -1;
+static int hf_etc_pd_led_frequency = -1;
+static int hf_etc_pd_dmx_data_loss_behavior = -1;
+static int hf_etc_pd_dmx_data_loss_behavior_description_behavior = -1;
+static int hf_etc_pd_dmx_data_loss_behavior_description_text = -1;
+static int hf_etc_pd_led_plus_seven = -1;
+static int hf_etc_pd_backlight_brightness = -1;
+static int hf_etc_pd_backlight_timeout = -1;
+static int hf_etc_pd_status_indicators = -1;
+static int hf_etc_pd_overtemp_mode = -1;
+static int hf_etc_pd_simple_setup_mode = -1;
+static int hf_etc_pd_led_strobe_description_strobe = -1;
+static int hf_etc_pd_led_strobe_description_text = -1;
+static int hf_etc_pd_red_shift_description_red_shift = -1;
+static int hf_etc_pd_red_shift_description_text = -1;
+static int hf_etc_pd_plus_seven_description_plus_seven = -1;
+static int hf_etc_pd_plus_seven_description_text = -1;
+static int hf_etc_pd_backlight_timeout_description_timeout = -1;
+static int hf_etc_pd_backlight_timeout_description_text = -1;
+static int hf_etc_pd_simple_setup_mode_description_mode = -1;
+static int hf_etc_pd_simple_setup_mode_description_text = -1;
+static int hf_etc_pd_overtemp_mode_description_mode = -1;
+static int hf_etc_pd_overtemp_mode_description_text = -1;
+static int hf_etc_pd_led_requested_xy_x = -1;
+static int hf_etc_pd_led_requested_xy_y = -1;
+static int hf_etc_pd_led_current_xy_x = -1;
+static int hf_etc_pd_led_current_xy_y = -1;
+static int hf_etc_pd_current_pwm_led_number = -1;
+static int hf_etc_pd_current_pwm_channel_duty_cycle = -1;
+static int hf_etc_pd_tristimulus_led_number = -1;
+static int hf_etc_pd_tristimulus_x = -1;
+static int hf_etc_pd_tristimulus_y = -1;
+static int hf_etc_pd_tristimulus_z = -1;
+static int hf_etc_pd_led_information_led_number = -1;
+static int hf_etc_pd_led_information_type = -1;
+static int hf_etc_pd_led_information_dmx_control_channel = -1;
+static int hf_etc_pd_led_information_drive_current = -1;
+static int hf_etc_pd_led_information_gamut_polygon_order = -1;
+static int hf_etc_pd_led_information_quantity = -1;
+static int hf_etc_pd_preset_config_preset_number = -1;
+static int hf_etc_pd_preset_config_fade_time = -1;
+static int hf_etc_pd_preset_config_delay_time = -1;
+static int hf_etc_pd_preset_config_hue = -1;
+static int hf_etc_pd_preset_config_saturation = -1;
+static int hf_etc_pd_preset_config_intensity = -1;
+static int hf_etc_pd_preset_config_strobe = -1;
+static int hf_etc_pd_sequence_playback_sequence_number = -1;
+static int hf_etc_pd_sequence_config_sequence_number = -1;
+static int hf_etc_pd_sequence_config_preset_steps = -1;
+static int hf_etc_pd_sequence_config_preset_step = -1;
+static int hf_etc_pd_sequence_config_step_link_times = -1;
+static int hf_etc_pd_sequence_config_step_link_time = -1;
+static int hf_etc_pd_sequence_config_rate = -1;
+static int hf_etc_pd_sequence_config_end_state = -1;
+static int hf_etc_pd_low_power_timeout = -1;
+static int hf_etc_pd_low_power_timeout_description_timeout = -1;
+static int hf_etc_pd_low_power_timeout_description_text = -1;
+static int hf_etc_pd_led_enum_frequency = -1;
+static int hf_etc_pd_led_enum_frequency_description_frequency = -1;
+static int hf_etc_pd_led_enum_frequency_description_text = -1;
+static int hf_etc_pd_rgbi_preset_config_preset_number = -1;
+static int hf_etc_pd_rgbi_preset_config_fade_time = -1;
+static int hf_etc_pd_rgbi_preset_config_delay_time = -1;
+static int hf_etc_pd_rgbi_preset_config_red = -1;
+static int hf_etc_pd_rgbi_preset_config_green = -1;
+static int hf_etc_pd_rgbi_preset_config_blue = -1;
+static int hf_etc_pd_rgbi_preset_config_intensity = -1;
+static int hf_etc_pd_rgbi_preset_config_strobe = -1;
+static int hf_etc_pd_cct_preset_config_preset_number = -1;
+static int hf_etc_pd_cct_preset_config_fade_time = -1;
+static int hf_etc_pd_cct_preset_config_delay_time = -1;
+static int hf_etc_pd_cct_preset_config_white_point = -1;
+static int hf_etc_pd_cct_preset_config_tint = -1;
+static int hf_etc_pd_cct_preset_config_strobe = -1;
+static int hf_etc_pd_cct_preset_config_intensity = -1;
+static int hf_etc_pd_cct_preset_config_tone = -1;
+static int hf_etc_pd_cct_preset_config_reserved = -1;
+static int hf_etc_pd_supplementary_device_version_param_index = -1;
+static int hf_etc_pd_supplementary_device_version_param_description = -1;
+static int hf_etc_pd_power_command = -1;
+static int hf_etc_pd_power_command_description_state = -1;
+static int hf_etc_pd_power_command_description_text = -1;
+static int hf_etc_pd_dali_short_address = -1;
+static int hf_etc_pd_dali_group_membership = -1;
+static int hf_etc_pd_auto_bind = -1;
+static int hf_etc_pd_packet_delay = -1;
+static int hf_etc_pd_has_enum_text_pid = -1;
+static int hf_etc_pd_has_enum_text_true_false = -1;
+static int hf_etc_pd_get_enum_text_pid = -1;
+static int hf_etc_pd_get_enum_text_enum = -1;
+static int hf_etc_pd_get_enum_text_description = -1;
+
+static int ett_etc_sequence_config_steps = -1;
+static int ett_etc_sequence_config_times = -1;
+
+/* end ETC */
+/* end manufacturer-specific constants and variables */
+
 static guint16
 rdm_checksum(tvbuff_t *tvb, guint length)
 {
-	guint16 sum = RDM_SC_RDM;
-	guint	i;
-	for (i = 0; i < length; i++)
-		sum += tvb_get_guint8(tvb, i);
-	return sum;
+  guint16 sum = RDM_SC_RDM;
+  guint  i;
+  for (i = 0; i < length; i++)
+    sum += tvb_get_guint8(tvb, i);
+  return sum;
+}
+
+static void
+rdm_proto_tree_add_numeric_item(proto_tree *tree, int hfindex, tvbuff_t *tvb, guint *offset_ptr, guint8 len)
+{
+  guint offset = *offset_ptr;
+  proto_tree_add_item(tree, hfindex, tvb, offset, len, ENC_BIG_ENDIAN);
+  *offset_ptr += len;
+}
+
+static void
+rdm_proto_tree_add_ascii_item(proto_tree *tree, int hfindex, tvbuff_t *tvb, guint *offset_ptr, gint len)
+{
+  guint offset = *offset_ptr;
+  proto_tree_add_item(tree, hfindex, tvb, offset, len, ENC_ASCII|ENC_NA);
+  *offset_ptr += len;
+}
+
+static void
+rdm_proto_tree_add_bytes_item(proto_tree *tree, int hfindex, tvbuff_t *tvb, guint *offset_ptr, gint len)
+{
+  guint offset = *offset_ptr;
+  proto_tree_add_item(tree, hfindex, tvb, offset, len, ENC_NA);
+  *offset_ptr += len;
 }
 
 static guint
 dissect_rdm_pd_queued_message(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len _U_)
 {
-	switch(cc) {
-	case RDM_CC_GET_COMMAND:
-		proto_tree_add_item(tree, hf_rdm_pd_queued_message_status, tvb,
-			offset, 1, ENC_BIG_ENDIAN);
-		offset += 1;
-		break;
-	}
+  switch(cc) {
+  case RDM_CC_GET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_queued_message_status, tvb, &offset, 1);
+    break;
+  }
 
-	return offset;
+  return offset;
 }
 
 static guint
 dissect_rdm_pd_dmx_start_address(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len _U_)
 {
-	switch(cc) {
-	case RDM_CC_SET_COMMAND:
-	case RDM_CC_GET_COMMAND_RESPONSE:
-		proto_tree_add_item(tree, hf_rdm_pd_dmx_start_address, tvb,
-			offset, 2, ENC_BIG_ENDIAN);
-		offset +=  2;
-		break;
-	}
-
-	return offset;
+  switch(cc) {
+  case RDM_CC_SET_COMMAND:
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dmx_start_address, tvb, &offset, 2);
+    break;
+  }
+
+  return offset;
 }
 
 static guint
-dissect_rdm_pd_device_info(tvbuff_t *tvb _U_, guint offset, proto_tree *tree _U_, guint8 cc, guint8 len _U_)
+dissect_rdm_pd_device_info(tvbuff_t *tvb _U_, guint offset, proto_tree *tree _U_, guint8 cc, guint8 len _U_, guint16 device_manufacturer_id)
 {
-	switch(cc) {
-	case RDM_CC_GET_COMMAND_RESPONSE:
-		proto_tree_add_item(tree, hf_rdm_pd_proto_vers, tvb,
-			offset, 2, ENC_BIG_ENDIAN);
-		offset +=  2;
-
-		proto_tree_add_item(tree, hf_rdm_pd_device_model_id, tvb,
-			offset, 2, ENC_BIG_ENDIAN);
-		offset +=  2;
-
-		proto_tree_add_item(tree, hf_rdm_pd_product_cat, tvb,
-			offset, 2, ENC_BIG_ENDIAN);
-		offset +=  2;
-
-		proto_tree_add_item(tree, hf_rdm_pd_software_vers_id, tvb,
-			offset, 4, ENC_BIG_ENDIAN);
-		offset +=  4;
-
-		proto_tree_add_item(tree, hf_rdm_pd_dmx_footprint, tvb,
-			offset, 2, ENC_BIG_ENDIAN);
-		offset +=  2;
-
-		proto_tree_add_item(tree, hf_rdm_pd_dmx_pers_current, tvb,
-			offset, 1, ENC_BIG_ENDIAN);
-		offset += 1;
-
-		proto_tree_add_item(tree, hf_rdm_pd_dmx_pers_total, tvb,
-			offset, 1, ENC_BIG_ENDIAN);
-		offset += 1;
-
-		proto_tree_add_item(tree, hf_rdm_pd_dmx_start_address, tvb,
-			offset, 2, ENC_BIG_ENDIAN);
-		offset +=  2;
-
-		proto_tree_add_item(tree, hf_rdm_pd_sub_device_count, tvb,
-			offset, 2, ENC_BIG_ENDIAN);
-		offset +=  2;
-
-		proto_tree_add_item(tree, hf_rdm_pd_sensor_count, tvb,
-			offset, 1, ENC_BIG_ENDIAN);
-		offset += 1;
-
-		break;
-	}
-
-	return offset;
+  switch(cc) {
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_proto_vers, tvb, &offset, 2);
+    switch(device_manufacturer_id) {
+    case RDM_MANUFACTURER_ID_ETC:
+      rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_device_model_id, tvb, &offset, 2);
+      break;
+    default:
+      rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_device_model_id, tvb, &offset, 2);
+      break;
+    }
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_product_cat, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_software_vers_id, tvb, &offset, 4);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dmx_footprint, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dmx_pers_current, tvb, &offset, 1);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dmx_pers_total, tvb, &offset, 1);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dmx_start_address, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_sub_device_count, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_sensor_count, tvb, &offset, 1);
+    break;
+  }
+
+  return offset;
 }
 
 
 static guint
 dissect_rdm_pd_device_model_description(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len)
 {
-	switch(cc) {
-	case RDM_CC_GET_COMMAND_RESPONSE:
-		proto_tree_add_item(tree, hf_rdm_pd_device_model_description, tvb,
-			offset, len, ENC_ASCII|ENC_NA);
-		offset +=  len;
-		break;
-	}
+  switch(cc) {
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_ascii_item(tree, hf_rdm_pd_device_model_description, tvb, &offset, len);
+    break;
+  }
 
-	return offset;
+  return offset;
 }
 
 
 static guint
 dissect_rdm_pd_device_label(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len)
 {
-	switch(cc) {
-	case RDM_CC_SET_COMMAND:
-	case RDM_CC_GET_COMMAND_RESPONSE:
-		proto_tree_add_item(tree, hf_rdm_pd_device_label, tvb,
-			offset, len, ENC_ASCII|ENC_NA);
-		offset +=  len;
-		break;
-	}
-
-	return offset;
+  switch(cc) {
+  case RDM_CC_SET_COMMAND:
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_ascii_item(tree, hf_rdm_pd_device_label, tvb, &offset, len);
+    break;
+  }
+
+  return offset;
 }
 
 
 static guint
 dissect_rdm_pd_device_hours(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len _U_)
 {
-	switch(cc) {
-	case RDM_CC_SET_COMMAND:
-	case RDM_CC_GET_COMMAND_RESPONSE:
-		proto_tree_add_item(tree, hf_rdm_pd_device_hours, tvb,
-			offset, 4, ENC_BIG_ENDIAN);
-		offset +=  4;
-		break;
-	}
-
-	return offset;
+  switch(cc) {
+  case RDM_CC_SET_COMMAND:
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_device_hours, tvb, &offset, 4);
+    break;
+  }
+
+  return offset;
 }
 
 
 static guint
 dissect_rdm_pd_lamp_hours(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len _U_)
 {
-	switch(cc) {
-	case RDM_CC_SET_COMMAND:
-	case RDM_CC_GET_COMMAND_RESPONSE:
-		proto_tree_add_item(tree, hf_rdm_pd_lamp_hours, tvb,
-			offset, 4, ENC_BIG_ENDIAN);
-		offset +=  4;
-		break;
-	}
-
-	return offset;
+  switch(cc) {
+  case RDM_CC_SET_COMMAND:
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_lamp_hours, tvb, &offset, 4);
+    break;
+  }
+
+  return offset;
 }
 
 
 static guint
 dissect_rdm_pd_lamp_strikes(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len _U_)
 {
-	switch(cc) {
-	case RDM_CC_SET_COMMAND:
-	case RDM_CC_GET_COMMAND_RESPONSE:
-		proto_tree_add_item(tree, hf_rdm_pd_lamp_strikes, tvb,
-			offset, 4, ENC_BIG_ENDIAN);
-		offset +=  4;
-		break;
-	}
-
-	return offset;
+  switch(cc) {
+  case RDM_CC_SET_COMMAND:
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_lamp_strikes, tvb, &offset, 4);
+    break;
+  }
+
+  return offset;
 }
 
 
 static guint
 dissect_rdm_pd_sensor_definition(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len)
 {
-	switch(cc) {
-	case RDM_CC_GET_COMMAND:
-		proto_tree_add_item(tree, hf_rdm_pd_sensor_nr, tvb,
-			offset, 1, ENC_BIG_ENDIAN);
-		offset += 1;
-		break;
-
-	case RDM_CC_GET_COMMAND_RESPONSE:
-		proto_tree_add_item(tree, hf_rdm_pd_sensor_nr, tvb,
-			offset, 1, ENC_BIG_ENDIAN);
-		offset += 1;
-
-		proto_tree_add_item(tree, hf_rdm_pd_sensor_type, tvb,
-			offset, 1, ENC_BIG_ENDIAN);
-		offset += 1;
-
-		proto_tree_add_item(tree, hf_rdm_pd_sensor_unit, tvb,
-			offset, 1, ENC_BIG_ENDIAN);
-		offset += 1;
-
-		proto_tree_add_item(tree, hf_rdm_pd_sensor_prefix, tvb,
-			offset, 1, ENC_BIG_ENDIAN);
-		offset += 1;
-
-		proto_tree_add_item(tree, hf_rdm_pd_sensor_range_min_value, tvb,
-			offset, 2, ENC_BIG_ENDIAN);
-		offset +=  2;
+  switch(cc) {
+  case RDM_CC_GET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_sensor_nr, tvb, &offset, 1);
+    break;
+
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_sensor_nr, tvb, &offset, 1);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_sensor_type, tvb, &offset, 1);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_sensor_unit, tvb, &offset, 1);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_sensor_prefix, tvb, &offset, 1);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_sensor_range_min_value, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_sensor_range_max_value, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_sensor_normal_min_value, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_sensor_normal_max_value, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_sensor_recorded_value_support, tvb, &offset, 1);
+    rdm_proto_tree_add_ascii_item(tree, hf_rdm_pd_sensor_description, tvb, &offset, len);
+    break;
+  }
+
+  return offset;
+}
 
-		proto_tree_add_item(tree, hf_rdm_pd_sensor_range_max_value, tvb,
-			offset, 2, ENC_BIG_ENDIAN);
-		offset +=  2;
+static guint
+dissect_rdm_pd_sensor_value(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len)
+{
+  guint8 original_len = len;
 
-		proto_tree_add_item(tree, hf_rdm_pd_sensor_normal_min_value, tvb,
-			offset, 2, ENC_BIG_ENDIAN);
-		offset +=  2;
+  switch(cc) {
+  case RDM_CC_GET_COMMAND:
+  case RDM_CC_SET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_sensor_nr, tvb, &offset, 1);
+    break;
 
-		proto_tree_add_item(tree, hf_rdm_pd_sensor_normal_max_value, tvb,
-			offset, 2, ENC_BIG_ENDIAN);
-		offset +=  2;
+  case RDM_CC_GET_COMMAND_RESPONSE:
+  case RDM_CC_SET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_sensor_nr, tvb, &offset, 1);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_sensor_value_pres, tvb, &offset, 2);
 
-		proto_tree_add_item(tree, hf_rdm_pd_sensor_recorded_value_support, tvb,
-			offset, 1, ENC_BIG_ENDIAN);
-		offset += 1;
+    if (original_len == 7 || original_len == 9) {
+      rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_sensor_value_low, tvb, &offset, 2);
+      rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_sensor_value_high, tvb, &offset, 2);
+    }
 
-		proto_tree_add_item(tree, hf_rdm_pd_sensor_description, tvb,
-			offset, len - 13, ENC_ASCII|ENC_NA);
-		offset += (len - 13);
-		break;
-	}
+    if (original_len == 5 || original_len == 9) {
+      rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_sensor_value_rec, tvb, &offset, 2);
+    }
 
-	return offset;
-}
+    break;
+  }
 
-static guint
-dissect_rdm_pd_sensor_value(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len)
-{
-	switch(cc) {
-	case RDM_CC_GET_COMMAND:
-	case RDM_CC_SET_COMMAND:
-		proto_tree_add_item(tree, hf_rdm_pd_sensor_nr, tvb,
-			offset, 1, ENC_BIG_ENDIAN);
-		offset += 1;
-		break;
-
-	case RDM_CC_GET_COMMAND_RESPONSE:
-	case RDM_CC_SET_COMMAND_RESPONSE:
-		proto_tree_add_item(tree, hf_rdm_pd_sensor_nr, tvb,
-			offset, 1, ENC_BIG_ENDIAN);
-		offset += 1;
-		proto_tree_add_item(tree, hf_rdm_pd_sensor_value_pres, tvb,
-			offset, 2, ENC_BIG_ENDIAN);
-		offset +=  2;
-
-		if (len == 7 || len == 9) {
-			proto_tree_add_item(tree, hf_rdm_pd_sensor_value_low, tvb,
-				offset, 2, ENC_BIG_ENDIAN);
-			offset +=  2;
-			proto_tree_add_item(tree, hf_rdm_pd_sensor_value_high, tvb,
-				offset, 2, ENC_BIG_ENDIAN);
-			offset +=  2;
-		}
-
-		if (len == 5 || len == 9) {
-			proto_tree_add_item(tree, hf_rdm_pd_sensor_value_rec, tvb,
-				offset, 2, ENC_BIG_ENDIAN);
-			offset +=  2;
-		}
-
-		break;
-	}
-
-	return offset;
+  return offset;
 }
 
 static guint
 dissect_rdm_pd_manufacturer_label(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len)
 {
-	switch(cc) {
-	case RDM_CC_GET_COMMAND_RESPONSE:
-		proto_tree_add_item(tree, hf_rdm_pd_manu_label, tvb,
-			offset, len, ENC_ASCII|ENC_NA);
-		offset +=  len;
-		break;
-	}
+  switch(cc) {
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_ascii_item(tree, hf_rdm_pd_manu_label, tvb, &offset, len);
+    break;
+  }
 
-	return offset;
+  return offset;
 }
 
 static guint
 dissect_rdm_pd_disc_unique_branch(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len _U_)
 {
-	switch(cc) {
-	case RDM_CC_DISCOVERY_COMMAND:
-		proto_tree_add_item(tree, hf_rdm_pd_disc_unique_branch_lb_uid, tvb,
-			offset, 6, ENC_NA);
-		offset += 6;
-
-		proto_tree_add_item(tree, hf_rdm_pd_disc_unique_branch_ub_uid, tvb,
-			offset, 6, ENC_NA);
-		offset += 6;
-		break;
-	}
-
-	return offset;
+  switch(cc) {
+  case RDM_CC_DISCOVERY_COMMAND:
+    rdm_proto_tree_add_bytes_item(tree, hf_rdm_pd_disc_unique_branch_lb_uid, tvb, &offset, 6);
+    rdm_proto_tree_add_bytes_item(tree, hf_rdm_pd_disc_unique_branch_ub_uid, tvb, &offset, 6);
+    break;
+  }
+
+  return offset;
 }
 
 static guint
 dissect_rdm_pd_disc_mute(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len)
 {
-	switch(cc) {
-	case RDM_CC_DISCOVERY_COMMAND_RESPONSE:
-		proto_tree_add_item(tree, hf_rdm_pd_disc_mute_control_field, tvb,
-			offset, 2, ENC_BIG_ENDIAN);
-		offset += 2;
-		if (len > 2) {
-			proto_tree_add_item(tree, hf_rdm_pd_disc_mute_binding_uid, tvb,
-				offset, 6, ENC_NA);
-			offset += 6;
-		}
-		break;
-	}
-
-	return offset;
+  switch(cc) {
+  case RDM_CC_DISCOVERY_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_disc_mute_control_field, tvb, &offset, 2);
+    if (len > 2) {
+      rdm_proto_tree_add_bytes_item(tree, hf_rdm_pd_disc_mute_binding_uid, tvb, &offset, 6);
+    }
+    break;
+  }
+
+  return offset;
 }
 
 static guint
 dissect_rdm_pd_disc_un_mute(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len)
 {
-	switch(cc) {
-	case RDM_CC_DISCOVERY_COMMAND_RESPONSE:
-		proto_tree_add_item(tree, hf_rdm_pd_disc_unmute_control_field, tvb,
-			offset, 2, ENC_BIG_ENDIAN);
-		offset += 2;
-		if (len > 2) {
-			proto_tree_add_item(tree, hf_rdm_pd_disc_unmute_binding_uid, tvb,
-				offset, 6, ENC_NA);
-			offset += 6;
-		}
-		break;
-	}
-
-	return offset;
+  switch(cc) {
+  case RDM_CC_DISCOVERY_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_disc_unmute_control_field, tvb, &offset, 2);
+    if (len > 2) {
+      rdm_proto_tree_add_bytes_item(tree, hf_rdm_pd_disc_unmute_binding_uid, tvb, &offset, 6);
+    }
+    break;
+  }
+
+  return offset;
 }
 
 static guint
 dissect_rdm_pd_proxied_devices(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len)
 {
-	switch(cc) {
-	case RDM_CC_GET_COMMAND_RESPONSE:
-		while (len >= 6) {
-			proto_tree_add_item(tree, hf_rdm_pd_proxied_devices_uid, tvb,
-				offset, 6, ENC_NA);
-			offset += 6;
-			len    -= 6;
-		}
-		break;
-	}
-
-	return offset;
+  switch(cc) {
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    while (len >= 6) {
+      rdm_proto_tree_add_bytes_item(tree, hf_rdm_pd_proxied_devices_uid, tvb, &offset, 6);
+    }
+    break;
+  }
+
+  return offset;
 }
 
 static guint
 dissect_rdm_pd_proxied_device_count(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len _U_)
 {
-	switch(cc) {
-	case RDM_CC_GET_COMMAND_RESPONSE:
-		proto_tree_add_item(tree, hf_rdm_pd_proxied_device_count, tvb,
-			offset, 2, ENC_BIG_ENDIAN);
-		offset += 2;
-		proto_tree_add_item(tree, hf_rdm_pd_proxied_device_list_change, tvb,
-			offset, 1, ENC_BIG_ENDIAN);
-		offset += 1;
-		break;
-	}
-
-	return offset;
+  switch(cc) {
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_proxied_device_count, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_proxied_device_list_change, tvb, &offset, 1);
+    break;
+  }
+
+  return offset;
 }
 
 static guint
 dissect_rdm_pd_comms_status(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len _U_)
 {
-	switch(cc) {
-	case RDM_CC_GET_COMMAND_RESPONSE:
-		proto_tree_add_item(tree, hf_rdm_pd_comms_status_short_msg, tvb,
-			offset, 2, ENC_BIG_ENDIAN);
-		offset += 2;
-		proto_tree_add_item(tree, hf_rdm_pd_comms_status_len_mismatch, tvb,
-			offset, 2, ENC_BIG_ENDIAN);
-		offset += 2;
-		proto_tree_add_item(tree, hf_rdm_pd_comms_status_csum_fail, tvb,
-			offset, 2, ENC_BIG_ENDIAN);
-		offset += 2;
-		break;
-	}
-
-	return offset;
+  switch(cc) {
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_comms_status_short_msg, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_comms_status_len_mismatch, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_comms_status_csum_fail, tvb, &offset, 2);
+    break;
+  }
+
+  return offset;
 }
 
 static guint
 dissect_rdm_pd_status_messages(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len)
 {
-	switch(cc) {
-	case RDM_CC_GET_COMMAND:
-		proto_tree_add_item(tree, hf_rdm_pd_status_messages_type, tvb,
-			offset, 1, ENC_BIG_ENDIAN);
-		offset += 1;
-		break;
-
-	case RDM_CC_GET_COMMAND_RESPONSE:
-		while (len >= 9) {
-			proto_tree_add_item(tree, hf_rdm_pd_status_messages_sub_device_id, tvb,
-				offset, 2, ENC_BIG_ENDIAN);
-			offset += 2;
-			len    -= 2;
-			proto_tree_add_item(tree, hf_rdm_pd_status_messages_type, tvb,
-				offset, 1, ENC_BIG_ENDIAN);
-			offset += 1;
-			len    -= 1;
-			proto_tree_add_item(tree, hf_rdm_pd_status_messages_id, tvb,
-				offset, 2, ENC_BIG_ENDIAN);
-			offset += 2;
-			len    -= 2;
-			proto_tree_add_item(tree, hf_rdm_pd_status_messages_data_value_1, tvb,
-				offset, 2, ENC_BIG_ENDIAN);
-			offset += 2;
-			len    -= 2;
-			proto_tree_add_item(tree, hf_rdm_pd_status_messages_data_value_2, tvb,
-				offset, 2, ENC_BIG_ENDIAN);
-			offset += 2;
-			len    -= 2;
-		}
-		break;
-	}
-
-	return offset;
+  switch(cc) {
+  case RDM_CC_GET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_status_messages_type, tvb, &offset, 1);
+    break;
+
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    while (len >= 9) {
+      rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_status_messages_sub_device_id, tvb, &offset, 2);
+      rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_status_messages_type, tvb, &offset, 1);
+      rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_status_messages_id, tvb, &offset, 2);
+      rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_status_messages_data_value_1, tvb, &offset, 2);
+      rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_status_messages_data_value_2, tvb, &offset, 2);
+    }
+    break;
+  }
+
+  return offset;
 }
 
 static guint
 dissect_rdm_pd_status_id_description(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len)
 {
-	switch(cc) {
-	case RDM_CC_GET_COMMAND:
-		proto_tree_add_item(tree, hf_rdm_pd_status_id, tvb,
-			offset, 2, ENC_BIG_ENDIAN);
-		offset += 2;
-		break;
+  switch(cc) {
+  case RDM_CC_GET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_status_id, tvb, &offset, 2);
+    break;
 
-	case RDM_CC_GET_COMMAND_RESPONSE:
-		proto_tree_add_item(tree, hf_rdm_pd_status_id_description, tvb,
-			offset, len, ENC_ASCII|ENC_NA);
-		offset += len;
-		break;
-	}
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_ascii_item(tree, hf_rdm_pd_status_id_description, tvb, &offset, len);
+    break;
+  }
 
-	return offset;
+  return offset;
 }
 
 static guint
 dissect_rdm_pd_clear_status_id(tvbuff_t *tvb _U_, guint offset, proto_tree *tree _U_, guint8 cc _U_, guint8 len _U_)
 {
-	return offset;
+  return offset;
 }
 
 static guint
 dissect_rdm_pd_sub_device_status_report_threshold(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len _U_)
 {
-	switch(cc) {
-	case RDM_CC_SET_COMMAND:
-	case RDM_CC_GET_COMMAND_RESPONSE:
-		proto_tree_add_item(tree, hf_rdm_pd_sub_device_status_report_threshold_status_type, tvb,
-			offset, 1, ENC_BIG_ENDIAN);
-		offset += 1;
-		break;
-	}
-
-	return offset;
-}
-
-static guint
-dissect_rdm_pd_supported_parameters(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len)
-{
-	switch(cc) {
-	case RDM_CC_GET_COMMAND_RESPONSE:
-		while (len >= 2) {
-			proto_tree_add_item(tree, hf_rdm_pd_parameter_id, tvb,
-				offset, 2, ENC_BIG_ENDIAN);
-			offset += 2;
-			len    -= 2;
-		}
-		break;
-	}
-
-	return offset;
-}
-
-static guint
-dissect_rdm_pd_parameter_description(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len)
-{
-	switch(cc) {
-	case RDM_CC_GET_COMMAND:
-		proto_tree_add_item(tree, hf_rdm_pd_parameter_id, tvb,
-			offset, 2, ENC_BIG_ENDIAN);
-		offset += 2;
-		break;
-
-	case RDM_CC_GET_COMMAND_RESPONSE:
-		proto_tree_add_item(tree, hf_rdm_pd_parameter_id, tvb,
-			offset, 2, ENC_BIG_ENDIAN);
-		offset += 2;
-		proto_tree_add_item(tree, hf_rdm_pd_parameter_pdl_size, tvb,
-			offset, 1, ENC_BIG_ENDIAN);
-		offset += 1;
-		proto_tree_add_item(tree, hf_rdm_pd_parameter_data_type, tvb,
-			offset, 1, ENC_BIG_ENDIAN);
-		offset += 1;
-		proto_tree_add_item(tree, hf_rdm_pd_parameter_cmd_class, tvb,
-			offset, 1, ENC_BIG_ENDIAN);
-		offset += 1;
-		proto_tree_add_item(tree, hf_rdm_pd_parameter_type, tvb,
-			offset, 1, ENC_BIG_ENDIAN);
-		offset += 1;
-		proto_tree_add_item(tree, hf_rdm_pd_parameter_unit, tvb,
-			offset, 1, ENC_BIG_ENDIAN);
-		offset += 1;
-		proto_tree_add_item(tree, hf_rdm_pd_parameter_prefix, tvb,
-			offset, 1, ENC_BIG_ENDIAN);
-		offset += 1;
-		proto_tree_add_item(tree, hf_rdm_pd_parameter_min_value, tvb,
-			offset, 4, ENC_BIG_ENDIAN);
-		offset += 4;
-		proto_tree_add_item(tree, hf_rdm_pd_parameter_max_value, tvb,
-			offset, 4, ENC_BIG_ENDIAN);
-		offset += 4;
-		proto_tree_add_item(tree, hf_rdm_pd_parameter_default_value, tvb,
-			offset, 4, ENC_BIG_ENDIAN);
-		offset += 4;
-		proto_tree_add_item(tree, hf_rdm_pd_parameter_description, tvb,
-			offset, len - 0x14, ENC_ASCII|ENC_NA);
-		offset += (len - 0x14);
-		break;
-	}
-
-	return offset;
+  switch(cc) {
+  case RDM_CC_SET_COMMAND:
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_sub_device_status_report_threshold_status_type, tvb, &offset, 1);
+    break;
+  }
+
+  return offset;
+}
+
+static void
+add_param_id_to_tree(guint16 param_id, proto_tree *tree, tvbuff_t *tvb, guint *offset, guint16 device_manufacturer_id)
+{
+  if (param_id < 0x8000) {
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_parameter_id, tvb, offset, 2);
+  } else {
+    switch(device_manufacturer_id) {
+    case RDM_MANUFACTURER_ID_ETC:
+      rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_parameter_id, tvb, offset, 2);
+      break;
+    default:
+      rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_parameter_id, tvb, offset, 2);
+      break;
+    }
+  }
 }
 
 static guint
-dissect_rdm_pd_product_detail_id_list(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len)
+dissect_rdm_pd_supported_parameters(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len, guint16 device_manufacturer_id)
 {
-	switch(cc) {
-	case RDM_CC_GET_COMMAND_RESPONSE:
-		while (len >= 2) {
-			proto_tree_add_item(tree, hf_rdm_pd_product_detail_id_list, tvb,
-				offset, 2, ENC_BIG_ENDIAN);
-			offset += 2;
-			len    -= 2;
-		}
-		break;
-	}
+  guint16      param_id;
+
+  switch(cc) {
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    while (len >= 2) {
+      param_id = tvb_get_ntohs(tvb, offset);
+      add_param_id_to_tree(param_id, tree, tvb, &offset, device_manufacturer_id);
+      len -= 2;
+    }
+    break;
+  }
+
+  return offset;
+}
 
-	return offset;
+static guint
+dissect_rdm_pd_parameter_description(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len, guint16 device_manufacturer_id)
+{
+  guint16      param_id;
+
+  switch(cc) {
+  case RDM_CC_GET_COMMAND:
+    param_id = tvb_get_ntohs(tvb, offset);
+    add_param_id_to_tree(param_id, tree, tvb, &offset, device_manufacturer_id);
+    break;
+
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    param_id = tvb_get_ntohs(tvb, offset);
+    add_param_id_to_tree(param_id, tree, tvb, &offset, device_manufacturer_id);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_parameter_pdl_size, tvb, &offset, 1);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_parameter_data_type, tvb, &offset, 1);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_parameter_cmd_class, tvb, &offset, 1);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_parameter_type, tvb, &offset, 1);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_parameter_unit, tvb, &offset, 1);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_parameter_prefix, tvb, &offset, 1);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_parameter_min_value, tvb, &offset, 4);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_parameter_max_value, tvb, &offset, 4);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_parameter_default_value, tvb, &offset, 4);
+    rdm_proto_tree_add_ascii_item(tree, hf_rdm_pd_parameter_description, tvb, &offset, len);
+    break;
+  }
+
+  return offset;
+}
+
+static guint
+dissect_rdm_pd_product_detail_id_list(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    while (len >= 2) {
+      rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_product_detail_id_list, tvb, &offset, 2);
+    }
+    break;
+  }
+
+  return offset;
 }
 
 static guint
 dissect_rdm_pd_factory_defaults(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len _U_)
 {
-	switch(cc) {
-	case RDM_CC_GET_COMMAND_RESPONSE:
-		proto_tree_add_item(tree, hf_rdm_pd_factory_defaults, tvb,
-			offset, 1, ENC_BIG_ENDIAN);
-		offset += 1;
-		break;
-	}
+  switch(cc) {
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_factory_defaults, tvb, &offset, 1);
+    break;
+  }
 
-	return offset;
+  return offset;
 }
 
 static guint
 dissect_rdm_pd_language_capabilities(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len)
 {
-	switch(cc) {
-	case RDM_CC_GET_COMMAND_RESPONSE:
-		while (len >= 2) {
-			proto_tree_add_item(tree, hf_rdm_pd_language_code, tvb,
-				offset, 2, ENC_ASCII|ENC_NA);
-			offset += 2;
-			len    -= 2;
-		}
-		break;
-	}
-
-	return offset;
+  switch(cc) {
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    while (len >= 2) {
+      rdm_proto_tree_add_ascii_item(tree, hf_rdm_pd_language_code, tvb, &offset, 2);
+      len -= 2;
+    }
+    break;
+  }
+
+  return offset;
 }
 
 static guint
 dissect_rdm_pd_language(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len _U_)
 {
-	switch(cc) {
-	case RDM_CC_SET_COMMAND:
-	case RDM_CC_GET_COMMAND_RESPONSE:
-		proto_tree_add_item(tree, hf_rdm_pd_language_code, tvb,
-			offset, 2, ENC_ASCII|ENC_NA);
-		offset += 2;
-		break;
-	}
-
-	return offset;
+  switch(cc) {
+  case RDM_CC_SET_COMMAND:
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_ascii_item(tree, hf_rdm_pd_language_code, tvb, &offset, 2);
+    break;
+  }
+
+  return offset;
 }
 
 static guint
 dissect_rdm_pd_software_version_label(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len)
 {
-	switch(cc) {
-	case RDM_CC_GET_COMMAND_RESPONSE:
-		proto_tree_add_item(tree, hf_rdm_pd_software_version_label, tvb,
-			offset, len, ENC_ASCII|ENC_NA);
-		offset += len;
+  switch(cc) {
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_ascii_item(tree, hf_rdm_pd_software_version_label, tvb, &offset, len);
+    break;
+  }
 
-		break;
-	}
-
-	return offset;
+  return offset;
 }
 
 static guint
 dissect_rdm_pd_boot_software_version_id(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len _U_)
 {
-	switch(cc) {
-	case RDM_CC_GET_COMMAND_RESPONSE:
-		proto_tree_add_item(tree, hf_rdm_pd_boot_software_version_id, tvb,
-			offset, 4, ENC_BIG_ENDIAN);
-		offset += 4;
-
-		break;
-	}
+  switch(cc) {
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_boot_software_version_id, tvb, &offset, 4);
+    break;
+  }
 
-	return offset;
+  return offset;
 }
 
 static guint
 dissect_rdm_pd_boot_software_version_label(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len)
 {
-	switch(cc) {
-	case RDM_CC_GET_COMMAND_RESPONSE:
-		proto_tree_add_item(tree, hf_rdm_pd_boot_software_version_label, tvb,
-			offset, len, ENC_ASCII|ENC_NA);
-		offset += len;
+  switch(cc) {
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_ascii_item(tree, hf_rdm_pd_boot_software_version_label, tvb, &offset, len);
+    break;
+  }
 
-		break;
-	}
-
-	return offset;
+  return offset;
 }
 
 static guint
 dissect_rdm_pd_dmx_personality(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len _U_)
 {
-	switch(cc) {
-	case RDM_CC_SET_COMMAND:
-		proto_tree_add_item(tree, hf_rdm_pd_dmx_pers_nr, tvb,
-			offset, 1, ENC_BIG_ENDIAN);
-		offset += 1;
-		break;
-
-	case RDM_CC_GET_COMMAND_RESPONSE:
-		proto_tree_add_item(tree, hf_rdm_pd_dmx_pers_current, tvb,
-			offset, 1, ENC_BIG_ENDIAN);
-		offset += 1;
-		proto_tree_add_item(tree, hf_rdm_pd_dmx_pers_count, tvb,
-			offset, 1, ENC_BIG_ENDIAN);
-		offset += 1;
-		break;
-	}
-
-	return offset;
+  switch(cc) {
+  case RDM_CC_SET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dmx_pers_nr, tvb, &offset, 1);
+    break;
+
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dmx_pers_current, tvb, &offset, 1);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dmx_pers_count, tvb, &offset, 1);
+    break;
+  }
+
+  return offset;
 }
 
 static guint
 dissect_rdm_pd_dmx_personality_description(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len)
 {
-	switch(cc) {
-	case RDM_CC_GET_COMMAND:
-		proto_tree_add_item(tree, hf_rdm_pd_dmx_pers_requested, tvb,
-			offset, 1, ENC_BIG_ENDIAN);
-		offset += 1;
-		break;
-
-	case RDM_CC_GET_COMMAND_RESPONSE:
-		proto_tree_add_item(tree, hf_rdm_pd_dmx_pers_requested, tvb,
-			offset, 1, ENC_BIG_ENDIAN);
-		offset += 1;
-		proto_tree_add_item(tree, hf_rdm_pd_dmx_pers_slots, tvb,
-			offset, 2, ENC_BIG_ENDIAN);
-		offset += 2;
-		proto_tree_add_item(tree, hf_rdm_pd_dmx_pers_text, tvb,
-			offset, (len - 3), ENC_ASCII|ENC_NA);
-		offset += (len - 3);
-		break;
-	}
-
-	return offset;
+  switch(cc) {
+  case RDM_CC_GET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dmx_pers_requested, tvb, &offset, 1);
+    break;
+
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dmx_pers_requested, tvb, &offset, 1);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dmx_pers_slots, tvb, &offset, 2);
+    rdm_proto_tree_add_ascii_item(tree, hf_rdm_pd_dmx_pers_text, tvb, &offset, len);
+    break;
+  }
+
+  return offset;
 }
 
 static guint
 dissect_rdm_pd_slot_info(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len)
 {
-	switch(cc) {
-	case RDM_CC_GET_COMMAND_RESPONSE:
-		while (len >= 5) {
-			proto_tree_add_item(tree, hf_rdm_pd_slot_offset, tvb,
-				offset, 2, ENC_BIG_ENDIAN);
-			offset += 2;
-			len    -= 2;
-			proto_tree_add_item(tree, hf_rdm_pd_slot_type, tvb,
-				offset, 1, ENC_BIG_ENDIAN);
-			offset += 1;
-			len    -= 1;
-			proto_tree_add_item(tree, hf_rdm_pd_slot_label_id, tvb,
-				offset, 2, ENC_BIG_ENDIAN);
-			offset += 2;
-			len    -= 2;
-		}
-		break;
-	}
-
-	return offset;
+  switch(cc) {
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    while (len >= 5) {
+      rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_slot_offset, tvb, &offset, 2);
+      rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_slot_type, tvb, &offset, 1);
+      rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_slot_label_id, tvb, &offset, 2);
+    }
+    break;
+  }
+
+  return offset;
 }
 
 static guint
 dissect_rdm_pd_slot_description(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len)
 {
-	switch(cc) {
-	case RDM_CC_GET_COMMAND:
-		proto_tree_add_item(tree, hf_rdm_pd_slot_nr, tvb,
-			offset, 2, ENC_BIG_ENDIAN);
-		offset += 2;
-		break;
+  switch(cc) {
+  case RDM_CC_GET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_slot_nr, tvb, &offset, 2);
+    break;
+
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_slot_nr, tvb, &offset, 2);
+    rdm_proto_tree_add_ascii_item(tree, hf_rdm_pd_slot_description, tvb, &offset, len);
+    break;
+  }
+
+  return offset;
+}
 
-	case RDM_CC_GET_COMMAND_RESPONSE:
-		proto_tree_add_item(tree, hf_rdm_pd_slot_nr, tvb,
-			offset, 2, ENC_BIG_ENDIAN);
-		offset += 2;
-		proto_tree_add_item(tree, hf_rdm_pd_slot_description, tvb,
-			offset, (len - 2), ENC_ASCII|ENC_NA);
-		offset += (len - 2);
-		break;
-	}
+static guint
+dissect_rdm_pd_slot_value(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    while (len >= 3) {
+      rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_slot_offset, tvb, &offset, 2);
+      rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_slot_value, tvb, &offset, 1);
+    }
+    break;
+  }
+
+  return offset;
+}
 
-	return offset;
+static guint
+dissect_rdm_pd_dmx_block_address(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dmx_block_address_subdevice_footprint, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dmx_block_address_base_dmx_address, tvb, &offset, 2);
+    break;
+
+  case RDM_CC_SET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dmx_block_address_base_dmx_address, tvb, &offset, 2);
+    break;
+  }
+
+  return offset;
 }
 
 static guint
-dissect_rdm_pd_slot_value(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len)
+dissect_rdm_pd_dmx_fail_mode(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
 {
-	switch(cc) {
-	case RDM_CC_GET_COMMAND_RESPONSE:
-		while (len >= 3) {
-			proto_tree_add_item(tree, hf_rdm_pd_slot_offset, tvb,
-				offset, 2, ENC_BIG_ENDIAN);
-			offset += 2;
-			len    -= 2;
-			proto_tree_add_item(tree, hf_rdm_pd_slot_value, tvb,
-				offset, 1, ENC_BIG_ENDIAN);
-			offset += 1;
-			len    -= 1;
-		}
-		break;
-	}
+  switch(cc) {
+  case RDM_CC_GET_COMMAND_RESPONSE:
+  case RDM_CC_SET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dmx_fail_mode_scene_number, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dmx_fail_mode_loss_of_signal_delay, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dmx_fail_mode_hold_time, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dmx_fail_mode_level, tvb, &offset, 1);
+    break;
+  }
+
+  return offset;
+}
 
-	return offset;
+static guint
+dissect_rdm_pd_dmx_startup_mode(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND_RESPONSE:
+  case RDM_CC_SET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dmx_startup_mode_scene_number, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dmx_startup_mode_loss_of_signal_delay, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dmx_startup_mode_hold_time, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dmx_startup_mode_level, tvb, &offset, 1);
+    break;
+  }
+
+  return offset;
 }
 
 static guint
 dissect_rdm_pd_record_sensors(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len)
 {
-	switch(cc) {
-	case RDM_CC_GET_COMMAND:
-		proto_tree_add_item(tree, hf_rdm_pd_sensor_nr, tvb,
-			offset, 1, ENC_BIG_ENDIAN);
-		offset += 1;
-		break;
-
-	case RDM_CC_GET_COMMAND_RESPONSE:
-		proto_tree_add_item(tree, hf_rdm_pd_sensor_nr, tvb,
-			offset, 1, ENC_BIG_ENDIAN);
-		offset += 1;
-		proto_tree_add_item(tree, hf_rdm_pd_sensor_type, tvb,
-			offset, 1, ENC_BIG_ENDIAN);
-		offset += 1;
-		proto_tree_add_item(tree, hf_rdm_pd_sensor_unit, tvb,
-			offset, 1, ENC_BIG_ENDIAN);
-		offset += 1;
-		proto_tree_add_item(tree, hf_rdm_pd_sensor_prefix, tvb,
-			offset, 1, ENC_BIG_ENDIAN);
-		offset += 1;
-		proto_tree_add_item(tree, hf_rdm_pd_sensor_range_min_value, tvb,
-			offset, 2, ENC_BIG_ENDIAN);
-		offset += 2;
-		proto_tree_add_item(tree, hf_rdm_pd_sensor_range_max_value, tvb,
-			offset, 2, ENC_BIG_ENDIAN);
-		offset += 2;
-		proto_tree_add_item(tree, hf_rdm_pd_sensor_normal_min_value, tvb,
-			offset, 2, ENC_BIG_ENDIAN);
-		offset += 2;
-		proto_tree_add_item(tree, hf_rdm_pd_sensor_normal_max_value, tvb,
-			offset, 2, ENC_BIG_ENDIAN);
-		offset += 2;
-		proto_tree_add_item(tree, hf_rdm_pd_rec_value_support, tvb,
-			offset, 1, ENC_BIG_ENDIAN);
-		offset += 1;
-		proto_tree_add_item(tree, hf_rdm_pd_sensor_description, tvb,
-			offset, (len - 13), ENC_ASCII|ENC_NA);
-		offset += (len - 13);
-
-		break;
-	}
-
-	return offset;
+  switch(cc) {
+  case RDM_CC_GET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_sensor_nr, tvb, &offset, 1);
+    break;
+
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_sensor_nr, tvb, &offset, 1);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_sensor_type, tvb, &offset, 1);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_sensor_unit, tvb, &offset, 1);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_sensor_prefix, tvb, &offset, 1);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_sensor_range_min_value, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_sensor_range_max_value, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_sensor_normal_min_value, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_sensor_normal_max_value, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_rec_value_support, tvb, &offset, 1);
+    rdm_proto_tree_add_ascii_item(tree, hf_rdm_pd_sensor_description, tvb, &offset, len);
+    break;
+  }
+
+  return offset;
 }
 
 static guint
-dissect_rdm_pd_lamp_state(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len _U_)
+dissect_rdm_pd_dimmer_info(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
 {
-	switch(cc) {
-	case RDM_CC_SET_COMMAND:
-	case RDM_CC_GET_COMMAND_RESPONSE:
-		proto_tree_add_item(tree, hf_rdm_pd_lamp_state, tvb,
-			offset, 1, ENC_BIG_ENDIAN);
-		offset += 1;
-		break;
-	}
+  switch(cc) {
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dimmer_info_minimum_level_lower_limit, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dimmer_info_minimum_level_upper_limit, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dimmer_info_maximum_level_lower_limit, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dimmer_info_maximum_level_upper_limit, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dimmer_info_number_of_supported_curves, tvb, &offset, 1);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dimmer_info_levels_resolution, tvb, &offset, 1);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dimmer_info_minimum_level_split_levels_supported, tvb, &offset, 1);
+    break;
+  }
+
+  return offset;
+}
 
-	return offset;
+static guint
+dissect_rdm_pd_minimum_level(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND_RESPONSE:
+  case RDM_CC_SET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_minimum_level_increasing, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_minimum_level_decreasing, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_minimum_level_on_below_minimum, tvb, &offset, 1);
+    break;
+  }
+
+  return offset;
 }
 
 static guint
-dissect_rdm_pd_lamp_on_mode(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len _U_)
+dissect_rdm_pd_maximum_level(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND_RESPONSE:
+  case RDM_CC_SET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_maximum_level_level, tvb, &offset, 2);
+    break;
+  }
+
+  return offset;
+}
+
+static guint
+dissect_rdm_pd_curve(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_curve_curve, tvb, &offset, 1);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_curve_number_of_curves, tvb, &offset, 1);
+    break;
+
+  case RDM_CC_SET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_curve_curve, tvb, &offset, 1);
+    break;
+  }
+
+  return offset;
+}
+
+static guint
+dissect_rdm_pd_curve_description(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_curve_description_curve, tvb, &offset, 1);
+    break;
+
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_curve_description_curve, tvb, &offset, 1);
+    rdm_proto_tree_add_ascii_item(tree, hf_rdm_pd_curve_description_text, tvb, &offset, len);
+    break;
+  }
+
+  return offset;
+}
+
+static guint
+dissect_rdm_pd_output_response_time(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_output_response_time_response_time, tvb, &offset, 1);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_output_response_time_number_of_response_times, tvb, &offset, 1);
+    break;
+
+  case RDM_CC_SET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_output_response_time_response_time, tvb, &offset, 1);
+    break;
+  }
+
+  return offset;
+}
+
+static guint
+dissect_rdm_pd_output_response_time_description(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len)
 {
-	switch(cc) {
-	case RDM_CC_SET_COMMAND:
-	case RDM_CC_GET_COMMAND_RESPONSE:
-		proto_tree_add_item(tree, hf_rdm_pd_lamp_on_mode, tvb,
-			offset, 1, ENC_BIG_ENDIAN);
-		offset += 1;
-		break;
-	}
+  switch(cc) {
+  case RDM_CC_GET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_output_response_time_description_output_response_time, tvb, &offset, 1);
+    break;
+
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_output_response_time_description_output_response_time, tvb, &offset, 1);
+    rdm_proto_tree_add_ascii_item(tree, hf_rdm_pd_output_response_time_description_text, tvb, &offset, len);
+    break;
+  }
+
+  return offset;
+}
+
+static guint
+dissect_rdm_pd_modulation_frequency(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_modulation_frequency_modulation_frequency, tvb, &offset, 1);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_modulation_frequency_number_of_modulation_frequencies, tvb, &offset, 1);
+    break;
+
+  case RDM_CC_SET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_modulation_frequency_modulation_frequency, tvb, &offset, 1);
+    break;
+  }
+
+  return offset;
+}
+
+static guint
+dissect_rdm_pd_modulation_frequency_description(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_modulation_frequency_description_modulation_frequency, tvb, &offset, 1);
+    break;
+
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_modulation_frequency_description_modulation_frequency, tvb, &offset, 1);
+    rdm_proto_tree_add_ascii_item(tree, hf_rdm_pd_modulation_frequency_description_text, tvb, &offset, len);
+    break;
+  }
+
+  return offset;
+}
+
+static guint
+dissect_rdm_pd_lamp_state(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len _U_)
+{
+  switch(cc) {
+  case RDM_CC_SET_COMMAND:
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_lamp_state, tvb, &offset, 1);
+    break;
+  }
+
+  return offset;
+}
 
-	return offset;
+static guint
+dissect_rdm_pd_lamp_on_mode(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len _U_)
+{
+  switch(cc) {
+  case RDM_CC_SET_COMMAND:
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_lamp_on_mode, tvb, &offset, 1);
+    break;
+  }
+
+  return offset;
 }
 
 static guint
 dissect_rdm_pd_device_power_cycles(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len _U_)
 {
-	switch(cc) {
-	case RDM_CC_SET_COMMAND:
-	case RDM_CC_GET_COMMAND_RESPONSE:
-		proto_tree_add_item(tree, hf_rdm_pd_device_power_cycles, tvb,
-			offset, 4, ENC_BIG_ENDIAN);
-		offset += 4;
-		break;
-	}
+  switch(cc) {
+  case RDM_CC_SET_COMMAND:
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_device_power_cycles, tvb, &offset, 4);
+    break;
+  }
+
+  return offset;
+}
 
-	return offset;
+static guint
+dissect_rdm_pd_burn_in(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND_RESPONSE:
+  case RDM_CC_SET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_burn_in, tvb, &offset, 1);
+    break;
+  }
+
+  return offset;
 }
 
 static guint
 dissect_rdm_pd_display_invert(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len _U_)
 {
-	switch(cc) {
-	case RDM_CC_SET_COMMAND:
-	case RDM_CC_GET_COMMAND_RESPONSE:
-		proto_tree_add_item(tree, hf_rdm_pd_display_invert, tvb,
-			offset, 1, ENC_BIG_ENDIAN);
-		offset += 1;
-		break;
-	}
-
-	return offset;
+  switch(cc) {
+  case RDM_CC_SET_COMMAND:
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_display_invert, tvb, &offset, 1);
+    break;
+  }
+
+  return offset;
 }
 
 static guint
 dissect_rdm_pd_display_level(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len _U_)
 {
-	switch(cc) {
-	case RDM_CC_SET_COMMAND:
-	case RDM_CC_GET_COMMAND_RESPONSE:
-		proto_tree_add_item(tree, hf_rdm_pd_display_level, tvb,
-			offset, 1, ENC_BIG_ENDIAN);
-		offset += 1;
-		break;
-	}
-
-	return offset;
+  switch(cc) {
+  case RDM_CC_SET_COMMAND:
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_display_level, tvb, &offset, 1);
+    break;
+  }
+
+  return offset;
 }
 
 static guint
 dissect_rdm_pd_pan_invert(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len _U_)
 {
-	switch(cc) {
-	case RDM_CC_SET_COMMAND:
-	case RDM_CC_GET_COMMAND_RESPONSE:
-		proto_tree_add_item(tree, hf_rdm_pd_pan_invert, tvb,
-			offset, 1, ENC_BIG_ENDIAN);
-		offset += 1;
-		break;
-	}
-
-	return offset;
+  switch(cc) {
+  case RDM_CC_SET_COMMAND:
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_pan_invert, tvb, &offset, 1);
+    break;
+  }
+
+  return offset;
 }
 
 static guint
 dissect_rdm_pd_tilt_invert(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len _U_)
 {
-	switch(cc) {
-	case RDM_CC_SET_COMMAND:
-	case RDM_CC_GET_COMMAND_RESPONSE:
-		proto_tree_add_item(tree, hf_rdm_pd_tilt_invert, tvb,
-			offset, 1, ENC_BIG_ENDIAN);
-		offset += 1;
-		break;
-	}
-
-	return offset;
+  switch(cc) {
+  case RDM_CC_SET_COMMAND:
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_tilt_invert, tvb, &offset, 1);
+    break;
+  }
+
+  return offset;
 }
 
 static guint
 dissect_rdm_pd_pan_tilt_swap(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len _U_)
 {
-	switch(cc) {
-	case RDM_CC_SET_COMMAND:
-	case RDM_CC_GET_COMMAND_RESPONSE:
-		proto_tree_add_item(tree, hf_rdm_pd_tilt_swap, tvb,
-			offset, 1, ENC_BIG_ENDIAN);
-		offset += 1;
-		break;
-	}
-
-	return offset;
+  switch(cc) {
+  case RDM_CC_SET_COMMAND:
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_tilt_swap, tvb, &offset, 1);
+    break;
+  }
+
+  return offset;
 }
 
 static guint
 dissect_rdm_pd_real_time_clock(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len _U_)
 {
-	switch(cc) {
-	case RDM_CC_SET_COMMAND:
-	case RDM_CC_GET_COMMAND_RESPONSE:
-		proto_tree_add_item(tree, hf_rdm_pd_real_time_clock_year, tvb,
-			offset, 2, ENC_BIG_ENDIAN);
-		offset += 2;
-		proto_tree_add_item(tree, hf_rdm_pd_real_time_clock_month, tvb,
-			offset, 1, ENC_BIG_ENDIAN);
-		offset += 1;
-		proto_tree_add_item(tree, hf_rdm_pd_real_time_clock_day, tvb,
-			offset, 1, ENC_BIG_ENDIAN);
-		offset += 1;
-		proto_tree_add_item(tree, hf_rdm_pd_real_time_clock_hour, tvb,
-			offset, 1, ENC_BIG_ENDIAN);
-		offset += 1;
-		proto_tree_add_item(tree, hf_rdm_pd_real_time_clock_minute, tvb,
-			offset, 1, ENC_BIG_ENDIAN);
-		offset += 1;
-		proto_tree_add_item(tree, hf_rdm_pd_real_time_clock_second, tvb,
-			offset, 1, ENC_BIG_ENDIAN);
-		offset += 1;
-		break;
-	}
-
-	return offset;
+  switch(cc) {
+  case RDM_CC_SET_COMMAND:
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_real_time_clock_year, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_real_time_clock_month, tvb, &offset, 1);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_real_time_clock_day, tvb, &offset, 1);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_real_time_clock_hour, tvb, &offset, 1);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_real_time_clock_minute, tvb, &offset, 1);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_real_time_clock_second, tvb, &offset, 1);
+    break;
+  }
+
+  return offset;
+}
+
+static guint
+dissect_rdm_pd_lock_pin(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_lock_pin_pin_code, tvb, &offset, 2);
+    break;
+
+  case RDM_CC_SET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_lock_pin_new_pin_code, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_lock_pin_pin_code, tvb, &offset, 2);
+    break;
+  }
+
+  return offset;
+}
+
+static guint
+dissect_rdm_pd_lock_state(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_lock_state_lock_state, tvb, &offset, 1);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_lock_state_number_of_lock_states, tvb, &offset, 1);
+    break;
+
+  case RDM_CC_SET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_lock_state_pin_code, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_lock_state_lock_state, tvb, &offset, 1);
+    break;
+  }
+
+  return offset;
+}
+
+static guint
+dissect_rdm_pd_lock_description(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_lock_state_description_lock_state, tvb, &offset, 1);
+    break;
+
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_lock_state_description_lock_state, tvb, &offset, 1);
+    rdm_proto_tree_add_ascii_item(tree, hf_rdm_pd_lock_state_description_text, tvb, &offset, len);
+    break;
+  }
+
+  return offset;
+}
+
+static guint
+dissect_rdm_pd_list_interfaces(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    while (len >= 6) {
+      rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_list_interfaces_interface_identifier, tvb, &offset, 4);
+      rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_list_interfaces_interface_hardware_type, tvb, &offset, 2);
+    }
+    break;
+  }
+
+  return offset;
+}
+
+static guint
+dissect_rdm_pd_interface_label(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_interface_label_interface_identifier, tvb, &offset, 4);
+    break;
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_interface_label_interface_identifier, tvb, &offset, 4);
+    rdm_proto_tree_add_ascii_item(tree, hf_rdm_pd_interface_label_label, tvb, &offset, len);
+    break;
+  }
+
+  return offset;
+}
+
+static guint
+dissect_rdm_pd_hardware_address_type1(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_hardware_address_type1_interface_identifier, tvb, &offset, 4);
+    break;
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_hardware_address_type1_interface_identifier, tvb, &offset, 4);
+    rdm_proto_tree_add_bytes_item(tree, hf_rdm_pd_hardware_address_type1_hardware_address, tvb, &offset, 6);
+    break;
+  }
+
+  return offset;
+}
+
+static guint
+dissect_rdm_pd_dhcp_mode(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dhcp_mode_interface_identifier, tvb, &offset, 4);
+    break;
+  case RDM_CC_GET_COMMAND_RESPONSE:
+  case RDM_CC_SET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dhcp_mode_interface_identifier, tvb, &offset, 4);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dhcp_mode_enabled, tvb, &offset, 1);
+    break;
+  }
+
+  return offset;
+}
+
+static guint
+dissect_rdm_pd_zeroconf_mode(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_zeroconf_mode_interface_identifier, tvb, &offset, 4);
+    break;
+  case RDM_CC_GET_COMMAND_RESPONSE:
+  case RDM_CC_SET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_zeroconf_mode_interface_identifier, tvb, &offset, 4);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_zeroconf_mode_enabled, tvb, &offset, 1);
+    break;
+  }
+
+  return offset;
+}
+
+static guint
+dissect_rdm_pd_current_address(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_current_address_interface_identifier, tvb, &offset, 4);
+    break;
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_current_address_interface_identifier, tvb, &offset, 4);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_current_address_ipv4_address, tvb, &offset, 4);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_current_address_netmask, tvb, &offset, 1);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_current_address_dhcp_status, tvb, &offset, 1);
+    break;
+  }
+
+  return offset;
+}
+
+static guint
+dissect_rdm_pd_static_address(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_static_address_interface_identifier, tvb, &offset, 4);
+    break;
+  case RDM_CC_GET_COMMAND_RESPONSE:
+  case RDM_CC_SET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_static_address_interface_identifier, tvb, &offset, 4);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_static_address_ipv4_address, tvb, &offset, 4);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_static_address_netmask, tvb, &offset, 1);
+    break;
+  }
+
+  return offset;
+}
+
+static guint
+dissect_rdm_pd_interface_renew_dhcp(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
+{
+  switch(cc) {
+  case RDM_CC_SET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_interface_renew_dhcp_interface_identifier, tvb, &offset, 4);
+    break;
+  }
+
+  return offset;
+}
+
+static guint
+dissect_rdm_pd_interface_release_dhcp(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
+{
+  switch(cc) {
+  case RDM_CC_SET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_interface_release_dhcp_interface_identifier, tvb, &offset, 4);
+    break;
+  }
+
+  return offset;
+}
+
+static guint
+dissect_rdm_pd_interface_apply_configuration(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
+{
+  switch(cc) {
+  case RDM_CC_SET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_interface_apply_configuration_interface_identifier, tvb, &offset, 4);
+    break;
+  }
+
+  return offset;
+}
+
+static guint
+dissect_rdm_pd_ipv4_default_route(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND_RESPONSE:
+  case RDM_CC_SET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_ipv4_default_route_interface_identifier, tvb, &offset, 4);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_ipv4_default_route_ipv4_default_route, tvb, &offset, 4);
+    break;
+  }
+
+  return offset;
+}
+
+static guint
+dissect_rdm_pd_dns_ipv4_name_server(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dns_ipv4_name_server_index, tvb, &offset, 1);
+    break;
+  case RDM_CC_GET_COMMAND_RESPONSE:
+  case RDM_CC_SET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dns_ipv4_name_server_index, tvb, &offset, 1);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_dns_ipv4_name_server_address, tvb, &offset, 4);
+    break;
+  }
+
+  return offset;
+}
+
+static guint
+dissect_rdm_pd_dns_hostname(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND_RESPONSE:
+  case RDM_CC_SET_COMMAND:
+    rdm_proto_tree_add_ascii_item(tree, hf_rdm_pd_dns_hostname, tvb, &offset, len);
+    break;
+  }
+
+  return offset;
+}
+
+static guint
+dissect_rdm_pd_dns_domain_name(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND_RESPONSE:
+  case RDM_CC_SET_COMMAND:
+    rdm_proto_tree_add_ascii_item(tree, hf_rdm_pd_dns_domain_name, tvb, &offset, len);
+    break;
+  }
+
+  return offset;
 }
 
 static guint
 dissect_rdm_pd_identify_device(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len _U_)
 {
-	switch(cc) {
-	case RDM_CC_SET_COMMAND:
-		proto_tree_add_item(tree, hf_rdm_pd_identify_device, tvb,
-			offset, 1, ENC_BIG_ENDIAN);
-		offset += 1;
-		break;
+  switch(cc) {
+  case RDM_CC_SET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_identify_device, tvb, &offset, 1);
+    break;
 
-	case RDM_CC_GET_COMMAND_RESPONSE:
-		proto_tree_add_item(tree, hf_rdm_pd_identify_device_state, tvb,
-			offset, 1, ENC_BIG_ENDIAN);
-		offset += 1;
-		break;
-	}
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_identify_device_state, tvb, &offset, 1);
+    break;
+  }
 
-	return offset;
+  return offset;
 }
 
 static guint
 dissect_rdm_pd_reset_device(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len _U_)
 {
-	switch(cc) {
-	case RDM_CC_SET_COMMAND:
-		proto_tree_add_item(tree, hf_rdm_pd_reset_device, tvb,
-			offset, 1, ENC_BIG_ENDIAN);
-		offset += 1;
-		break;
-	}
+  switch(cc) {
+  case RDM_CC_SET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_reset_device, tvb, &offset, 1);
+    break;
+  }
 
-	return offset;
+  return offset;
 }
 
 static guint
 dissect_rdm_pd_power_state(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len _U_)
 {
-	switch(cc) {
-	case RDM_CC_SET_COMMAND:
-	case RDM_CC_GET_COMMAND_RESPONSE:
-		proto_tree_add_item(tree, hf_rdm_pd_power_state, tvb,
-			offset, 1, ENC_BIG_ENDIAN);
-		offset += 1;
-		break;
-	}
-
-	return offset;
+  switch(cc) {
+  case RDM_CC_SET_COMMAND:
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_power_state, tvb, &offset, 1);
+    break;
+  }
+
+  return offset;
 }
 
 static guint
 dissect_rdm_pd_perform_selftest(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len _U_)
 {
-	switch(cc) {
-	case RDM_CC_SET_COMMAND:
-		proto_tree_add_item(tree, hf_rdm_pd_selftest_nr, tvb,
-			offset, 1, ENC_BIG_ENDIAN);
-		offset += 1;
-		break;
+  switch(cc) {
+  case RDM_CC_SET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_selftest_nr, tvb, &offset, 1);
+    break;
 
-	case RDM_CC_GET_COMMAND_RESPONSE:
-		proto_tree_add_item(tree, hf_rdm_pd_selftest_state, tvb,
-			offset, 1, ENC_BIG_ENDIAN);
-		offset += 1;
-		break;
-	}
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_selftest_state, tvb, &offset, 1);
+    break;
+  }
 
-	return offset;
+  return offset;
 }
 
 static guint
 dissect_rdm_pd_self_test_description(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len)
 {
-	switch(cc) {
-	case RDM_CC_GET_COMMAND:
-		proto_tree_add_item(tree, hf_rdm_pd_selftest_nr, tvb,
-			offset, 1, ENC_BIG_ENDIAN);
-		offset += 1;
-		break;
+  switch(cc) {
+  case RDM_CC_GET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_selftest_nr, tvb, &offset, 1);
+    break;
+
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_selftest_nr, tvb, &offset, 1);
+    rdm_proto_tree_add_ascii_item(tree, hf_rdm_pd_selftest_description, tvb, &offset, len);
+    break;
+  }
+
+  return offset;
+}
 
-	case RDM_CC_GET_COMMAND_RESPONSE:
-		proto_tree_add_item(tree, hf_rdm_pd_selftest_nr, tvb,
-			offset, 1, ENC_BIG_ENDIAN);
-		offset += 1;
-		proto_tree_add_item(tree, hf_rdm_pd_selftest_description, tvb,
-			offset, (len - 1), ENC_ASCII|ENC_NA);
-		offset += (len - 1);
-		break;
-	}
+static guint
+dissect_rdm_pd_capture_preset(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len _U_)
+{
+  switch(cc) {
+  case RDM_CC_SET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_capture_preset_scene_nr, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_capture_preset_up_fade_time, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_capture_preset_down_fade_time, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_capture_preset_wait_time, tvb, &offset, 2);
+    break;
+  }
+
+  return offset;
+}
 
-	return offset;
+static guint
+dissect_rdm_pd_preset_playback(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len _U_)
+{
+  switch(cc) {
+  case RDM_CC_SET_COMMAND:
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_preset_playback_mode, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_preset_playback_level, tvb, &offset, 1);
+    break;
+  }
+
+  return offset;
 }
 
 static guint
-dissect_rdm_pd_capture_preset(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len _U_)
+dissect_rdm_pd_identify_mode(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
 {
-	switch(cc) {
-	case RDM_CC_SET_COMMAND:
-		proto_tree_add_item(tree, hf_rdm_pd_capture_preset_scene_nr, tvb,
-			offset, 2, ENC_BIG_ENDIAN);
-		offset += 2;
-		proto_tree_add_item(tree, hf_rdm_pd_capture_preset_up_fade_time, tvb,
-			offset, 2, ENC_BIG_ENDIAN);
-		offset += 2;
-		proto_tree_add_item(tree, hf_rdm_pd_capture_preset_down_fade_time, tvb,
-			offset, 2, ENC_BIG_ENDIAN);
-		offset += 2;
-		proto_tree_add_item(tree, hf_rdm_pd_capture_preset_wait_time, tvb,
-			offset, 2, ENC_BIG_ENDIAN);
-		offset += 2;
+  switch(cc) {
+  case RDM_CC_GET_COMMAND_RESPONSE:
+  case RDM_CC_SET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_identify_mode, tvb, &offset, 1);
+    break;
+  }
+
+  return offset;
+}
 
-		break;
-	}
+static guint
+dissect_rdm_pd_preset_info(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_preset_info_level_field_supported, tvb, &offset, 1);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_preset_info_preset_sequence_supported, tvb, &offset, 1);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_preset_info_split_times_supported, tvb, &offset, 1);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_preset_info_dmx_fail_infinite_delay_time_supported, tvb, &offset, 1);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_preset_info_dmx_fail_infinite_hold_time_supported, tvb, &offset, 1);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_preset_info_start_up_infinite_hold_time_supported, tvb, &offset, 1);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_preset_info_maximum_scene_number, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_preset_info_minimum_preset_fade_time_supported, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_preset_info_maximum_preset_fade_time_supported, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_preset_info_minimum_preset_wait_time_supported, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_preset_info_maximum_preset_wait_time_supported, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_preset_info_minimum_dmx_fail_delay_time_supported, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_preset_info_maximum_dmx_fail_delay_time_supported, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_preset_info_minimum_dmx_fail_hold_time_supported, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_preset_info_maximum_dmx_fail_hold_time_supported, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_preset_info_minimum_start_up_delay_time_supported, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_preset_info_maximum_start_up_delay_time_supported, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_preset_info_minimum_start_up_hold_time_supported, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_preset_info_maximum_start_up_hold_time_supported, tvb, &offset, 2);
+    break;
+  }
+
+  return offset;
+}
 
-	return offset;
+static guint
+dissect_rdm_pd_preset_status(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_preset_status_scene_number, tvb, &offset, 2);
+    break;
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_preset_status_scene_number, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_preset_status_up_fade_time, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_preset_status_down_fade_time, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_preset_status_wait_time, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_preset_status_programmed, tvb, &offset, 1);
+    break;
+  case RDM_CC_SET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_preset_status_scene_number, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_preset_status_up_fade_time, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_preset_status_down_fade_time, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_preset_status_wait_time, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_preset_status_clear_preset, tvb, &offset, 1);
+    break;
+  }
+
+  return offset;
 }
 
 static guint
-dissect_rdm_pd_preset_playback(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len _U_)
+dissect_rdm_pd_preset_mergemode(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
 {
-	switch(cc) {
-	case RDM_CC_SET_COMMAND:
-	case RDM_CC_GET_COMMAND_RESPONSE:
-		proto_tree_add_item(tree, hf_rdm_pd_preset_playback_mode, tvb,
-			offset, 2, ENC_BIG_ENDIAN);
-		offset += 2;
-		proto_tree_add_item(tree, hf_rdm_pd_preset_playback_level, tvb,
-			offset, 1, ENC_BIG_ENDIAN);
-		offset += 1;
-		break;
-	}
+  switch(cc) {
+  case RDM_CC_GET_COMMAND_RESPONSE:
+  case RDM_CC_SET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_preset_mergemode, tvb, &offset, 1);
+    break;
+  }
+
+  return offset;
+}
 
-	return offset;
+static guint
+dissect_rdm_pd_power_on_self_test(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND_RESPONSE:
+  case RDM_CC_SET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_power_on_self_test, tvb, &offset, 1);
+    break;
+  }
+
+  return offset;
 }
 
 static guint
-dissect_rdm_mdb_param_data(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint16 param_id, guint8 pdl)
+dissect_rdm_pd_background_queued_status_policy(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
 {
-	switch(param_id) {
-	case RDM_PARAM_ID_SENSOR_VALUE:
-		offset = dissect_rdm_pd_sensor_value(tvb, offset, tree, cc, pdl);
-		break;
+  switch(cc) {
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_background_queued_status_policy_current_policy, tvb, &offset, 1);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_background_queued_status_policy_number_of_policies, tvb, &offset, 1);
+    break;
+  case RDM_CC_SET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_background_queued_status_policy_current_policy, tvb, &offset, 1);
+    break;
+  }
+
+  return offset;
+}
 
-	case RDM_PARAM_ID_QUEUED_MESSAGE:
-		offset = dissect_rdm_pd_queued_message(tvb, offset, tree, cc, pdl);
-		break;
+static guint
+dissect_rdm_pd_background_queued_status_policy_description(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_background_queued_status_policy_description_policy, tvb, &offset, 1);
+    break;
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_background_queued_status_policy_description_policy, tvb, &offset, 1);
+    rdm_proto_tree_add_ascii_item(tree, hf_rdm_pd_background_queued_status_policy_description_description, tvb, &offset, len);
+    break;
+  }
+
+  return offset;
+}
 
-	case RDM_PARAM_ID_DMX_START_ADDRESS:
-		offset = dissect_rdm_pd_dmx_start_address(tvb, offset, tree, cc, pdl);
-		break;
+static guint
+dissect_rdm_pd_endpoint_list(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_endpoint_list_change_number, tvb, &offset, 4);
+    while (len >= 3) {
+      rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_endpoint_list_endpoint_id, tvb, &offset, 2);
+      rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_endpoint_list_endpoint_type, tvb, &offset, 1);
+    }
+    break;
+  }
+
+  return offset;
+}
 
-	case RDM_PARAM_ID_DEVICE_INFO:
-		offset = dissect_rdm_pd_device_info(tvb, offset, tree, cc, pdl);
-		break;
+static guint
+dissect_rdm_pd_search_domain(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND_RESPONSE:
+  case RDM_CC_SET_COMMAND:
+    rdm_proto_tree_add_ascii_item(tree, hf_rdm_pd_search_domain_dns_domain_name, tvb, &offset, len);
+    break;
+  }
+  return offset;
+}
 
-	case RDM_PARAM_ID_DEVICE_MODEL_DESCRIPTION:
-		offset = dissect_rdm_pd_device_model_description(tvb, offset, tree, cc, pdl);
-		break;
+static guint
+dissect_rdm_pd_endpoint_to_universe(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND:
+  case RDM_CC_SET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_endpoint_to_universe_endpoint_id, tvb, &offset, 2);
+    break;
+  case RDM_CC_GET_COMMAND_RESPONSE:
+  case RDM_CC_SET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_endpoint_to_universe_endpoint_id, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_endpoint_to_universe_universe_number, tvb, &offset, 2);
+    break;
+  }
+
+  return offset;
+}
 
-	case RDM_PARAM_ID_DEVICE_LABEL:
-		offset = dissect_rdm_pd_device_label(tvb, offset, tree, cc, pdl);
-		break;
+static guint
+dissect_rdm_pd_rdm_traffic_enable(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_rdm_traffic_enable_endpoint_id, tvb, &offset, 2);
+    break;
+  case RDM_CC_GET_COMMAND_RESPONSE:
+  case RDM_CC_SET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_rdm_traffic_enable_endpoint_id, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_rdm_traffic_enable_rdm_enabled, tvb, &offset, 1);
+    break;
+  }
+
+  return offset;
+}
 
-	case RDM_PARAM_ID_DEVICE_HOURS:
-		offset = dissect_rdm_pd_device_hours(tvb, offset, tree, cc, pdl);
-		break;
+static guint
+dissect_rdm_pd_endpoint_mode(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND:
+  case RDM_CC_SET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_endpoint_mode_endpoint_id, tvb, &offset, 2);
+    break;
+  case RDM_CC_GET_COMMAND_RESPONSE:
+  case RDM_CC_SET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_endpoint_mode_endpoint_id, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_endpoint_mode_endpoint_mode, tvb, &offset, 1);
+    break;
+  }
+
+  return offset;
+}
 
-	case RDM_PARAM_ID_LAMP_HOURS:
-		offset = dissect_rdm_pd_lamp_hours(tvb, offset, tree, cc, pdl);
-		break;
+static guint
+dissect_rdm_pd_endpoint_label(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND:
+  case RDM_CC_SET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_endpoint_label_endpoint_id, tvb, &offset, 2);
+    break;
+  case RDM_CC_GET_COMMAND_RESPONSE:
+  case RDM_CC_SET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_endpoint_label_endpoint_id, tvb, &offset, 2);
+    rdm_proto_tree_add_ascii_item(tree, hf_rdm_pd_endpoint_label_label, tvb, &offset, len);
+    break;
+  }
+
+  return offset;
+}
 
-	case RDM_PARAM_ID_LAMP_STRIKES:
-		offset = dissect_rdm_pd_lamp_strikes(tvb, offset, tree, cc, pdl);
-		break;
+static guint
+dissect_rdm_pd_discovery_state(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND:
+  case RDM_CC_SET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_discovery_state_endpoint_id, tvb, &offset, 2);
+    break;
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_discovery_state_endpoint_id, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_discovery_state_device_count, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_discovery_state_discovery_state, tvb, &offset, 1);
+    break;
+  case RDM_CC_SET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_discovery_state_endpoint_id, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_discovery_state_discovery_state, tvb, &offset, 1);
+    break;
+  }
+
+  return offset;
+}
 
-	case RDM_PARAM_ID_SENSOR_DEFINITION:
-		offset = dissect_rdm_pd_sensor_definition(tvb, offset, tree, cc, pdl);
-		break;
+static guint
+dissect_rdm_pd_endpoint_timing(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND:
+  case RDM_CC_SET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_endpoint_timing_endpoint_id, tvb, &offset, 2);
+    break;
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_endpoint_timing_endpoint_id, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_endpoint_timing_setting, tvb, &offset, 1);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_endpoint_timing_number_of_settings, tvb, &offset, 1);
+    break;
+  case RDM_CC_SET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_endpoint_timing_endpoint_id, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_endpoint_timing_setting, tvb, &offset, 1);
+    break;
+  }
+
+  return offset;
+}
 
-	case RDM_PARAM_ID_MANUFACTURER_LABEL:
-		offset = dissect_rdm_pd_manufacturer_label(tvb, offset, tree, cc, pdl);
-		break;
+static guint
+dissect_rdm_pd_endpoint_timing_description(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_endpoint_timing_description_setting, tvb, &offset, 1);
+    break;
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_endpoint_timing_description_setting, tvb, &offset, 1);
+    rdm_proto_tree_add_ascii_item(tree, hf_rdm_pd_endpoint_timing_description_description, tvb, &offset, len);
+    break;
+  }
+
+  return offset;
+}
 
-	case RDM_PARAM_ID_DISC_UNIQUE_BRANCH:
-		offset = dissect_rdm_pd_disc_unique_branch(tvb, offset, tree, cc, pdl);
-		break;
+static guint
+dissect_rdm_pd_binding_control_fields(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_binding_control_fields_endpoint_id, tvb, &offset, 2);
+    rdm_proto_tree_add_bytes_item(tree, hf_rdm_pd_binding_control_fields_uid, tvb, &offset, 6);
+    break;
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_binding_control_fields_endpoint_id, tvb, &offset, 2);
+    rdm_proto_tree_add_bytes_item(tree, hf_rdm_pd_binding_control_fields_uid, tvb, &offset, 6);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_binding_control_fields_control_field, tvb, &offset, 2);
+    rdm_proto_tree_add_bytes_item(tree, hf_rdm_pd_binding_control_fields_binding_uid, tvb, &offset, 6);
+    break;
+  }
+
+  return offset;
+}
 
-	case RDM_PARAM_ID_DISC_MUTE:
-		offset = dissect_rdm_pd_disc_mute(tvb, offset, tree, cc, pdl);
-		break;
+static guint
+dissect_rdm_pd_identify_endpoint(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND:
+  case RDM_CC_SET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_identify_endpoint_endpoint_id, tvb, &offset, 2);
+    break;
+  case RDM_CC_GET_COMMAND_RESPONSE:
+  case RDM_CC_SET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_identify_endpoint_endpoint_id, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_identify_endpoint_identify_state, tvb, &offset, 1);
+    break;
+  }
+
+  return offset;
+}
 
-	case RDM_PARAM_ID_DISC_UN_MUTE:
-		offset = dissect_rdm_pd_disc_un_mute(tvb, offset, tree, cc, pdl);
-		break;
+static guint
+dissect_rdm_pd_background_discovery(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND:
+  case RDM_CC_SET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_background_discovery_endpoint_id, tvb, &offset, 2);
+    break;
+  case RDM_CC_GET_COMMAND_RESPONSE:
+  case RDM_CC_SET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_background_discovery_endpoint_id, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_background_discovery_enabled, tvb, &offset, 1);
+    break;
+  }
+
+  return offset;
+}
 
-	case RDM_PARAM_ID_PROXIED_DEVICES:
-		offset = dissect_rdm_pd_proxied_devices(tvb, offset, tree, cc, pdl);
-		break;
+static guint
+dissect_rdm_pd_endpoint_responder_list_change(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_endpoint_responder_list_change_endpoint_id, tvb, &offset, 2);
+    break;
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_endpoint_responder_list_change_endpoint_id, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_endpoint_responder_list_change_change_number, tvb, &offset, 4);
+    break;
+  }
+
+  return offset;
+}
 
-	case RDM_PARAM_ID_PROXIED_DEVICE_COUNT:
-		offset = dissect_rdm_pd_proxied_device_count(tvb, offset, tree, cc, pdl);
-		break;
+static guint
+dissect_rdm_pd_endpoint_responders(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_endpoint_responders_endpoint_id, tvb, &offset, 2);
+    break;
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_endpoint_responders_endpoint_id, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_endpoint_responders_change_number, tvb, &offset, 4);
+    while (len >= 6) {
+      rdm_proto_tree_add_bytes_item(tree, hf_rdm_pd_endpoint_responders_uid, tvb, &offset, 6);
+    }
+    break;
+  }
+
+  return offset;
+}
 
-	case RDM_PARAM_ID_COMMS_STATUS:
-		offset = dissect_rdm_pd_comms_status(tvb, offset, tree, cc, pdl);
-		break;
+static guint
+dissect_rdm_pd_tcp_comms_status(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    while (len >= 87) {
+      rdm_proto_tree_add_ascii_item(tree, hf_rdm_pd_tcp_comms_status_scope_string, tvb, &offset, 63);
+      rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_tcp_comms_status_broker_ipv4_address, tvb, &offset, 4);
+      rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_tcp_comms_status_broker_ipv6_address, tvb, &offset, 16);
+      rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_tcp_comms_status_broker_port, tvb, &offset, 2);
+      rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_tcp_comms_status_unhealthy_tcp_events, tvb, &offset, 2);
+    }
+    break;
+  case RDM_CC_SET_COMMAND:
+    rdm_proto_tree_add_ascii_item(tree, hf_rdm_pd_tcp_comms_status_scope_string, tvb, &offset, 63);
+    break;
+  }
+
+  return offset;
+}
 
-	case RDM_PARAM_ID_STATUS_MESSAGES:
-		offset = dissect_rdm_pd_status_messages(tvb, offset, tree, cc, pdl);
-		break;
+static guint
+dissect_rdm_pd_endpoint_list_change(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_endpoint_list_change_change_number, tvb, &offset, 4);
+    break;
+  }
 
-	case RDM_PARAM_ID_STATUS_ID_DESCRIPTION:
-		offset = dissect_rdm_pd_status_id_description(tvb, offset, tree, cc, pdl);
-		break;
+  return offset;
+}
 
-	case RDM_PARAM_ID_CLEAR_STATUS_ID:
-		offset = dissect_rdm_pd_clear_status_id(tvb, offset, tree, cc, pdl);
-		break;
+static guint
+dissect_rdm_pd_component_scope(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_component_scope_scope_slot, tvb, &offset, 2);
+    break;
+  case RDM_CC_GET_COMMAND_RESPONSE:
+  case RDM_CC_SET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_component_scope_scope_slot, tvb, &offset, 2);
+    rdm_proto_tree_add_ascii_item(tree, hf_rdm_pd_component_scope_scope_string, tvb, &offset, 63);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_component_scope_scope_static_config_type, tvb, &offset, 1);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_component_scope_scope_static_ipv4_address, tvb, &offset, 4);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_component_scope_scope_static_ipv6_address, tvb, &offset, 16);
+    rdm_proto_tree_add_numeric_item(tree, hf_rdm_pd_component_scope_scope_static_port, tvb, &offset, 2);
+    break;
+  }
+
+  return offset;
+}
 
-	case RDM_PARAM_ID_SUB_DEVICE_STATUS_REPORT_THRESHOLD:
-		offset = dissect_rdm_pd_sub_device_status_report_threshold(tvb, offset, tree, cc, pdl);
-		break;
+static guint
+dissect_rdm_pd_broker_status(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_rem_pd_broker_status_set_allowed, tvb, &offset, 1);
+    rdm_proto_tree_add_numeric_item(tree, hf_rem_pd_broker_status_state, tvb, &offset, 1);
+    break;
+  case RDM_CC_SET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_rem_pd_broker_status_state, tvb, &offset, 1);
+    break;
+  }
+
+  return offset;
+}
 
-	case RDM_PARAM_ID_SUPPORTED_PARAMETERS:
-		offset = dissect_rdm_pd_supported_parameters(tvb, offset, tree, cc, pdl);
-		break;
+static guint
+dissect_etc_pd_led_curve(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND_RESPONSE:
+  case RDM_CC_SET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_led_curve, tvb, &offset, 1);
+    break;
+  }
+
+  return offset;
+}
 
-	case RDM_PARAM_ID_PARAMETER_DESCRIPTION:
-		offset = dissect_rdm_pd_parameter_description(tvb, offset, tree, cc, pdl);
-		break;
+static guint
+dissect_etc_pd_led_curve_description(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_led_curve_description_curve, tvb, &offset, 1);
+    break;
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_led_curve_description_curve, tvb, &offset, 1);
+    rdm_proto_tree_add_ascii_item(tree, hf_etc_pd_led_curve_description_text, tvb, &offset, len);
+    break;
+  }
+
+  return offset;
+}
 
-	case RDM_PARAM_ID_PRODUCT_DETAIL_ID_LIST:
-		offset = dissect_rdm_pd_product_detail_id_list(tvb, offset, tree, cc, pdl);
-		break;
+static guint
+dissect_etc_pd_led_strobe(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND_RESPONSE:
+  case RDM_CC_SET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_led_strobe, tvb, &offset, 1);
+    break;
+  }
+
+  return offset;
+}
 
-	case RDM_PARAM_ID_FACTORY_DEFAULTS:
-		offset = dissect_rdm_pd_factory_defaults(tvb, offset, tree, cc, pdl);
-		break;
+static guint
+dissect_etc_pd_led_output_mode(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND_RESPONSE:
+  case RDM_CC_SET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_led_output_mode, tvb, &offset, 1);
+    break;
+  }
+
+  return offset;
+}
 
-	case RDM_PARAM_ID_LANGUAGE_CAPABILITIES:
-		offset = dissect_rdm_pd_language_capabilities(tvb, offset, tree, cc, pdl);
-		break;
+static guint
+dissect_etc_pd_led_output_mode_description(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_led_output_mode_description_mode, tvb, &offset, 1);
+    break;
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_led_output_mode_description_mode, tvb, &offset, 1);
+    rdm_proto_tree_add_ascii_item(tree, hf_etc_pd_led_output_mode_description_text, tvb, &offset, len);
+    break;
+  }
+
+  return offset;
+}
 
-	case RDM_PARAM_ID_LANGUAGE:
-		offset = dissect_rdm_pd_language(tvb, offset, tree, cc, pdl);
-		break;
+static guint
+dissect_etc_pd_led_red_shift(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND_RESPONSE:
+  case RDM_CC_SET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_led_red_shift, tvb, &offset, 1);
+    break;
+  }
+
+  return offset;
+}
 
-	case RDM_PARAM_ID_SOFTWARE_VERSION_LABEL:
-		offset = dissect_rdm_pd_software_version_label(tvb, offset, tree, cc, pdl);
-		break;
+static guint
+dissect_etc_pd_led_white_point(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND_RESPONSE:
+  case RDM_CC_SET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_led_white_point, tvb, &offset, 1);
+    break;
+  }
+
+  return offset;
+}
 
-	case RDM_PARAM_ID_BOOT_SOFTWARE_VERSION_ID:
-		offset = dissect_rdm_pd_boot_software_version_id(tvb, offset, tree, cc, pdl);
-		break;
+static guint
+dissect_etc_pd_led_white_point_description(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_led_white_point_description_white_point, tvb, &offset, 1);
+    break;
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_led_white_point_description_white_point, tvb, &offset, 1);
+    rdm_proto_tree_add_ascii_item(tree, hf_etc_pd_led_white_point_description_text, tvb, &offset, len);
+    break;
+  }
+
+  return offset;
+}
 
-	case RDM_PARAM_ID_BOOT_SOFTWARE_VERSION_LABEL:
-		offset = dissect_rdm_pd_boot_software_version_label(tvb, offset, tree, cc, pdl);
-		break;
+static guint
+dissect_etc_pd_led_frequency(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND_RESPONSE:
+  case RDM_CC_SET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_led_frequency, tvb, &offset, 2);
+    break;
+  }
+
+  return offset;
+}
 
-	case RDM_PARAM_ID_DMX_PERSONALITY:
-		offset = dissect_rdm_pd_dmx_personality(tvb, offset, tree, cc, pdl);
-		break;
+static guint
+dissect_etc_pd_dmx_data_loss_behavior(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND_RESPONSE:
+  case RDM_CC_SET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_dmx_data_loss_behavior, tvb, &offset, 1);
+    break;
+  }
+
+  return offset;
+}
 
-	case RDM_PARAM_ID_DMX_PERSONALITY_DESCRIPTION:
-		offset = dissect_rdm_pd_dmx_personality_description(tvb, offset, tree, cc, pdl);
-		break;
+static guint
+dissect_etc_pd_dmx_data_loss_behavior_description(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_dmx_data_loss_behavior_description_behavior, tvb, &offset, 1);
+    break;
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_dmx_data_loss_behavior_description_behavior, tvb, &offset, 1);
+    rdm_proto_tree_add_ascii_item(tree, hf_etc_pd_dmx_data_loss_behavior_description_text, tvb, &offset, len);
+    break;
+  }
+
+  return offset;
+}
+
+static guint
+dissect_etc_pd_led_plus_seven(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND_RESPONSE:
+  case RDM_CC_SET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_led_plus_seven, tvb, &offset, 1);
+    break;
+  }
+
+  return offset;
+}
 
-	case RDM_PARAM_ID_SLOT_INFO:
-		offset = dissect_rdm_pd_slot_info(tvb, offset, tree, cc, pdl);
-		break;
+static guint
+dissect_etc_pd_backlight_brightness(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND_RESPONSE:
+  case RDM_CC_SET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_backlight_brightness, tvb, &offset, 1);
+    break;
+  }
+
+  return offset;
+}
 
-	case RDM_PARAM_ID_SLOT_DESCRIPTION:
-		offset = dissect_rdm_pd_slot_description(tvb, offset, tree, cc, pdl);
-		break;
+static guint
+dissect_etc_pd_backlight_timeout(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND_RESPONSE:
+  case RDM_CC_SET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_backlight_timeout, tvb, &offset, 1);
+    break;
+  }
+
+  return offset;
+}
 
-	case RDM_PARAM_ID_DEFAULT_SLOT_VALUE:
-		offset = dissect_rdm_pd_slot_value(tvb, offset, tree, cc, pdl);
-		break;
+static guint
+dissect_etc_pd_status_indicators(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND_RESPONSE:
+  case RDM_CC_SET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_status_indicators, tvb, &offset, 1);
+    break;
+  }
+
+  return offset;
+}
 
-	case RDM_PARAM_ID_RECORD_SENSORS:
-		offset = dissect_rdm_pd_record_sensors(tvb, offset, tree, cc, pdl);
-		break;
+static guint
+dissect_etc_pd_recalibrate_fixture(guint offset)
+{
+  /* set-only, no data */
+  return offset;
+}
 
-	case RDM_PARAM_ID_LAMP_STATE:
-		offset = dissect_rdm_pd_lamp_state(tvb, offset, tree, cc, pdl);
-		break;
+static guint
+dissect_etc_pd_overtemp_mode(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND_RESPONSE:
+  case RDM_CC_SET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_overtemp_mode, tvb, &offset, 1);
+    break;
+  }
+
+  return offset;
+}
 
-	case RDM_PARAM_ID_LAMP_ON_MODE:
-		offset = dissect_rdm_pd_lamp_on_mode(tvb, offset, tree, cc, pdl);
-		break;
+static guint
+dissect_etc_pd_simple_setup_mode(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND_RESPONSE:
+  case RDM_CC_SET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_simple_setup_mode, tvb, &offset, 1);
+    break;
+  }
+
+  return offset;
+}
 
-	case RDM_PARAM_ID_DEVICE_POWER_CYCLES:
-		offset = dissect_rdm_pd_device_power_cycles(tvb, offset, tree, cc, pdl);
-		break;
+static guint
+dissect_etc_pd_led_strobe_description(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_led_strobe_description_strobe, tvb, &offset, 1);
+    break;
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_led_strobe_description_strobe, tvb, &offset, 1);
+    rdm_proto_tree_add_ascii_item(tree, hf_etc_pd_led_strobe_description_text, tvb, &offset, len);
+    break;
+  }
+
+  return offset;
+}
 
-	case RDM_PARAM_ID_DISPLAY_INVERT:
-		offset = dissect_rdm_pd_display_invert(tvb, offset, tree, cc, pdl);
-		break;
+static guint
+dissect_etc_pd_red_shift_description(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_red_shift_description_red_shift, tvb, &offset, 1);
+    break;
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_red_shift_description_red_shift, tvb, &offset, 1);
+    rdm_proto_tree_add_ascii_item(tree, hf_etc_pd_red_shift_description_text, tvb, &offset, len);
+    break;
+  }
+
+  return offset;
+}
 
-	case RDM_PARAM_ID_DISPLAY_LEVEL:
-		offset = dissect_rdm_pd_display_level(tvb, offset, tree, cc, pdl);
-		break;
+static guint
+dissect_etc_pd_plus_seven_description(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_plus_seven_description_plus_seven, tvb, &offset, 1);
+    break;
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_plus_seven_description_plus_seven, tvb, &offset, 1);
+    rdm_proto_tree_add_ascii_item(tree, hf_etc_pd_plus_seven_description_text, tvb, &offset, len);
+    break;
+  }
+
+  return offset;
+}
 
-	case RDM_PARAM_ID_PAN_INVERT:
-		offset = dissect_rdm_pd_pan_invert(tvb, offset, tree, cc, pdl);
-		break;
+static guint
+dissect_etc_pd_backlight_timeout_description(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_backlight_timeout_description_timeout, tvb, &offset, 1);
+    break;
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_backlight_timeout_description_timeout, tvb, &offset, 1);
+    rdm_proto_tree_add_ascii_item(tree, hf_etc_pd_backlight_timeout_description_text, tvb, &offset, len);
+    break;
+  }
+
+  return offset;
+}
 
-	case RDM_PARAM_ID_TILT_INVERT:
-		offset = dissect_rdm_pd_tilt_invert(tvb, offset, tree, cc, pdl);
-		break;
+static guint
+dissect_etc_pd_simple_setup_mode_description(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_simple_setup_mode_description_mode, tvb, &offset, 1);
+    break;
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_simple_setup_mode_description_mode, tvb, &offset, 1);
+    rdm_proto_tree_add_ascii_item(tree, hf_etc_pd_simple_setup_mode_description_text, tvb, &offset, len);
+    break;
+  }
+
+  return offset;
+}
 
-	case RDM_PARAM_ID_PAN_TILT_SWAP:
-		offset = dissect_rdm_pd_pan_tilt_swap(tvb, offset, tree, cc, pdl);
-		break;
+static guint
+dissect_etc_pd_overtemp_mode_description(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_overtemp_mode_description_mode, tvb, &offset, 1);
+    break;
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_overtemp_mode_description_mode, tvb, &offset, 1);
+    rdm_proto_tree_add_ascii_item(tree, hf_etc_pd_overtemp_mode_description_text, tvb, &offset, len);
+    break;
+  }
+
+  return offset;
+}
 
-	case RDM_PARAM_ID_REAL_TIME_CLOCK:
-		offset = dissect_rdm_pd_real_time_clock(tvb, offset, tree, cc, pdl);
-		break;
+static guint
+dissect_etc_pd_led_requested_xy(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_led_requested_xy_x, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_led_requested_xy_y, tvb, &offset, 2);
+    break;
+  }
+
+  return offset;
+}
 
-	case RDM_PARAM_ID_IDENTIFY_DEVICE:
-		offset = dissect_rdm_pd_identify_device(tvb, offset, tree, cc, pdl);
-		break;
+static guint
+dissect_etc_pd_led_current_xy(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_led_current_xy_x, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_led_current_xy_y, tvb, &offset, 2);
+    break;
+  }
+
+  return offset;
+}
 
-	case RDM_PARAM_ID_RESET_DEVICE:
-		offset = dissect_rdm_pd_reset_device(tvb, offset, tree, cc, pdl);
-		break;
+static guint
+dissect_etc_pd_current_pwm(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_current_pwm_led_number, tvb, &offset, 1);
+    break;
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_current_pwm_led_number, tvb, &offset, 1);
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_current_pwm_channel_duty_cycle, tvb, &offset, 2);
+    break;
+  }
+
+  return offset;
+}
 
-	case RDM_PARAM_ID_POWER_STATE:
-		offset = dissect_rdm_pd_power_state(tvb, offset, tree, cc, pdl);
-		break;
+static guint
+dissect_etc_pd_tristimulus(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_tristimulus_led_number, tvb, &offset, 1);
+    break;
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_tristimulus_led_number, tvb, &offset, 1);
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_tristimulus_x, tvb, &offset, 4);
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_tristimulus_y, tvb, &offset, 4);
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_tristimulus_z, tvb, &offset, 4);
+    break;
+  }
+
+  return offset;
+}
 
-	case RDM_PARAM_ID_PERFORM_SELFTEST:
-		offset = dissect_rdm_pd_perform_selftest(tvb, offset, tree, cc, pdl);
-		break;
+static guint
+dissect_etc_pd_led_information(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_led_information_led_number, tvb, &offset, 1);
+    break;
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_led_information_led_number, tvb, &offset, 1);
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_led_information_type, tvb, &offset, 1);
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_led_information_dmx_control_channel, tvb, &offset, 1);
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_led_information_drive_current, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_led_information_gamut_polygon_order, tvb, &offset, 1);
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_led_information_quantity, tvb, &offset, 1);
+    break;
+  }
+
+  return offset;
+}
 
-	case RDM_PARAM_ID_SELF_TEST_DESCRIPTION:
-		offset = dissect_rdm_pd_self_test_description(tvb, offset, tree, cc, pdl);
-		break;
+static guint
+dissect_etc_pd_preset_config(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_preset_config_preset_number, tvb, &offset, 2);
+    break;
+  case RDM_CC_GET_COMMAND_RESPONSE:
+  case RDM_CC_SET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_preset_config_preset_number, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_preset_config_fade_time, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_preset_config_delay_time, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_preset_config_hue, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_preset_config_saturation, tvb, &offset, 1);
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_preset_config_intensity, tvb, &offset, 1);
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_preset_config_strobe, tvb, &offset, 1);
+    break;
+  }
+
+  return offset;
+}
 
-	case RDM_PARAM_ID_CAPTURE_PRESET:
-		offset = dissect_rdm_pd_capture_preset(tvb, offset, tree, cc, pdl);
-		break;
+static guint
+dissect_etc_pd_sequence_playback(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND_RESPONSE:
+  case RDM_CC_SET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_sequence_playback_sequence_number, tvb, &offset, 2);
+    break;
+  }
+
+  return offset;
+}
 
-	case RDM_PARAM_ID_PRESET_PLAYBACK:
-		offset = dissect_rdm_pd_preset_playback(tvb, offset, tree, cc, pdl);
-		break;
+static guint
+dissect_etc_pd_sequence_config(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
+{
+  guint       i;
+  proto_tree *preset_steps_tree, *preset_steps_sub_item;
+  proto_tree *step_link_times_tree, *step_link_times_sub_item;
+
+  switch(cc) {
+  case RDM_CC_GET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_sequence_config_sequence_number, tvb, &offset, 2);
+    break;
+  case RDM_CC_GET_COMMAND_RESPONSE:
+  case RDM_CC_SET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_sequence_config_sequence_number, tvb, &offset, 2);
+
+    preset_steps_tree = proto_tree_add_item(tree, hf_etc_pd_sequence_config_preset_steps, tvb, offset, 24, ENC_NA);
+    preset_steps_sub_item = proto_item_add_subtree(preset_steps_tree, ett_etc_sequence_config_steps);
+    for (i = 0; i < 24; i++) {
+      rdm_proto_tree_add_numeric_item(preset_steps_sub_item, hf_etc_pd_sequence_config_preset_step, tvb, &offset, 1);
+    }
+
+    step_link_times_tree = proto_tree_add_item(tree, hf_etc_pd_sequence_config_step_link_times, tvb, offset, 48, ENC_NA);
+    step_link_times_sub_item = proto_item_add_subtree(step_link_times_tree, ett_etc_sequence_config_times);
+    for (i = 0; i < 24; i++) {
+      rdm_proto_tree_add_numeric_item(step_link_times_sub_item, hf_etc_pd_sequence_config_step_link_time, tvb, &offset, 2);
+    }
+
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_sequence_config_rate, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_sequence_config_end_state, tvb, &offset, 1);
+    break;
+  }
+
+  return offset;
+}
 
-	default:
-		proto_tree_add_item(tree, hf_rdm_parameter_data_raw, tvb,
-			offset, pdl, ENC_NA);
-		offset += pdl;
-		break;
-	}
 
-	return offset;
+static guint
+dissect_etc_pd_low_power_timeout(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND_RESPONSE:
+  case RDM_CC_SET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_low_power_timeout, tvb, &offset, 1);
+    break;
+  }
+
+  return offset;
 }
 
 static guint
-dissect_rdm_pd_ack_overflow(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint16 param_id _U_, guint8 pdl)
+dissect_etc_pd_low_power_timeout_description(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len)
 {
-	if (pdl > 0) {
-		switch(cc) {
-		case RDM_CC_GET_COMMAND_RESPONSE:
-		case RDM_CC_SET_COMMAND_RESPONSE:
-			proto_tree_add_item(tree, hf_rdm_pd_ack_overflow_raw_data, tvb, offset, pdl, ENC_NA);
-			offset += pdl;
-			break;
-		}
-	}
+  switch(cc) {
+  case RDM_CC_GET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_low_power_timeout_description_timeout, tvb, &offset, 1);
+    break;
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_low_power_timeout_description_timeout, tvb, &offset, 1);
+    rdm_proto_tree_add_ascii_item(tree, hf_etc_pd_low_power_timeout_description_text, tvb, &offset, len);
+    break;
+  }
+
+  return offset;
+}
 
-	return offset;
+static guint
+dissect_etc_pd_led_enum_frequency(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND_RESPONSE:
+  case RDM_CC_SET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_led_enum_frequency, tvb, &offset, 1);
+    break;
+  }
+
+  return offset;
 }
 
 static guint
-dissect_rdm_pd_ack_timer(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint16 param_id _U_, guint8 pdl)
+dissect_etc_pd_led_enum_frequency_description(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len)
 {
-	if (pdl == 2) {
-		switch(cc) {
-		case RDM_CC_GET_COMMAND_RESPONSE:
-		case RDM_CC_SET_COMMAND_RESPONSE:
-			proto_tree_add_item(tree, hf_rdm_pd_ack_timer_estimated_response_time, tvb,
-				offset, 2, ENC_BIG_ENDIAN);
-			offset += 2;
-			break;
-		}
-	}
-	return offset;
+  switch(cc) {
+  case RDM_CC_GET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_led_enum_frequency_description_frequency, tvb, &offset, 1);
+    break;
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_led_enum_frequency_description_frequency, tvb, &offset, 1);
+    rdm_proto_tree_add_ascii_item(tree, hf_etc_pd_led_enum_frequency_description_text, tvb, &offset, len);
+    break;
+  }
+
+  return offset;
 }
 
 static guint
-dissect_rdm_pd_nack_reason(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint16 param_id _U_, guint8 pdl _U_)
+dissect_etc_pd_rgbi_preset_config(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
 {
-	if (pdl == 2) {
-		switch(cc) {
-		case RDM_CC_GET_COMMAND_RESPONSE:
-		case RDM_CC_SET_COMMAND_RESPONSE:
-			proto_tree_add_item(tree, hf_rdm_pd_nack_reason_code, tvb,
-				offset, 2, ENC_BIG_ENDIAN);
-			offset += 2;
-			break;
-		}
-	}
-
-	return offset;
-}
-
-static guint
-dissect_rdm_mdb(tvbuff_t *tvb, guint offset, proto_tree *tree)
-{
-	guint8      cc;
-	guint8      rt;
-	guint16	    param_id;
-	guint8	    parameter_data_length;
-	proto_tree *hi,*si, *mdb_tree;
-
-	rt = tvb_get_guint8(tvb, offset);
-	cc = tvb_get_guint8(tvb, offset + 4);
-
-	if ((cc & RDM_CC_COMMAND_RESPONSE_FLAG) == RDM_CC_COMMAND_RESPONSE_FLAG) {
-		proto_tree_add_item(tree, hf_rdm_response_type, tvb,
-				offset, 1, ENC_BIG_ENDIAN);
-	        offset += 1;
-
-	} else {
-		proto_tree_add_item(tree, hf_rdm_port_id, tvb,
-		                offset, 1, ENC_BIG_ENDIAN);
-	        offset += 1;
-	}
-
-	proto_tree_add_item(tree, hf_rdm_message_count, tvb,
-			offset, 1, ENC_BIG_ENDIAN);
-	offset += 1;
-
-	proto_tree_add_item(tree, hf_rdm_sub_device, tvb,
-			offset, 2, ENC_BIG_ENDIAN);
-	offset += 2;
-
-	hi = proto_tree_add_item(tree, hf_rdm_mdb, tvb,
-			offset, -1, ENC_NA);
-	mdb_tree = proto_item_add_subtree(hi,ett_rdm);
-
-	proto_tree_add_item(mdb_tree, hf_rdm_command_class, tvb,
-			offset, 1, ENC_BIG_ENDIAN);
-	offset += 1;
-
-	param_id = tvb_get_ntohs(tvb, offset);
-	proto_tree_add_item(mdb_tree, hf_rdm_parameter_id, tvb,
-			offset, 2, ENC_BIG_ENDIAN);
-	offset += 2;
-
-	parameter_data_length = tvb_get_guint8(tvb, offset);
-	proto_tree_add_item(mdb_tree, hf_rdm_parameter_data_length, tvb,
-			offset, 1, ENC_BIG_ENDIAN);
-	offset += 1;
-	proto_item_set_len( mdb_tree,  parameter_data_length + 4);
-
-	if (parameter_data_length > 0) {
-
-		hi = proto_tree_add_item(mdb_tree, hf_rdm_parameter_data, tvb,
-				offset, parameter_data_length, ENC_NA);
-		si = proto_item_add_subtree(hi,ett_rdm);
-
-		if ((cc & RDM_CC_COMMAND_RESPONSE_FLAG) == RDM_CC_COMMAND_RESPONSE_FLAG) {
-
-			switch(rt) {
-			case RDM_RESPONSE_TYPE_ACK:
-				offset = dissect_rdm_mdb_param_data(tvb, offset, si, cc, param_id, parameter_data_length);
-				break;
-			case RDM_RESPONSE_TYPE_ACK_TIMER:
-				offset = dissect_rdm_pd_ack_timer(tvb, offset, si, cc, param_id, parameter_data_length);
-				break;
-			case RDM_RESPONSE_TYPE_NACK_REASON:
-				offset = dissect_rdm_pd_nack_reason(tvb, offset, si, cc, param_id, parameter_data_length);
-				break;
-			case RDM_RESPONSE_TYPE_ACK_OVERFLOW:
-				offset = dissect_rdm_pd_ack_overflow(tvb, offset, si, cc, param_id, parameter_data_length);
-				break;
-			}
-
-		} else {
-			offset = dissect_rdm_mdb_param_data(tvb, offset, si, cc, param_id, parameter_data_length);
-		}
-	}
-
-	return offset;
+  switch(cc) {
+  case RDM_CC_GET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_rgbi_preset_config_preset_number, tvb, &offset, 2);
+    break;
+  case RDM_CC_GET_COMMAND_RESPONSE:
+  case RDM_CC_SET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_rgbi_preset_config_preset_number, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_rgbi_preset_config_fade_time, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_rgbi_preset_config_delay_time, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_rgbi_preset_config_red, tvb, &offset, 1);
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_rgbi_preset_config_green, tvb, &offset, 1);
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_rgbi_preset_config_blue, tvb, &offset, 1);
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_rgbi_preset_config_intensity, tvb, &offset, 1);
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_rgbi_preset_config_strobe, tvb, &offset, 1);
+    break;
+  }
+
+  return offset;
 }
 
-static int
-dissect_rdm(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
+static guint
+dissect_etc_pd_cct_preset_config(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
 {
-	col_set_str(pinfo->cinfo, COL_PROTOCOL, "RDM");
-	col_clear(pinfo->cinfo, COL_INFO);
+  switch(cc) {
+  case RDM_CC_GET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_cct_preset_config_preset_number, tvb, &offset, 2);
+    break;
+  case RDM_CC_GET_COMMAND_RESPONSE:
+  case RDM_CC_SET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_cct_preset_config_preset_number, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_cct_preset_config_fade_time, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_cct_preset_config_delay_time, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_cct_preset_config_white_point, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_cct_preset_config_tint, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_cct_preset_config_strobe, tvb, &offset, 1);
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_cct_preset_config_intensity, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_cct_preset_config_tone, tvb, &offset, 1);
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_cct_preset_config_reserved, tvb, &offset, 4);
+    break;
+  }
+
+  return offset;
+}
 
-	if (tree) {
-		gint	    padding_size;
-		guint16	    man_id;
-		guint32	    dev_id;
-		guint       message_length, offset = 0;
+static guint
+dissect_etc_pd_supplementary_device_version(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_supplementary_device_version_param_index, tvb, &offset, 1);
+    break;
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_supplementary_device_version_param_index, tvb, &offset, 1);
+    rdm_proto_tree_add_ascii_item(tree, hf_etc_pd_supplementary_device_version_param_description, tvb, &offset, len);
+    break;
+  }
+
+  return offset;
+}
 
-		proto_tree *ti = proto_tree_add_item(tree, proto_rdm, tvb,
-				offset, -1, ENC_NA);
-		proto_tree *rdm_tree = proto_item_add_subtree(ti, ett_rdm);
+static guint
+dissect_etc_pd_power_command(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND_RESPONSE:
+  case RDM_CC_SET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_power_command, tvb, &offset, 1);
+    break;
+  }
+
+  return offset;
+}
 
-		proto_tree_add_item(rdm_tree, hf_rdm_sub_start_code, tvb,
-				offset, 1, ENC_BIG_ENDIAN);
-		offset += 1;
+static guint
+dissect_etc_pd_power_command_description(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_power_command_description_state, tvb, &offset, 1);
+    break;
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_power_command_description_state, tvb, &offset, 1);
+    rdm_proto_tree_add_ascii_item(tree, hf_etc_pd_power_command_description_text, tvb, &offset, len);
+    break;
+  }
+
+  return offset;
+}
 
-		message_length = tvb_get_guint8(tvb, offset);
-		proto_tree_add_item(rdm_tree, hf_rdm_message_length, tvb,
-				offset, 1, ENC_BIG_ENDIAN);
-		offset += 1;
+static guint
+dissect_etc_pd_dali_short_address(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND_RESPONSE:
+  case RDM_CC_SET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_dali_short_address, tvb, &offset, 1);
+    break;
+  }
+
+  return offset;
+}
 
-		man_id = tvb_get_ntohs(tvb, offset);
-		dev_id = tvb_get_ntohl(tvb, offset + 2);
-		proto_item_append_text(ti, ", Dst UID: %04x:%08x", man_id, dev_id);
-		proto_tree_add_item(rdm_tree, hf_rdm_dest_uid, tvb,
-				offset, 6, ENC_NA);
-		offset += 6;
+static guint
+dissect_etc_pd_dali_group_membership(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND_RESPONSE:
+  case RDM_CC_SET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_dali_group_membership, tvb, &offset, 2);
+    break;
+  }
+
+  return offset;
+}
+
+static guint
+dissect_etc_pd_auto_bind(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND_RESPONSE:
+  case RDM_CC_SET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_auto_bind, tvb, &offset, 1);
+    break;
+  }
+
+  return offset;
+}
+
+static guint
+dissect_etc_pd_delete_subdevice(guint offset)
+{
+  /* set-only, no data */
+  return offset;
+}
+
+static guint
+dissect_etc_pd_packet_delay(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND_RESPONSE:
+  case RDM_CC_SET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_packet_delay, tvb, &offset, 1);
+    break;
+  }
+
+  return offset;
+}
+
+static guint
+dissect_etc_pd_has_enum_text(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_has_enum_text_pid, tvb, &offset, 2);
+    break;
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_has_enum_text_pid, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_has_enum_text_true_false, tvb, &offset, 1);
+    break;
+  }
+
+  return offset;
+}
+
+static guint
+dissect_etc_pd_get_enum_text(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint8 len)
+{
+  switch(cc) {
+  case RDM_CC_GET_COMMAND:
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_get_enum_text_pid, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_get_enum_text_enum, tvb, &offset, 4);
+    break;
+  case RDM_CC_GET_COMMAND_RESPONSE:
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_get_enum_text_pid, tvb, &offset, 2);
+    rdm_proto_tree_add_numeric_item(tree, hf_etc_pd_get_enum_text_enum, tvb, &offset, 4);
+    rdm_proto_tree_add_ascii_item(tree, hf_etc_pd_get_enum_text_description, tvb, &offset, len);
+    break;
+  }
+
+  return offset;
+}
+
+static guint
+dissect_etc_pd_prepare_for_software_download(guint offset)
+{
+  /* set-only, no data */
+  return offset;
+}
+
+static guint
+dissect_etc_pid(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint16 param_id, guint8 pdl)
+{
+  switch(param_id) {
+  case ETC_PARAM_ID_LED_CURVE:
+    offset = dissect_etc_pd_led_curve(tvb, offset, tree, cc);
+    break;
+  case ETC_PARAM_ID_LED_CURVE_DESCRIPTION:
+    offset = dissect_etc_pd_led_curve_description(tvb, offset, tree, cc, pdl);
+    break;
+  case ETC_PARAM_ID_LED_STROBE:
+    offset = dissect_etc_pd_led_strobe(tvb, offset, tree, cc);
+    break;
+  case ETC_PARAM_ID_LED_OUTPUT_MODE:
+    offset = dissect_etc_pd_led_output_mode(tvb, offset, tree, cc);
+    break;
+  case ETC_PARAM_ID_LED_OUTPUT_MODE_DESCRIPTION:
+    offset = dissect_etc_pd_led_output_mode_description(tvb, offset, tree, cc, pdl);
+    break;
+  case ETC_PARAM_ID_LED_RED_SHIFT:
+    offset = dissect_etc_pd_led_red_shift(tvb, offset, tree, cc);
+    break;
+  case ETC_PARAM_ID_LED_WHITE_POINT:
+    offset = dissect_etc_pd_led_white_point(tvb, offset, tree, cc);
+    break;
+  case ETC_PARAM_ID_LED_WHITE_POINT_DESCRIPTION:
+    offset = dissect_etc_pd_led_white_point_description(tvb, offset, tree, cc, pdl);
+    break;
+  case ETC_PARAM_ID_LED_FREQUENCY:
+    offset = dissect_etc_pd_led_frequency(tvb, offset, tree, cc);
+    break;
+  case ETC_PARAM_ID_DMX_LOSS_BEHAVIOR:
+    offset = dissect_etc_pd_dmx_data_loss_behavior(tvb, offset, tree, cc);
+    break;
+  case ETC_PARAM_ID_DMX_LOSS_BEHAVIOR_DESCRIPTION:
+    offset = dissect_etc_pd_dmx_data_loss_behavior_description(tvb, offset, tree, cc, pdl);
+    break;
+  case ETC_PARAM_ID_LED_PLUS_SEVEN:
+    offset = dissect_etc_pd_led_plus_seven(tvb, offset, tree, cc);
+    break;
+  case ETC_PARAM_ID_BACKLIGHT_BRIGHTNESS:
+    offset = dissect_etc_pd_backlight_brightness(tvb, offset, tree, cc);
+    break;
+  case ETC_PARAM_ID_BACKLIGHT_TIMEOUT:
+    offset = dissect_etc_pd_backlight_timeout(tvb, offset, tree, cc);
+    break;
+  case ETC_PARAM_ID_STATUS_INDICATORS:
+    offset = dissect_etc_pd_status_indicators(tvb, offset, tree, cc);
+    break;
+  case ETC_PARAM_ID_RECALIBRATE_FIXTURE:
+    offset = dissect_etc_pd_recalibrate_fixture(offset);
+    break;
+  case ETC_PARAM_ID_OVERTEMPMODE:
+    offset = dissect_etc_pd_overtemp_mode(tvb, offset, tree, cc);
+    break;
+  case ETC_PARAM_ID_SIMPLESETUPMODE:
+    offset = dissect_etc_pd_simple_setup_mode(tvb, offset, tree, cc);
+    break;
+  case ETC_PARAM_ID_LED_STROBE_DESCRIPTION:
+    offset = dissect_etc_pd_led_strobe_description(tvb, offset, tree, cc, pdl);
+    break;
+  case ETC_PARAM_ID_LED_RED_SHIFT_DESCRIPTION:
+    offset = dissect_etc_pd_red_shift_description(tvb, offset, tree, cc, pdl);
+    break;
+  case ETC_PARAM_ID_LED_PLUS_SEVEN_DESCRIPTION:
+    offset = dissect_etc_pd_plus_seven_description(tvb, offset, tree, cc, pdl);
+    break;
+  case ETC_PARAM_ID_BACKLIGHT_TIMEOUT_DESCRIPTION:
+    offset = dissect_etc_pd_backlight_timeout_description(tvb, offset, tree, cc, pdl);
+    break;
+  case ETC_PARAM_ID_SIMPLESETUPMODE_DESCRIPTION:
+    offset = dissect_etc_pd_simple_setup_mode_description(tvb, offset, tree, cc, pdl);
+    break;
+  case ETC_PARAM_ID_OVERTEMPMODE_DESCRIPTION:
+    offset = dissect_etc_pd_overtemp_mode_description(tvb, offset, tree, cc, pdl);
+    break;
+  case ETC_PARAM_ID_LED_REQUESTED_XY:
+    offset = dissect_etc_pd_led_requested_xy(tvb, offset, tree, cc);
+    break;
+  case ETC_PARAM_ID_LED_CURRENT_XY:
+    offset = dissect_etc_pd_led_current_xy(tvb, offset, tree, cc);
+    break;
+  case ETC_PARAM_ID_LED_CURRENT_PWM:
+    offset = dissect_etc_pd_current_pwm(tvb, offset, tree, cc);
+    break;
+  case ETC_PARAM_ID_LED_TRISTIMULUS:
+    offset = dissect_etc_pd_tristimulus(tvb, offset, tree, cc);
+    break;
+  case ETC_PARAM_ID_LED_INFORMATION:
+    offset = dissect_etc_pd_led_information(tvb, offset, tree, cc);
+    break;
+  case ETC_PARAM_ID_PRESETCONFIG:
+    offset = dissect_etc_pd_preset_config(tvb, offset, tree, cc);
+    break;
+  case ETC_PARAM_ID_SEQUENCE_PLAYBACK:
+    offset = dissect_etc_pd_sequence_playback(tvb, offset, tree, cc);
+    break;
+  case ETC_PARAM_ID_SEQUENCE_CONFIG:
+    offset = dissect_etc_pd_sequence_config(tvb, offset, tree, cc);
+    break;
+  case ETC_PARAM_ID_LOW_POWER_TIMEOUT:
+    offset = dissect_etc_pd_low_power_timeout(tvb, offset, tree, cc);
+    break;
+  case ETC_PARAM_ID_LOW_POWER_TIMEOUT_DESCRIPTION:
+    offset = dissect_etc_pd_low_power_timeout_description(tvb, offset, tree, cc, pdl);
+    break;
+  case ETC_PARAM_ID_LED_ENUM_FREQUENCY:
+    offset = dissect_etc_pd_led_enum_frequency(tvb, offset, tree, cc);
+    break;
+  case ETC_PARAM_ID_LED_ENUM_FREQUENCY_DESCRIPTION:
+    offset = dissect_etc_pd_led_enum_frequency_description(tvb, offset, tree, cc, pdl);
+    break;
+  case ETC_PARAM_ID_RGBI_PRESETCONFIG:
+    offset = dissect_etc_pd_rgbi_preset_config(tvb, offset, tree, cc);
+    break;
+  case ETC_PARAM_ID_CCT_PRESETCONFIG:
+    offset = dissect_etc_pd_cct_preset_config(tvb, offset, tree, cc);
+    break;
+  case ETC_PARAM_ID_SUPPLEMENTARY_DEVICE_VERSION:
+    offset = dissect_etc_pd_supplementary_device_version(tvb, offset, tree, cc, pdl);
+    break;
+/* do not display
+  case ETC_PARAM_ID_START_UWB_DISCOVER:
+    break;
+  case ETC_PARAM_ID_START_UWB_MEASURE:
+    break;
+  case ETC_PARAM_ID_POSITION:
+    break;
+*/
+/* TODO: begin need descriptions */
+  case ETC_PARAM_ID_S4DIM_CALIBRATE:
+    break;
+  case ETC_PARAM_ID_S4DIM_CALIBRATE_DESCRIPTION:
+    break;
+  case ETC_PARAM_ID_S4DIM_TEST_MODE:
+    break;
+  case ETC_PARAM_ID_S4DIM_TEST_MODE_DESCRIPTION:
+    break;
+  case ETC_PARAM_ID_S4DIM_MAX_OUTPUT_VOLTAGE:
+    break;
+  case ETC_PARAM_ID_S4DIM_MAX_OUTPUT_VOLTAGE_DESCRIPTION:
+    break;
+/* TODO: end need descriptions */
+  case ETC_PARAM_ID_POWER_COMMAND:
+    offset = dissect_etc_pd_power_command(tvb, offset, tree, cc);
+    break;
+  case ETC_PARAM_ID_POWER_COMMAND_DESCRIPTION:
+    offset = dissect_etc_pd_power_command_description(tvb, offset, tree, cc, pdl);
+    break;
+/* TODO: begin need descriptions */
+  case ETC_PARAM_ID_THRESHOLD_COMMAND:
+    break;
+  case ETC_PARAM_ID_TURNON_DELAY_COMMAND:
+    break;
+/* TODO: end need descriptions */
+  case ETC_PARAM_ID_SET_DALI_SHORTADDRESS:
+    offset = dissect_etc_pd_dali_short_address(tvb, offset, tree, cc);
+    break;
+  case ETC_PARAM_ID_DALI_GROUP_MEMBERSHIP:
+    offset = dissect_etc_pd_dali_group_membership(tvb, offset, tree, cc);
+    break;
+  case ETC_PARAM_ID_AUTOBIND:
+    offset = dissect_etc_pd_auto_bind(tvb, offset, tree, cc);
+    break;
+  case ETC_PARAM_ID_DELETE_SUBDEVICE:
+    offset = dissect_etc_pd_delete_subdevice(offset);
+    break;
+  case ETC_PARAM_ID_PACKET_DELAY:
+    offset = dissect_etc_pd_packet_delay(tvb, offset, tree, cc);
+    break;
+  case ETC_PARAM_ID_HAS_ENUM_TEXT:
+    offset = dissect_etc_pd_has_enum_text(tvb, offset, tree, cc);
+    break;
+  case ETC_PARAM_ID_GET_ENUM_TEXT:
+    offset = dissect_etc_pd_get_enum_text(tvb, offset, tree, cc, pdl);
+    break;
+  case ETC_PARAM_ID_PREPAREFORSOFTWAREDOWNLOAD:
+    offset = dissect_etc_pd_prepare_for_software_download(offset);
+    break;
+  default:
+    proto_tree_add_item(tree, hf_rdm_parameter_data_raw, tvb, offset, pdl, ENC_NA);
+    offset += pdl;
+  }
+
+  return offset;
+}
+
+static guint
+dissect_manufacturer_specific_pid(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint16 param_id, guint8 pdl, guint16 device_manufacturer_id)
+{
+  switch(device_manufacturer_id) {
+  case RDM_MANUFACTURER_ID_ETC:
+    offset = dissect_etc_pid(tvb, offset, tree, cc, param_id, pdl);
+    break;
+  default:
+    proto_tree_add_item(tree, hf_rdm_parameter_data_raw, tvb, offset, pdl, ENC_NA);
+    offset += pdl;
+    break;
+  }
+
+  return offset;
+}
+
+static guint
+dissect_rdm_mdb_param_data(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint16 param_id, guint8 pdl, guint16 device_manufacturer_id)
+{
+  if (param_id >= 0x8000) {
+    offset = dissect_manufacturer_specific_pid(tvb, offset, tree, cc, param_id, pdl, device_manufacturer_id);
+  } else {
+    switch(param_id) {
+    case RDM_PARAM_ID_SENSOR_VALUE:
+      offset = dissect_rdm_pd_sensor_value(tvb, offset, tree, cc, pdl);
+      break;
+
+    case RDM_PARAM_ID_QUEUED_MESSAGE:
+      offset = dissect_rdm_pd_queued_message(tvb, offset, tree, cc, pdl);
+      break;
+
+    case RDM_PARAM_ID_DMX_START_ADDRESS:
+      offset = dissect_rdm_pd_dmx_start_address(tvb, offset, tree, cc, pdl);
+      break;
+
+    case RDM_PARAM_ID_DEVICE_INFO:
+      offset = dissect_rdm_pd_device_info(tvb, offset, tree, cc, pdl, device_manufacturer_id);
+      break;
+
+    case RDM_PARAM_ID_DEVICE_MODEL_DESCRIPTION:
+      offset = dissect_rdm_pd_device_model_description(tvb, offset, tree, cc, pdl);
+      break;
+
+    case RDM_PARAM_ID_DEVICE_LABEL:
+      offset = dissect_rdm_pd_device_label(tvb, offset, tree, cc, pdl);
+      break;
+
+    case RDM_PARAM_ID_DEVICE_HOURS:
+      offset = dissect_rdm_pd_device_hours(tvb, offset, tree, cc, pdl);
+      break;
+
+    case RDM_PARAM_ID_LAMP_HOURS:
+      offset = dissect_rdm_pd_lamp_hours(tvb, offset, tree, cc, pdl);
+      break;
+
+    case RDM_PARAM_ID_LAMP_STRIKES:
+      offset = dissect_rdm_pd_lamp_strikes(tvb, offset, tree, cc, pdl);
+      break;
+
+    case RDM_PARAM_ID_SENSOR_DEFINITION:
+      offset = dissect_rdm_pd_sensor_definition(tvb, offset, tree, cc, pdl);
+      break;
+
+    case RDM_PARAM_ID_MANUFACTURER_LABEL:
+      offset = dissect_rdm_pd_manufacturer_label(tvb, offset, tree, cc, pdl);
+      break;
+
+    case RDM_PARAM_ID_DISC_UNIQUE_BRANCH:
+      offset = dissect_rdm_pd_disc_unique_branch(tvb, offset, tree, cc, pdl);
+      break;
+
+    case RDM_PARAM_ID_DISC_MUTE:
+      offset = dissect_rdm_pd_disc_mute(tvb, offset, tree, cc, pdl);
+      break;
+
+    case RDM_PARAM_ID_DISC_UN_MUTE:
+      offset = dissect_rdm_pd_disc_un_mute(tvb, offset, tree, cc, pdl);
+      break;
+
+    case RDM_PARAM_ID_PROXIED_DEVICES:
+      offset = dissect_rdm_pd_proxied_devices(tvb, offset, tree, cc, pdl);
+      break;
+
+    case RDM_PARAM_ID_PROXIED_DEVICE_COUNT:
+      offset = dissect_rdm_pd_proxied_device_count(tvb, offset, tree, cc, pdl);
+      break;
+
+    case RDM_PARAM_ID_COMMS_STATUS:
+      offset = dissect_rdm_pd_comms_status(tvb, offset, tree, cc, pdl);
+      break;
+
+    case RDM_PARAM_ID_STATUS_MESSAGES:
+      offset = dissect_rdm_pd_status_messages(tvb, offset, tree, cc, pdl);
+      break;
+
+    case RDM_PARAM_ID_STATUS_ID_DESCRIPTION:
+      offset = dissect_rdm_pd_status_id_description(tvb, offset, tree, cc, pdl);
+      break;
+
+    case RDM_PARAM_ID_CLEAR_STATUS_ID:
+      offset = dissect_rdm_pd_clear_status_id(tvb, offset, tree, cc, pdl);
+      break;
+
+    case RDM_PARAM_ID_SUB_DEVICE_STATUS_REPORT_THRESHOLD:
+      offset = dissect_rdm_pd_sub_device_status_report_threshold(tvb, offset, tree, cc, pdl);
+      break;
+
+    case RDM_PARAM_ID_SUPPORTED_PARAMETERS:
+      offset = dissect_rdm_pd_supported_parameters(tvb, offset, tree, cc, pdl, device_manufacturer_id);
+      break;
+
+    case RDM_PARAM_ID_PARAMETER_DESCRIPTION:
+      offset = dissect_rdm_pd_parameter_description(tvb, offset, tree, cc, pdl, device_manufacturer_id);
+      break;
+
+    case RDM_PARAM_ID_PRODUCT_DETAIL_ID_LIST:
+      offset = dissect_rdm_pd_product_detail_id_list(tvb, offset, tree, cc, pdl);
+      break;
+
+    case RDM_PARAM_ID_FACTORY_DEFAULTS:
+      offset = dissect_rdm_pd_factory_defaults(tvb, offset, tree, cc, pdl);
+      break;
+
+    case RDM_PARAM_ID_LANGUAGE_CAPABILITIES:
+      offset = dissect_rdm_pd_language_capabilities(tvb, offset, tree, cc, pdl);
+      break;
+
+    case RDM_PARAM_ID_LANGUAGE:
+      offset = dissect_rdm_pd_language(tvb, offset, tree, cc, pdl);
+      break;
+
+    case RDM_PARAM_ID_SOFTWARE_VERSION_LABEL:
+      offset = dissect_rdm_pd_software_version_label(tvb, offset, tree, cc, pdl);
+      break;
+
+    case RDM_PARAM_ID_BOOT_SOFTWARE_VERSION_ID:
+      offset = dissect_rdm_pd_boot_software_version_id(tvb, offset, tree, cc, pdl);
+      break;
+
+    case RDM_PARAM_ID_BOOT_SOFTWARE_VERSION_LABEL:
+      offset = dissect_rdm_pd_boot_software_version_label(tvb, offset, tree, cc, pdl);
+      break;
+
+    case RDM_PARAM_ID_DMX_PERSONALITY:
+      offset = dissect_rdm_pd_dmx_personality(tvb, offset, tree, cc, pdl);
+      break;
+
+    case RDM_PARAM_ID_DMX_PERSONALITY_DESCRIPTION:
+      offset = dissect_rdm_pd_dmx_personality_description(tvb, offset, tree, cc, pdl);
+      break;
+
+    case RDM_PARAM_ID_SLOT_INFO:
+      offset = dissect_rdm_pd_slot_info(tvb, offset, tree, cc, pdl);
+      break;
+
+    case RDM_PARAM_ID_SLOT_DESCRIPTION:
+      offset = dissect_rdm_pd_slot_description(tvb, offset, tree, cc, pdl);
+      break;
+
+    case RDM_PARAM_ID_DEFAULT_SLOT_VALUE:
+      offset = dissect_rdm_pd_slot_value(tvb, offset, tree, cc, pdl);
+      break;
+
+    case RDM_PARAM_ID_DMX_BLOCK_ADDRESS:
+      offset = dissect_rdm_pd_dmx_block_address(tvb, offset, tree, cc);
+      break;
+
+    case RDM_PARAM_ID_DMX_FAIL_MODE:
+      offset = dissect_rdm_pd_dmx_fail_mode(tvb, offset, tree, cc);
+      break;
+
+    case RDM_PARAM_ID_DMX_STARTUP_MODE:
+      offset = dissect_rdm_pd_dmx_startup_mode(tvb, offset, tree, cc);
+      break;
+
+    case RDM_PARAM_ID_RECORD_SENSORS:
+      offset = dissect_rdm_pd_record_sensors(tvb, offset, tree, cc, pdl);
+      break;
+
+    case RDM_PARAM_ID_DIMMER_INFO:
+      offset = dissect_rdm_pd_dimmer_info(tvb, offset, tree, cc);
+      break;
+
+    case RDM_PARAM_ID_MINIMUM_LEVEL:
+      offset = dissect_rdm_pd_minimum_level(tvb, offset, tree, cc);
+      break;
+
+    case RDM_PARAM_ID_MAXIMUM_LEVEL:
+      offset = dissect_rdm_pd_maximum_level(tvb, offset, tree, cc);
+      break;
+
+    case RDM_PARAM_ID_CURVE:
+      offset = dissect_rdm_pd_curve(tvb, offset, tree, cc);
+      break;
+
+    case RDM_PARAM_ID_CURVE_DESCRIPTION:
+      offset = dissect_rdm_pd_curve_description(tvb, offset, tree, cc, pdl);
+      break;
+
+    case RDM_PARAM_ID_OUTPUT_RESPONSE_TIME:
+      offset = dissect_rdm_pd_output_response_time(tvb, offset, tree, cc);
+      break;
+
+    case RDM_PARAM_ID_OUTPUT_RESPONSE_TIME_DESCRIPTION:
+      offset = dissect_rdm_pd_output_response_time_description(tvb, offset, tree, cc, pdl);
+      break;
+
+    case RDM_PARAM_ID_MODULATION_FREQUENCY:
+      offset = dissect_rdm_pd_modulation_frequency(tvb, offset, tree, cc);
+      break;
+
+    case RDM_PARAM_ID_MODULATION_FREQUENCY_DESCRIPTION:
+      offset = dissect_rdm_pd_modulation_frequency_description(tvb, offset, tree, cc, pdl);
+      break;
+
+    case RDM_PARAM_ID_LAMP_STATE:
+      offset = dissect_rdm_pd_lamp_state(tvb, offset, tree, cc, pdl);
+      break;
+
+    case RDM_PARAM_ID_LAMP_ON_MODE:
+      offset = dissect_rdm_pd_lamp_on_mode(tvb, offset, tree, cc, pdl);
+      break;
+
+    case RDM_PARAM_ID_DEVICE_POWER_CYCLES:
+      offset = dissect_rdm_pd_device_power_cycles(tvb, offset, tree, cc, pdl);
+      break;
+
+    case RDM_PARAM_ID_BURN_IN:
+      offset = dissect_rdm_pd_burn_in(tvb, offset, tree, cc);
+      break;
+
+    case RDM_PARAM_ID_DISPLAY_INVERT:
+      offset = dissect_rdm_pd_display_invert(tvb, offset, tree, cc, pdl);
+      break;
+
+    case RDM_PARAM_ID_DISPLAY_LEVEL:
+      offset = dissect_rdm_pd_display_level(tvb, offset, tree, cc, pdl);
+      break;
+
+    case RDM_PARAM_ID_PAN_INVERT:
+      offset = dissect_rdm_pd_pan_invert(tvb, offset, tree, cc, pdl);
+      break;
+
+    case RDM_PARAM_ID_TILT_INVERT:
+      offset = dissect_rdm_pd_tilt_invert(tvb, offset, tree, cc, pdl);
+      break;
+
+    case RDM_PARAM_ID_PAN_TILT_SWAP:
+      offset = dissect_rdm_pd_pan_tilt_swap(tvb, offset, tree, cc, pdl);
+      break;
+
+    case RDM_PARAM_ID_REAL_TIME_CLOCK:
+      offset = dissect_rdm_pd_real_time_clock(tvb, offset, tree, cc, pdl);
+      break;
+
+    case RDM_PARAM_ID_LOCK_PIN:
+      offset = dissect_rdm_pd_lock_pin(tvb, offset, tree, cc);
+      break;
+
+    case RDM_PARAM_ID_LOCK_STATE:
+      offset = dissect_rdm_pd_lock_state(tvb, offset, tree, cc);
+      break;
+
+    case RDM_PARAM_ID_LOCK_STATE_DESCRIPTION:
+      offset = dissect_rdm_pd_lock_description(tvb, offset, tree, cc, pdl);
+      break;
+
+    case RDM_PARAM_ID_LIST_INTERFACES:
+      offset = dissect_rdm_pd_list_interfaces(tvb, offset, tree, cc, pdl);
+      break;
 
+    case RDM_PARAM_ID_INTERFACE_LABEL:
+      offset = dissect_rdm_pd_interface_label(tvb, offset, tree, cc, pdl);
+      break;
 
-		man_id = tvb_get_ntohs(tvb, offset);
-		dev_id = tvb_get_ntohl(tvb, offset + 2);
-		proto_item_append_text(ti, ", Src UID: %04x:%08x", man_id, dev_id);
-		proto_tree_add_item(rdm_tree, hf_rdm_src_uid, tvb,
-				offset, 6, ENC_NA);
-		offset += 6;
+    case RDM_PARAM_ID_INTERFACE_HARDWARE_ADDRESS_TYPE1:
+      offset = dissect_rdm_pd_hardware_address_type1(tvb, offset, tree, cc);
+      break;
 
-		proto_tree_add_item(rdm_tree, hf_rdm_transaction_number, tvb,
-				offset, 1, ENC_BIG_ENDIAN);
-		offset += 1;
+    case RDM_PARAM_ID_IPV4_DHCP_MODE:
+      offset = dissect_rdm_pd_dhcp_mode(tvb, offset, tree, cc);
+      break;
 
-		offset = dissect_rdm_mdb(tvb, offset, rdm_tree);
+    case RDM_PARAM_ID_IPV4_ZEROCONF_MODE:
+      offset = dissect_rdm_pd_zeroconf_mode(tvb, offset, tree, cc);
+      break;
 
-		padding_size = offset - (message_length - 1);
-		if (padding_size > 0) {
-			proto_tree_add_item(rdm_tree, hf_rdm_intron, tvb,
-					offset, padding_size, ENC_NA);
-			offset += padding_size;
-		}
+    case RDM_PARAM_ID_IPV4_CURRENT_ADDRESS:
+      offset = dissect_rdm_pd_current_address(tvb, offset, tree, cc);
+      break;
 
-		proto_tree_add_checksum(rdm_tree, tvb, offset, hf_rdm_checksum, hf_rdm_checksum_status, &ei_rdm_checksum, pinfo, rdm_checksum(tvb, offset),
-							ENC_BIG_ENDIAN, PROTO_CHECKSUM_VERIFY);
-		offset += 2;
+    case RDM_PARAM_ID_IPV4_STATIC_ADDRESS:
+      offset = dissect_rdm_pd_static_address(tvb, offset, tree, cc);
+      break;
 
-		if (offset < tvb_reported_length(tvb))
-			proto_tree_add_item(rdm_tree, hf_rdm_trailer, tvb,
-					offset, -1, ENC_NA);
-	}
-	return tvb_captured_length(tvb);
+    case RDM_PARAM_ID_INTERFACE_RENEW_DHCP:
+      offset = dissect_rdm_pd_interface_renew_dhcp(tvb, offset, tree, cc);
+      break;
+
+    case RDM_PARAM_ID_INTERFACE_RELEASE_DHCP:
+      offset = dissect_rdm_pd_interface_release_dhcp(tvb, offset, tree, cc);
+      break;
+
+    case RDM_PARAM_ID_INTERFACE_APPLY_CONFIGURATION:
+      offset = dissect_rdm_pd_interface_apply_configuration(tvb, offset, tree, cc);
+      break;
+
+    case RDM_PARAM_ID_IPV4_DEFAULT_ROUTE:
+      offset = dissect_rdm_pd_ipv4_default_route(tvb, offset, tree, cc);
+      break;
+
+    case RDM_PARAM_ID_DNS_IPV4_NAME_SERVER:
+      offset = dissect_rdm_pd_dns_ipv4_name_server(tvb, offset, tree, cc);
+      break;
+
+    case RDM_PARAM_ID_DNS_HOSTNAME:
+      offset = dissect_rdm_pd_dns_hostname(tvb, offset, tree, cc, pdl);
+      break;
+
+    case RDM_PARAM_ID_DNS_DOMAIN_NAME:
+      offset = dissect_rdm_pd_dns_domain_name(tvb, offset, tree, cc, pdl);
+      break;
+
+    case RDM_PARAM_ID_IDENTIFY_DEVICE:
+      offset = dissect_rdm_pd_identify_device(tvb, offset, tree, cc, pdl);
+      break;
+
+    case RDM_PARAM_ID_RESET_DEVICE:
+      offset = dissect_rdm_pd_reset_device(tvb, offset, tree, cc, pdl);
+      break;
+
+    case RDM_PARAM_ID_POWER_STATE:
+      offset = dissect_rdm_pd_power_state(tvb, offset, tree, cc, pdl);
+      break;
+
+    case RDM_PARAM_ID_PERFORM_SELFTEST:
+      offset = dissect_rdm_pd_perform_selftest(tvb, offset, tree, cc, pdl);
+      break;
+
+    case RDM_PARAM_ID_SELF_TEST_DESCRIPTION:
+      offset = dissect_rdm_pd_self_test_description(tvb, offset, tree, cc, pdl);
+      break;
+
+    case RDM_PARAM_ID_CAPTURE_PRESET:
+      offset = dissect_rdm_pd_capture_preset(tvb, offset, tree, cc, pdl);
+      break;
+
+    case RDM_PARAM_ID_PRESET_PLAYBACK:
+      offset = dissect_rdm_pd_preset_playback(tvb, offset, tree, cc, pdl);
+      break;
+
+    case RDM_PARAM_ID_IDENTIFY_MODE:
+      offset = dissect_rdm_pd_identify_mode(tvb, offset, tree, cc);
+      break;
+
+    case RDM_PARAM_ID_PRESET_INFO:
+      offset = dissect_rdm_pd_preset_info(tvb, offset, tree, cc);
+      break;
+
+    case RDM_PARAM_ID_PRESET_STATUS:
+      offset = dissect_rdm_pd_preset_status(tvb, offset, tree, cc);
+      break;
+
+    case RDM_PARAM_ID_PRESET_MERGEMODE:
+      offset = dissect_rdm_pd_preset_mergemode(tvb, offset, tree, cc);
+      break;
+
+    case RDM_PARAM_ID_POWER_ON_SELF_TEST:
+      offset = dissect_rdm_pd_power_on_self_test(tvb, offset, tree, cc);
+      break;
+
+    case RDM_PARAM_ID_BACKGROUND_QUEUED_STATUS_POLICY:
+      offset = dissect_rdm_pd_background_queued_status_policy(tvb, offset, tree, cc);
+      break;
+
+    case RDM_PARAM_ID_BACKGROUND_QUEUED_STATUS_POLICY_DESCRIPTION:
+      offset = dissect_rdm_pd_background_queued_status_policy_description(tvb, offset, tree, cc, pdl);
+      break;
+
+    case RDM_PARAM_ID_ENDPOINT_LIST:
+      offset = dissect_rdm_pd_endpoint_list(tvb, offset, tree, cc, pdl);
+      break;
+
+    case RDM_PARAM_ID_SEARCH_DOMAIN:
+      offset = dissect_rdm_pd_search_domain(tvb, offset, tree, cc, pdl);
+      break;
+
+    case RDM_PARAM_ID_ENDPOINT_TO_UNIVERSE:
+      offset = dissect_rdm_pd_endpoint_to_universe(tvb, offset, tree, cc);
+      break;
+
+    case RDM_PARAM_ID_RDM_TRAFFIC_ENABLE:
+      offset = dissect_rdm_pd_rdm_traffic_enable(tvb, offset, tree, cc);
+      break;
+
+    case RDM_PARAM_ID_ENDPOINT_MODE:
+      offset = dissect_rdm_pd_endpoint_mode(tvb, offset, tree, cc);
+      break;
+
+    case RDM_PARAM_ID_ENDPOINT_LABEL:
+      offset = dissect_rdm_pd_endpoint_label(tvb, offset, tree, cc, pdl);
+      break;
+
+    case RDM_PARAM_ID_DISCOVERY_STATE:
+      offset = dissect_rdm_pd_discovery_state(tvb, offset, tree, cc);
+      break;
+
+    case RDM_PARAM_ID_ENDPOINT_TIMING:
+      offset = dissect_rdm_pd_endpoint_timing(tvb, offset, tree, cc);
+      break;
+
+    case RDM_PARAM_ID_ENDPOINT_TIMING_DESCRIPTION:
+      offset = dissect_rdm_pd_endpoint_timing_description(tvb, offset, tree, cc, pdl);
+      break;
+
+    case RDM_PARAM_ID_BINDING_CONTROL_FIELDS:
+      offset = dissect_rdm_pd_binding_control_fields(tvb, offset, tree, cc);
+      break;
+
+    case RDM_PARAM_ID_IDENTIFY_ENDPOINT:
+      offset = dissect_rdm_pd_identify_endpoint(tvb, offset, tree, cc);
+      break;
+
+    case RDM_PARAM_ID_BACKGROUND_DISCOVERY:
+      offset = dissect_rdm_pd_background_discovery(tvb, offset, tree, cc);
+      break;
+
+    case RDM_PARAM_ID_ENDPOINT_RESPONDER_LIST_CHANGE:
+      offset = dissect_rdm_pd_endpoint_responder_list_change(tvb, offset, tree, cc);
+      break;
+
+    case RDM_PARAM_ID_ENDPOINT_RESPONDERS:
+      offset = dissect_rdm_pd_endpoint_responders(tvb, offset, tree, cc, pdl);
+      break;
+
+    case RDM_PARAM_ID_TCP_COMMS_STATUS:
+      offset = dissect_rdm_pd_tcp_comms_status(tvb, offset, tree, cc, pdl);
+      break;
+
+    case RDM_PARAM_ID_ENDPOINT_LIST_CHANGE:
+      offset = dissect_rdm_pd_endpoint_list_change(tvb, offset, tree, cc);
+      break;
+
+    case RDM_PARAM_ID_COMPONENT_SCOPE:
+      offset = dissect_rdm_pd_component_scope(tvb, offset, tree, cc);
+      break;
+
+    case RDM_PARAM_ID_BROKER_STATUS:
+      offset = dissect_rdm_pd_broker_status(tvb, offset, tree, cc);
+      break;
+
+    default:
+      proto_tree_add_item(tree, hf_rdm_parameter_data_raw, tvb,
+        offset, pdl, ENC_NA);
+      offset += pdl;
+      break;
+    }
+  }
+
+  return offset;
+}
+
+static guint
+dissect_rdm_pd_ack_overflow(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint16 param_id _U_, guint8 pdl)
+{
+  if (pdl > 0) {
+    switch(cc) {
+    case RDM_CC_GET_COMMAND_RESPONSE:
+    case RDM_CC_SET_COMMAND_RESPONSE:
+      proto_tree_add_item(tree, hf_rdm_pd_ack_overflow_raw_data, tvb, offset, pdl, ENC_NA);
+      offset += pdl;
+      break;
+    }
+  }
+
+  return offset;
+}
+
+static guint
+dissect_rdm_pd_ack_timer(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint16 param_id _U_, guint8 pdl)
+{
+  if (pdl == 2) {
+    switch(cc) {
+    case RDM_CC_GET_COMMAND_RESPONSE:
+    case RDM_CC_SET_COMMAND_RESPONSE:
+      proto_tree_add_item(tree, hf_rdm_pd_ack_timer_estimated_response_time, tvb,
+        offset, 2, ENC_BIG_ENDIAN);
+      offset += 2;
+      break;
+    }
+  }
+  return offset;
+}
+
+static guint
+dissect_rdm_pd_nack_reason(tvbuff_t *tvb, guint offset, proto_tree *tree, guint8 cc, guint16 param_id _U_, guint8 pdl _U_)
+{
+  if (pdl == 2) {
+    switch(cc) {
+    case RDM_CC_GET_COMMAND_RESPONSE:
+    case RDM_CC_SET_COMMAND_RESPONSE:
+      proto_tree_add_item(tree, hf_rdm_pd_nack_reason_code, tvb,
+        offset, 2, ENC_BIG_ENDIAN);
+      offset += 2;
+      break;
+    }
+  }
+
+  return offset;
+}
+
+static guint8
+is_response(guint8 command_class)
+{
+  if ((command_class & RDM_CC_COMMAND_RESPONSE_FLAG) == RDM_CC_COMMAND_RESPONSE_FLAG) {
+    return 1;
+  }
+  return 0;
+}
+
+static void
+add_pid_to_tree(guint16 param_id, proto_tree *mdb_tree, tvbuff_t *tvb, guint offset, guint16 device_manufacturer_id)
+{
+  if (param_id < 0x8000) {
+    proto_tree_add_item(mdb_tree, hf_rdm_parameter_id, tvb, offset, 2, ENC_BIG_ENDIAN);
+  } else {
+    switch(device_manufacturer_id) {
+    case RDM_MANUFACTURER_ID_ETC:
+      proto_tree_add_item(mdb_tree, hf_etc_parameter_id, tvb, offset, 2, ENC_BIG_ENDIAN);
+      break;
+    default:
+      proto_tree_add_item(mdb_tree, hf_rdm_parameter_id, tvb, offset, 2, ENC_BIG_ENDIAN);
+      break;
+    }
+  }
+}
+
+static guint
+dissect_rdm_mdb(tvbuff_t *tvb, guint offset, proto_tree *tree, guint16 device_manufacturer_id)
+{
+  guint8      cc;
+  guint8      rt;
+  guint16      param_id;
+  guint8      parameter_data_length;
+  proto_tree *hi,*si, *mdb_tree;
+
+  rt = tvb_get_guint8(tvb, offset);
+  cc = tvb_get_guint8(tvb, offset + 4);
+
+  if (is_response(cc)) {
+    proto_tree_add_item(tree, hf_rdm_response_type, tvb,
+        offset, 1, ENC_BIG_ENDIAN);
+          offset += 1;
+
+  } else {
+    proto_tree_add_item(tree, hf_rdm_port_id, tvb,
+                    offset, 1, ENC_BIG_ENDIAN);
+          offset += 1;
+  }
+
+  proto_tree_add_item(tree, hf_rdm_message_count, tvb,
+      offset, 1, ENC_BIG_ENDIAN);
+  offset += 1;
+
+  proto_tree_add_item(tree, hf_rdm_sub_device, tvb,
+      offset, 2, ENC_BIG_ENDIAN);
+  offset += 2;
+
+  hi = proto_tree_add_item(tree, hf_rdm_mdb, tvb,
+      offset, -1, ENC_NA);
+  mdb_tree = proto_item_add_subtree(hi,ett_rdm);
+
+  proto_tree_add_item(mdb_tree, hf_rdm_command_class, tvb,
+      offset, 1, ENC_BIG_ENDIAN);
+  offset += 1;
+
+  param_id = tvb_get_ntohs(tvb, offset);
+  add_pid_to_tree(param_id, mdb_tree, tvb, offset, device_manufacturer_id);
+  offset += 2;
+
+  parameter_data_length = tvb_get_guint8(tvb, offset);
+  proto_tree_add_item(mdb_tree, hf_rdm_parameter_data_length, tvb,
+      offset, 1, ENC_BIG_ENDIAN);
+  offset += 1;
+  proto_item_set_len( mdb_tree,  parameter_data_length + 4);
+
+  if (parameter_data_length > 0) {
+
+    hi = proto_tree_add_item(mdb_tree, hf_rdm_parameter_data, tvb,
+        offset, parameter_data_length, ENC_NA);
+    si = proto_item_add_subtree(hi,ett_rdm);
+
+    if (is_response(cc)) {
+
+      switch(rt) {
+      case RDM_RESPONSE_TYPE_ACK:
+        offset = dissect_rdm_mdb_param_data(tvb, offset, si, cc, param_id, parameter_data_length, device_manufacturer_id);
+        break;
+      case RDM_RESPONSE_TYPE_ACK_TIMER:
+        offset = dissect_rdm_pd_ack_timer(tvb, offset, si, cc, param_id, parameter_data_length);
+        break;
+      case RDM_RESPONSE_TYPE_NACK_REASON:
+        offset = dissect_rdm_pd_nack_reason(tvb, offset, si, cc, param_id, parameter_data_length);
+        break;
+      case RDM_RESPONSE_TYPE_ACK_OVERFLOW:
+        offset = dissect_rdm_pd_ack_overflow(tvb, offset, si, cc, param_id, parameter_data_length);
+        break;
+      }
+
+    } else {
+      offset = dissect_rdm_mdb_param_data(tvb, offset, si, cc, param_id, parameter_data_length, device_manufacturer_id);
+    }
+  }
+
+  return offset;
+}
+
+static guint16
+get_device_manufacturer_id(guint8 command_class, guint16 source_manufacturer_id, guint16 destination_manufacturer_id)
+{
+  if ((command_class == RDM_CC_GET_COMMAND) ||
+      (command_class == RDM_CC_SET_COMMAND)) {
+    return destination_manufacturer_id;
+  }
+  if ((command_class == RDM_CC_GET_COMMAND_RESPONSE) ||
+      (command_class == RDM_CC_SET_COMMAND_RESPONSE)) {
+    return source_manufacturer_id;
+  }
+  return 0;
+}
+
+static int
+dissect_rdm(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
+{
+  col_set_str(pinfo->cinfo, COL_PROTOCOL, "RDM");
+  col_clear(pinfo->cinfo, COL_INFO);
+
+  if (tree) {
+    gint      padding_size;
+    guint8    command_class;
+    guint16   destination_manufacturer_id;
+    guint16   source_manufacturer_id;
+    guint16   device_manufacturer_id;
+    guint32   destination_device_id;
+    guint32   source_device_id;
+    guint     message_length, offset = 0;
+
+    proto_tree *ti = proto_tree_add_item(tree, proto_rdm, tvb,
+        offset, -1, ENC_NA);
+    proto_tree *rdm_tree = proto_item_add_subtree(ti, ett_rdm);
+
+    proto_tree_add_item(rdm_tree, hf_rdm_sub_start_code, tvb,
+        offset, 1, ENC_BIG_ENDIAN);
+    offset += 1;
+
+    message_length = tvb_get_guint8(tvb, offset);
+    proto_tree_add_item(rdm_tree, hf_rdm_message_length, tvb,
+        offset, 1, ENC_BIG_ENDIAN);
+    offset += 1;
+
+    destination_manufacturer_id = tvb_get_ntohs(tvb, offset);
+    destination_device_id = tvb_get_ntohl(tvb, offset + 2);
+    proto_item_append_text(ti, ", Dst UID: %04x:%08x",
+        destination_manufacturer_id, destination_device_id);
+    proto_tree_add_item(rdm_tree, hf_rdm_dest_uid, tvb,
+        offset, 6, ENC_NA);
+    offset += 6;
+
+    source_manufacturer_id = tvb_get_ntohs(tvb, offset);
+    source_device_id = tvb_get_ntohl(tvb, offset + 2);
+    proto_item_append_text(ti, ", Src UID: %04x:%08x",
+        source_manufacturer_id, source_device_id);
+    proto_tree_add_item(rdm_tree, hf_rdm_src_uid, tvb,
+        offset, 6, ENC_NA);
+    offset += 6;
+
+    proto_tree_add_item(rdm_tree, hf_rdm_transaction_number, tvb,
+        offset, 1, ENC_BIG_ENDIAN);
+    offset += 1;
+
+    command_class = tvb_get_guint8(tvb, offset + 4);
+    device_manufacturer_id = get_device_manufacturer_id(command_class, source_manufacturer_id, destination_manufacturer_id);
+    offset = dissect_rdm_mdb(tvb, offset, rdm_tree, device_manufacturer_id);
+
+    padding_size = offset - (message_length - 1);
+    if (padding_size > 0) {
+      proto_tree_add_item(rdm_tree, hf_rdm_intron, tvb,
+          offset, padding_size, ENC_NA);
+      offset += padding_size;
+    }
+
+    proto_tree_add_checksum(rdm_tree, tvb, offset, hf_rdm_checksum, hf_rdm_checksum_status, &ei_rdm_checksum, pinfo, rdm_checksum(tvb, offset),
+              ENC_BIG_ENDIAN, PROTO_CHECKSUM_VERIFY);
+    offset += 2;
+
+    if (offset < tvb_reported_length(tvb)) {
+      proto_tree_add_item(rdm_tree, hf_rdm_trailer, tvb,
+          offset, -1, ENC_NA);
+    }
+  }
+  return tvb_captured_length(tvb);
 }
 
 void
 proto_register_rdm(void)
 {
-	static hf_register_info hf[] = {
-		{ &hf_rdm_sub_start_code,
-			{ "Sub-start code", "rdm.ssc",
-				FT_UINT8, BASE_HEX, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_message_length,
-			{ "Message length", "rdm.len",
-				FT_UINT8, BASE_DEC, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_dest_uid,
-			{ "Destination UID", "rdm.dst",
-				FT_BYTES, BASE_NONE, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_src_uid,
-			{ "Source UID", "rdm.src",
-				FT_BYTES, BASE_NONE, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_transaction_number,
-			{ "Transaction number", "rdm.tn",
-				FT_UINT8, BASE_DEC, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_port_id,
-			{ "Port ID", "rdm.port_id",
-				FT_UINT8, BASE_DEC, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_response_type,
-			{ "Response type", "rdm.rt",
-				FT_UINT8, BASE_HEX, VALS(rdm_rt_vals), 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_message_count,
-			{ "Message count", "rdm.mc",
-				FT_UINT8, BASE_DEC, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_sub_device,
-			{ "Sub-device", "rdm.sd",
-				FT_UINT16, BASE_DEC, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_mdb,
-			{ "Message Data Block", "rdm.mdb",
-				FT_NONE, BASE_NONE, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_command_class,
-			{ "Command class", "rdm.cc",
-				FT_UINT8, BASE_HEX, VALS(rdm_cc_vals), 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_parameter_id,
-			{ "Parameter ID", "rdm.pid",
-				FT_UINT16, BASE_HEX | BASE_EXT_STRING, &rdm_param_id_vals_ext, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_parameter_data_length,
-			{ "Parameter data length", "rdm.pdl",
-				FT_UINT8, BASE_DEC, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_parameter_data,
-			{ "Parameter data", "rdm.pd",
-				FT_NONE, BASE_NONE, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_parameter_data_raw,
-			{ "Raw Data", "rdm.pd.raw",
-				FT_BYTES, BASE_NONE, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_intron,
-			{ "Intron", "rdm.intron",
-				FT_BYTES, BASE_NONE, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_checksum,
-			{ "Checksum", "rdm.checksum",
-				FT_UINT16, BASE_HEX, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_checksum_status,
-			{ "Checksum Status", "rdm.checksum.status",
-				FT_UINT8, BASE_NONE, VALS(proto_checksum_vals), 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_trailer,
-			{ "Trailer", "rdm.trailer",
-				FT_BYTES, BASE_NONE, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_ack_overflow_raw_data,
-			{ "Raw Data", "rdm.pd.ack_overflow.raw_data",
-				FT_BYTES, BASE_NONE, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_ack_timer_estimated_response_time,
-			{ "Estimated Response Time", "rdm.pd.ack_timer.estimated_response_time",
-				FT_INT16, BASE_DEC, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_nack_reason_code,
-			{ "NACK Reason Code", "rdm.pd.nack_reason.code",
-				FT_UINT16, BASE_HEX, VALS(rdm_nr_vals), 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_queued_message_status,
-			{ "Status", "rdm.pd.queued_message.status",
-				FT_UINT8, BASE_HEX, VALS(rdm_status_vals), 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_sensor_nr,
-			{ "Sensor Nr.", "rdm.pd.sensor.nr",
-				FT_UINT8, BASE_DEC, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_sensor_value_pres,
-			{ "Sensor Present Value", "rdm.pd.sensor.value.present",
-				FT_INT16, BASE_DEC, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_sensor_value_low,
-			{ "Sensor Lowest Value", "rdm.pd.sensor.value.lowest",
-				FT_INT16, BASE_DEC, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_sensor_value_high,
-			{ "Sensor Highest Value", "rdm.pd.sensor.value.highest",
-				FT_INT16, BASE_DEC, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_sensor_value_rec,
-			{ "Sensor Recorded Value", "rdm.pd.sensor.value.recorded",
-				FT_INT16, BASE_DEC, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_sensor_range_min_value,
-			{ "Sensor Range Min. Value", "rdm.pd.sensor.range.min_value",
-				FT_INT16, BASE_DEC, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_sensor_range_max_value,
-			{ "Sensor Range Max. Value", "rdm.pd.sensor.range.max_value",
-				FT_INT16, BASE_DEC, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_sensor_normal_min_value,
-			{ "Sensor Normal Min. Value", "rdm.pd.sensor.normal.min_value",
-				FT_INT16, BASE_DEC, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_sensor_normal_max_value,
-			{ "Sensor Normal Max. Value", "rdm.pd.sensor.normal.max_value",
-				FT_INT16, BASE_DEC, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_sensor_recorded_value_support,
-			{ "Sensor Recorded Value Support", "rdm.pd.sensor.recorded_value_support",
-				FT_UINT8, BASE_HEX, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_sensor_type,
-			{ "Sensor Type", "rdm.pd.sensor_type",
-				FT_UINT8, BASE_HEX | BASE_EXT_STRING, &rdm_sensor_type_vals_ext, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_sensor_unit,
-			{ "Sensor Unit", "rdm.pd.sensor_unit",
-				FT_UINT8, BASE_HEX | BASE_EXT_STRING, &rdm_unit_vals_ext, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_sensor_prefix,
-			{ "Sensor Prefix", "rdm.pd.sensor_prefix",
-				FT_UINT8, BASE_HEX | BASE_EXT_STRING, &rdm_prefix_vals_ext, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_sensor_description,
-			{ "Sensor Description", "rdm.pd.sensor.description",
-				FT_STRING, BASE_NONE, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_manu_label,
-			{ "Manufacturer Label", "rdm.pd.manu_label",
-				FT_STRING, BASE_NONE, NULL, 0x0,
-				NULL, HFILL }},
-
-
-		{ &hf_rdm_pd_device_label,
-			{ "Device Label", "rdm.pd.device_label",
-				FT_STRING, BASE_NONE, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_dmx_start_address,
-			{ "DMX Start Address", "rdm.pd.dmx_start_address",
-				FT_UINT16, BASE_DEC, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_device_hours,
-			{ "Device Hours", "rdm.pd.device_hours",
-				FT_UINT32, BASE_DEC, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_lamp_hours,
-			{ "Lamp Hours", "rdm.pd.lamp_hours",
-				FT_UINT32, BASE_DEC, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_lamp_strikes,
-			{ "Lamp Strikes", "rdm.pd.lamp_strikes",
-				FT_UINT32, BASE_DEC, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_proto_vers,
-			{ "RDM Protocol Version", "rdm.pd.proto_vers",
-				FT_UINT16, BASE_HEX, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_device_model_id,
-			{ "Device Model ID", "rdm.pd.device_model_id",
-				FT_UINT16, BASE_HEX, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_product_cat,
-			{ "Product Category", "rdm.pd.product_cat",
-				FT_UINT16, BASE_HEX | BASE_EXT_STRING, &rdm_product_cat_vals_ext, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_software_vers_id,
-			{ "Software Version ID", "rdm.pd.software_version_id",
-				FT_UINT32, BASE_HEX, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_dmx_footprint,
-			{ "DMX Footprint", "rdm.pd.dmx_footprint",
-				FT_UINT16, BASE_DEC, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_dmx_pers_current,
-			{ "Current DMX Personality", "rdm.pd.dmx_pers_current",
-				FT_UINT8, BASE_DEC, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_dmx_pers_total,
-			{ "Total nr. DMX Personalities", "rdm.pd.dmx_pers_total",
-				FT_UINT8, BASE_DEC, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_sub_device_count,
-			{ "Sub-Device Count", "rdm.pd.sub_device_count",
-				FT_UINT16, BASE_DEC, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_sensor_count,
-			{ "Sensor Count", "rdm.pd.sensor_count",
-				FT_UINT8, BASE_DEC, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_device_model_description,
-			{ "Device Model Description", "rdm.pd.device_model_description",
-				FT_STRING, BASE_NONE, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_disc_unique_branch_lb_uid,
-			{ "Lower Bound UID", "rdm.pd.disc_unique_branch.lb_uid",
-				FT_BYTES, BASE_NONE, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_disc_unique_branch_ub_uid,
-			{ "Upper Bound UID", "rdm.pd.disc_unique_branch.ub_uid",
-				FT_BYTES, BASE_NONE, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_disc_mute_control_field,
-			{ "Control Field", "rdm.pd.disc_mute.control_field",
-				FT_UINT8, BASE_HEX, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_disc_mute_binding_uid,
-			{ "Binding UID", "rdm.pd.disc_mute.binding_uid",
-				FT_BYTES, BASE_NONE, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_disc_unmute_control_field,
-			{ "Control Field", "rdm.pd.disc_unmute.control_field",
-				FT_UINT8, BASE_HEX, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_disc_unmute_binding_uid,
-			{ "Binding UID", "rdm.pd.disc_unmute.binding_uid",
-				FT_BYTES, BASE_NONE, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_proxied_devices_uid,
-			{ "UID", "rdm.pd.proxied_devices.uid",
-				FT_BYTES, BASE_NONE, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_proxied_device_count,
-			{ "Device Count", "rdm.pd.device_count",
-				FT_UINT16, BASE_DEC, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_proxied_device_list_change,
-			{ "List Change", "rdm.pd.list_change",
-				FT_UINT8, BASE_DEC, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_real_time_clock_year,
-			{ "Year", "rdm.pd.real_time_clock.year",
-				FT_UINT16, BASE_DEC, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_real_time_clock_month,
-			{ "Month", "rdm.pd.real_time_clock.month",
-				FT_UINT8, BASE_DEC, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_real_time_clock_day,
-			{ "Day", "rdm.pd.real_time_clock.day",
-				FT_UINT8, BASE_DEC, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_real_time_clock_hour,
-			{ "Hour", "rdm.pd.real_time_clock.hour",
-				FT_UINT8, BASE_DEC, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_real_time_clock_minute,
-			{ "Minute", "rdm.pd.real_time_clock.minute",
-				FT_UINT8, BASE_DEC, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_real_time_clock_second,
-			{ "Second", "rdm.pd.real_time_clock.second",
-				FT_UINT8, BASE_DEC, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_lamp_state,
-			{ "Lamp State", "rdm.pd.lamp_state",
-				FT_UINT8, BASE_HEX, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_lamp_on_mode,
-			{ "Lamp On Mode", "rdm.pd.lamp_on_mode",
-				FT_UINT8, BASE_HEX, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_device_power_cycles,
-			{ "Device Power Cycles", "rdm.pd.device_power_cycles",
-				FT_UINT32, BASE_DEC, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_display_invert,
-			{ "Display Invert", "rdm.pd.display_invert",
-				FT_UINT8, BASE_HEX, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_display_level,
-			{ "Display Level", "rdm.pd.display_level",
-				FT_UINT8, BASE_DEC, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_pan_invert,
-			{ "Pan Invert", "rdm.pd.pan_invert",
-				FT_UINT8, BASE_HEX, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_tilt_invert,
-			{ "Tilt Invert", "rdm.pd.tilt_invert",
-				FT_UINT8, BASE_HEX, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_tilt_swap,
-			{ "Tilt Swap", "rdm.pd.tilt_swap",
-				FT_UINT8, BASE_HEX, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_selftest_nr,
-			{ "Selftest Nr.", "rdm.pd.selftest.nr",
-				FT_UINT8, BASE_DEC, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_selftest_state,
-			{ "Selftest State", "rdm.pd.selftest.state",
-				FT_UINT8, BASE_HEX, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_selftest_description,
-			{ "Selftest Description", "rdm.pd.selftest.description",
-				FT_STRING, BASE_NONE, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_language_code,
-			{ "Language Code", "rdm.pd.language_code",
-				FT_STRING, BASE_NONE, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_identify_device,
-			{ "Identify Device", "rdm.pd.identify_device",
-				FT_UINT8, BASE_HEX, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_identify_device_state,
-			{ "Identify Device State", "rdm.pd.identify_device.state",
-				FT_UINT8, BASE_HEX, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_reset_device,
-			{ "Reset Device", "rdm.pd.reset_device",
-				FT_UINT8, BASE_HEX, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_power_state,
-			{ "Power State", "rdm.pd.power_state",
-				FT_UINT8, BASE_HEX, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_capture_preset_scene_nr,
-			{ "Scene Nr.", "rdm.pd.capture_preset.scene_nr",
-				FT_UINT16, BASE_DEC, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_capture_preset_up_fade_time,
-			{ "Up Fade Time", "rdm.pd.capture_preset.up_fade_time",
-				FT_UINT16, BASE_DEC, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_capture_preset_down_fade_time,
-			{ "Down Fade Time", "rdm.pd.capture_preset.down_fade_time",
-				FT_UINT16, BASE_DEC, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_capture_preset_wait_time,
-			{ "Wait Time", "rdm.pd.capture_preset.wait_time",
-				FT_UINT16, BASE_DEC, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_preset_playback_mode,
-			{ "Mode", "rdm.pd.preset_playback.mode",
-				FT_UINT16, BASE_DEC, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_preset_playback_level,
-			{ "Level", "rdm.pd.preset_playback.level",
-				FT_UINT8, BASE_DEC, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_parameter_id,
-			{ "ID", "rdm.pd.parameter.id",
-				FT_UINT16, BASE_HEX, VALS(rdm_param_id_vals), 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_parameter_pdl_size,
-			{ "PDL Size", "rdm.pd.parameter.pdl_size",
-				FT_UINT8, BASE_DEC, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_parameter_data_type,
-			{ "Data Type", "rdm.pd.parameter.data_type",
-				FT_UINT8, BASE_DEC, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_parameter_cmd_class,
-			{ "Command Class", "rdm.pd.parameter.cmd_class",
-				FT_UINT8, BASE_DEC, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_parameter_type,
-			{ "Type", "rdm.pd.parameter.type",
-				FT_UINT8, BASE_DEC, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_parameter_unit,
-			{ "Unit", "rdm.pd.parameter.unit",
-				FT_UINT8, BASE_DEC, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_parameter_prefix,
-			{ "Prefix", "rdm.pd.parameter.prefix",
-				FT_UINT8, BASE_DEC, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_parameter_min_value,
-			{ "Min. Value", "rdm.pd.parameter.min_value",
-				FT_UINT32, BASE_DEC, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_parameter_max_value,
-			{ "Max. Value", "rdm.pd.parameter.max_value",
-				FT_UINT32, BASE_DEC, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_parameter_default_value,
-			{ "Default Value", "rdm.pd.parameter.default_value",
-				FT_UINT32, BASE_DEC, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_parameter_description,
-			{ "Description", "rdm.pd.parameter.description",
-				FT_STRING, BASE_NONE, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_software_version_label,
-			{ "Version Label", "rdm.pd.software_version.label",
-				FT_STRING, BASE_NONE, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_boot_software_version_id,
-			{ "Version ID", "rdm.pd.boot_software_version.id",
-				FT_UINT32, BASE_HEX, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_boot_software_version_label,
-			{ "Version Label", "rdm.pd.boot_software_version.label",
-				FT_STRING, BASE_NONE, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_comms_status_short_msg,
-			{ "Short Msg", "rdm.pd.comms_status.short_msg",
-				FT_UINT16, BASE_DEC, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_comms_status_len_mismatch,
-			{ "Len Mismatch", "rdm.pd.comms_status.len_mismatch",
-				FT_UINT16, BASE_DEC, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_comms_status_csum_fail,
-			{ "Checksum Fail", "rdm.pd.comms_status.csum_fail",
-				FT_UINT16, BASE_DEC, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_status_messages_type,
-			{ "Type", "rdm.pd.status_messages.type",
-				FT_UINT8, BASE_HEX, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_status_messages_sub_device_id,
-			{ "Sub. Device ID", "rdm.pd.status_messages.sub_devices_id",
-				FT_UINT16, BASE_HEX, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_status_messages_id,
-			{ "ID", "rdm.pd.status_messages.id",
-				FT_UINT16, BASE_HEX, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_status_messages_data_value_1,
-			{ "Data Value 1", "rdm.pd.status_messages.data_value_1",
-				FT_UINT16, BASE_HEX, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_status_messages_data_value_2,
-			{ "Data Value 2", "rdm.pd.status_messages.data_value_2",
-				FT_UINT16, BASE_HEX, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_status_id,
-			{ "ID", "rdm.pd.status_id",
-				FT_UINT16, BASE_DEC, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_status_id_description,
-			{ "Description", "rdm.pd.status_id.description",
-				FT_STRING, BASE_NONE, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_sub_device_status_report_threshold_status_type,
-			{ "Status Type", "rdm.pd.sub_device_status_report_threshold.status_type",
-				FT_UINT8, BASE_HEX, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_product_detail_id_list,
-			{ "Sensor Count", "rdm.pd.product_detail_id_list",
-				FT_UINT16, BASE_HEX, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_factory_defaults,
-			{ "Factory Defaults", "rdm.pd.factory_defaults",
-				FT_UINT8, BASE_DEC, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_dmx_pers_nr,
-			{ "DMX Pers. Nr.", "rdm.pd.dmx_pers.nr",
-				FT_UINT8, BASE_DEC, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_dmx_pers_count,
-			{ "DMX Pers. Count", "rdm.pd.dmx_pers.count",
-				FT_UINT8, BASE_DEC, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_dmx_pers_requested,
-			{ "DMX Pers. Requested", "rdm.pd.dmx_pers.requested",
-				FT_UINT8, BASE_DEC, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_dmx_pers_slots,
-			{ "DMX Pers. Slots", "rdm.pd.dmx_pers.slots",
-				FT_UINT16, BASE_DEC, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_dmx_pers_text,
-			{ "DMX Pers. Text", "rdm.pd.dmx_pers.text",
-				FT_STRING, BASE_NONE, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_slot_offset,
-			{ "Slot Offset", "rdm.pd.slot_offset",
-				FT_UINT16, BASE_DEC, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_slot_type,
-			{ "Slot Type", "rdm.pd.slot_type",
-				FT_UINT8, BASE_DEC, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_slot_label_id,
-			{ "Slot Label ID", "rdm.pd.slot_label_id",
-				FT_UINT16, BASE_HEX, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_slot_nr,
-			{ "Slot Nr.", "rdm.pd.slot_nr",
-				FT_UINT16, BASE_DEC, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_slot_description,
-			{ "Slot Description", "rdm.pd.slot_description",
-				FT_STRING, BASE_NONE, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_slot_value,
-			{ "Slot Value", "rdm.pd.slot_value",
-				FT_UINT8, BASE_DEC, NULL, 0x0,
-				NULL, HFILL }},
-
-		{ &hf_rdm_pd_rec_value_support,
-			{ "Rec. Value Support", "rdm.pd.rec_value_support",
-				FT_UINT8, BASE_HEX, NULL, 0x0,
-				NULL, HFILL }}
-	};
-
-	static gint *ett[] = {
-		&ett_rdm
-	};
-
-	static ei_register_info ei[] = {
-		{ &ei_rdm_checksum, { "rdm.bad_checksum", PI_CHECKSUM, PI_ERROR, "Bad checksum", EXPFILL }},
-	};
-
-	expert_module_t* expert_rdm;
-
-	proto_rdm = proto_register_protocol("Remote Device Management", "RDM", "rdm");
-	proto_register_field_array(proto_rdm, hf, array_length(hf));
-	proto_register_subtree_array(ett, array_length(ett));
-	register_dissector("rdm", dissect_rdm, proto_rdm);
-	expert_rdm = expert_register_protocol(proto_rdm);
-	expert_register_field_array(expert_rdm, ei, array_length(ei));
+  static hf_register_info hf[] = {
+    { &hf_rdm_sub_start_code,
+      { "Sub-start code", "rdm.ssc",
+        FT_UINT8, BASE_HEX, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_message_length,
+      { "Message length", "rdm.len",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_dest_uid,
+      { "Destination UID", "rdm.dst",
+        FT_BYTES, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_src_uid,
+      { "Source UID", "rdm.src",
+        FT_BYTES, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_transaction_number,
+      { "Transaction number", "rdm.tn",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_port_id,
+      { "Port ID", "rdm.port_id",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_response_type,
+      { "Response type", "rdm.rt",
+        FT_UINT8, BASE_HEX, VALS(rdm_rt_vals), 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_message_count,
+      { "Message count", "rdm.mc",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_sub_device,
+      { "Sub-device", "rdm.sd",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_mdb,
+      { "Message Data Block", "rdm.mdb",
+        FT_NONE, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_command_class,
+      { "Command class", "rdm.cc",
+        FT_UINT8, BASE_HEX, VALS(rdm_cc_vals), 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_parameter_id,
+      { "Parameter ID", "rdm.pid",
+        FT_UINT16, BASE_HEX | BASE_EXT_STRING, &rdm_param_id_vals_ext, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_parameter_data_length,
+      { "Parameter data length", "rdm.pdl",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_parameter_data,
+      { "Parameter data", "rdm.pd",
+        FT_NONE, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_parameter_data_raw,
+      { "Raw Data", "rdm.pd.raw",
+        FT_BYTES, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_intron,
+      { "Intron", "rdm.intron",
+        FT_BYTES, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_checksum,
+      { "Checksum", "rdm.checksum",
+        FT_UINT16, BASE_HEX, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_checksum_status,
+      { "Checksum Status", "rdm.checksum.status",
+        FT_UINT8, BASE_NONE, VALS(proto_checksum_vals), 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_trailer,
+      { "Trailer", "rdm.trailer",
+        FT_BYTES, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_ack_overflow_raw_data,
+      { "Raw Data", "rdm.pd.ack_overflow.raw_data",
+        FT_BYTES, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_ack_timer_estimated_response_time,
+      { "Estimated Response Time", "rdm.pd.ack_timer.estimated_response_time",
+        FT_INT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_nack_reason_code,
+      { "NACK Reason Code", "rdm.pd.nack_reason.code",
+        FT_UINT16, BASE_HEX, VALS(rdm_nr_vals), 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_queued_message_status,
+      { "Status", "rdm.pd.queued_message.status",
+        FT_UINT8, BASE_HEX, VALS(rdm_status_vals), 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_sensor_nr,
+      { "Sensor Nr.", "rdm.pd.sensor.nr",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_sensor_value_pres,
+      { "Sensor Present Value", "rdm.pd.sensor.value.present",
+        FT_INT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_sensor_value_low,
+      { "Sensor Lowest Value", "rdm.pd.sensor.value.lowest",
+        FT_INT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_sensor_value_high,
+      { "Sensor Highest Value", "rdm.pd.sensor.value.highest",
+        FT_INT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_sensor_value_rec,
+      { "Sensor Recorded Value", "rdm.pd.sensor.value.recorded",
+        FT_INT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_sensor_range_min_value,
+      { "Sensor Range Min. Value", "rdm.pd.sensor.range.min_value",
+        FT_INT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_sensor_range_max_value,
+      { "Sensor Range Max. Value", "rdm.pd.sensor.range.max_value",
+        FT_INT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_sensor_normal_min_value,
+      { "Sensor Normal Min. Value", "rdm.pd.sensor.normal.min_value",
+        FT_INT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_sensor_normal_max_value,
+      { "Sensor Normal Max. Value", "rdm.pd.sensor.normal.max_value",
+        FT_INT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_sensor_recorded_value_support,
+      { "Sensor Recorded Value Support", "rdm.pd.sensor.recorded_value_support",
+        FT_UINT8, BASE_HEX, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_sensor_type,
+      { "Sensor Type", "rdm.pd.sensor_type",
+        FT_UINT8, BASE_HEX | BASE_EXT_STRING, &rdm_sensor_type_vals_ext, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_sensor_unit,
+      { "Sensor Unit", "rdm.pd.sensor_unit",
+        FT_UINT8, BASE_HEX | BASE_EXT_STRING, &rdm_unit_vals_ext, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_sensor_prefix,
+      { "Sensor Prefix", "rdm.pd.sensor_prefix",
+        FT_UINT8, BASE_HEX | BASE_EXT_STRING, &rdm_prefix_vals_ext, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_sensor_description,
+      { "Sensor Description", "rdm.pd.sensor.description",
+        FT_STRING, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_manu_label,
+      { "Manufacturer Label", "rdm.pd.manu_label",
+        FT_STRING, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }},
+
+
+    { &hf_rdm_pd_device_label,
+      { "Device Label", "rdm.pd.device_label",
+        FT_STRING, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_dmx_start_address,
+      { "DMX Start Address", "rdm.pd.dmx_start_address",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_device_hours,
+      { "Device Hours", "rdm.pd.device_hours",
+        FT_UINT32, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_lamp_hours,
+      { "Lamp Hours", "rdm.pd.lamp_hours",
+        FT_UINT32, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_lamp_strikes,
+      { "Lamp Strikes", "rdm.pd.lamp_strikes",
+        FT_UINT32, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_proto_vers,
+      { "RDM Protocol Version", "rdm.pd.proto_vers",
+        FT_UINT16, BASE_HEX, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_device_model_id,
+      { "Device Model ID", "rdm.pd.device_model_id",
+        FT_UINT16, BASE_HEX, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_product_cat,
+      { "Product Category", "rdm.pd.product_cat",
+        FT_UINT16, BASE_HEX | BASE_EXT_STRING, &rdm_product_cat_vals_ext, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_software_vers_id,
+      { "Software Version ID", "rdm.pd.software_version_id",
+        FT_UINT32, BASE_HEX, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_dmx_footprint,
+      { "DMX Footprint", "rdm.pd.dmx_footprint",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_dmx_pers_current,
+      { "Current DMX Personality", "rdm.pd.dmx_pers_current",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_dmx_pers_total,
+      { "Total nr. DMX Personalities", "rdm.pd.dmx_pers_total",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_sub_device_count,
+      { "Sub-Device Count", "rdm.pd.sub_device_count",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_sensor_count,
+      { "Sensor Count", "rdm.pd.sensor_count",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_device_model_description,
+      { "Device Model Description", "rdm.pd.device_model_description",
+        FT_STRING, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_disc_unique_branch_lb_uid,
+      { "Lower Bound UID", "rdm.pd.disc_unique_branch.lb_uid",
+        FT_BYTES, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_disc_unique_branch_ub_uid,
+      { "Upper Bound UID", "rdm.pd.disc_unique_branch.ub_uid",
+        FT_BYTES, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_disc_mute_control_field,
+      { "Control Field", "rdm.pd.disc_mute.control_field",
+        FT_UINT8, BASE_HEX, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_disc_mute_binding_uid,
+      { "Binding UID", "rdm.pd.disc_mute.binding_uid",
+        FT_BYTES, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_disc_unmute_control_field,
+      { "Control Field", "rdm.pd.disc_unmute.control_field",
+        FT_UINT8, BASE_HEX, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_disc_unmute_binding_uid,
+      { "Binding UID", "rdm.pd.disc_unmute.binding_uid",
+        FT_BYTES, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_proxied_devices_uid,
+      { "UID", "rdm.pd.proxied_devices.uid",
+        FT_BYTES, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_proxied_device_count,
+      { "Device Count", "rdm.pd.device_count",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_proxied_device_list_change,
+      { "List Change", "rdm.pd.list_change",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_real_time_clock_year,
+      { "Year", "rdm.pd.real_time_clock.year",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_real_time_clock_month,
+      { "Month", "rdm.pd.real_time_clock.month",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_real_time_clock_day,
+      { "Day", "rdm.pd.real_time_clock.day",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_real_time_clock_hour,
+      { "Hour", "rdm.pd.real_time_clock.hour",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_real_time_clock_minute,
+      { "Minute", "rdm.pd.real_time_clock.minute",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_real_time_clock_second,
+      { "Second", "rdm.pd.real_time_clock.second",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_lamp_state,
+      { "Lamp State", "rdm.pd.lamp_state",
+        FT_UINT8, BASE_HEX, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_lamp_on_mode,
+      { "Lamp On Mode", "rdm.pd.lamp_on_mode",
+        FT_UINT8, BASE_HEX, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_device_power_cycles,
+      { "Device Power Cycles", "rdm.pd.device_power_cycles",
+        FT_UINT32, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_display_invert,
+      { "Display Invert", "rdm.pd.display_invert",
+        FT_UINT8, BASE_HEX, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_display_level,
+      { "Display Level", "rdm.pd.display_level",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_pan_invert,
+      { "Pan Invert", "rdm.pd.pan_invert",
+        FT_UINT8, BASE_HEX, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_tilt_invert,
+      { "Tilt Invert", "rdm.pd.tilt_invert",
+        FT_UINT8, BASE_HEX, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_tilt_swap,
+      { "Tilt Swap", "rdm.pd.tilt_swap",
+        FT_UINT8, BASE_HEX, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_selftest_nr,
+      { "Selftest Nr.", "rdm.pd.selftest.nr",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_selftest_state,
+      { "Selftest State", "rdm.pd.selftest.state",
+        FT_UINT8, BASE_HEX, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_selftest_description,
+      { "Selftest Description", "rdm.pd.selftest.description",
+        FT_STRING, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_language_code,
+      { "Language Code", "rdm.pd.language_code",
+        FT_STRING, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_identify_device,
+      { "Identify Device", "rdm.pd.identify_device",
+        FT_UINT8, BASE_HEX, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_identify_device_state,
+      { "Identify Device State", "rdm.pd.identify_device.state",
+        FT_UINT8, BASE_HEX, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_reset_device,
+      { "Reset Device", "rdm.pd.reset_device",
+        FT_UINT8, BASE_HEX, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_power_state,
+      { "Power State", "rdm.pd.power_state",
+        FT_UINT8, BASE_HEX, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_capture_preset_scene_nr,
+      { "Scene Nr.", "rdm.pd.capture_preset.scene_nr",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_capture_preset_up_fade_time,
+      { "Up Fade Time", "rdm.pd.capture_preset.up_fade_time",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_capture_preset_down_fade_time,
+      { "Down Fade Time", "rdm.pd.capture_preset.down_fade_time",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_capture_preset_wait_time,
+      { "Wait Time", "rdm.pd.capture_preset.wait_time",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_preset_playback_mode,
+      { "Mode", "rdm.pd.preset_playback.mode",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_preset_playback_level,
+      { "Level", "rdm.pd.preset_playback.level",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_parameter_id,
+      { "ID", "rdm.pd.parameter.id",
+        FT_UINT16, BASE_HEX, VALS(rdm_param_id_vals), 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_parameter_pdl_size,
+      { "PDL Size", "rdm.pd.parameter.pdl_size",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_parameter_data_type,
+      { "Data Type", "rdm.pd.parameter.data_type",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_parameter_cmd_class,
+      { "Command Class", "rdm.pd.parameter.cmd_class",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_parameter_type,
+      { "Type", "rdm.pd.parameter.type",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_parameter_unit,
+      { "Unit", "rdm.pd.parameter.unit",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_parameter_prefix,
+      { "Prefix", "rdm.pd.parameter.prefix",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_parameter_min_value,
+      { "Min. Value", "rdm.pd.parameter.min_value",
+        FT_UINT32, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_parameter_max_value,
+      { "Max. Value", "rdm.pd.parameter.max_value",
+        FT_UINT32, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_parameter_default_value,
+      { "Default Value", "rdm.pd.parameter.default_value",
+        FT_UINT32, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_parameter_description,
+      { "Description", "rdm.pd.parameter.description",
+        FT_STRING, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_software_version_label,
+      { "Version Label", "rdm.pd.software_version.label",
+        FT_STRING, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_boot_software_version_id,
+      { "Version ID", "rdm.pd.boot_software_version.id",
+        FT_UINT32, BASE_HEX, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_boot_software_version_label,
+      { "Version Label", "rdm.pd.boot_software_version.label",
+        FT_STRING, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_comms_status_short_msg,
+      { "Short Msg", "rdm.pd.comms_status.short_msg",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_comms_status_len_mismatch,
+      { "Len Mismatch", "rdm.pd.comms_status.len_mismatch",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_comms_status_csum_fail,
+      { "Checksum Fail", "rdm.pd.comms_status.csum_fail",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_status_messages_type,
+      { "Type", "rdm.pd.status_messages.type",
+        FT_UINT8, BASE_HEX, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_status_messages_sub_device_id,
+      { "Sub. Device ID", "rdm.pd.status_messages.sub_devices_id",
+        FT_UINT16, BASE_HEX, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_status_messages_id,
+      { "ID", "rdm.pd.status_messages.id",
+        FT_UINT16, BASE_HEX, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_status_messages_data_value_1,
+      { "Data Value 1", "rdm.pd.status_messages.data_value_1",
+        FT_UINT16, BASE_HEX, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_status_messages_data_value_2,
+      { "Data Value 2", "rdm.pd.status_messages.data_value_2",
+        FT_UINT16, BASE_HEX, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_status_id,
+      { "ID", "rdm.pd.status_id",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_status_id_description,
+      { "Description", "rdm.pd.status_id.description",
+        FT_STRING, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_sub_device_status_report_threshold_status_type,
+      { "Status Type", "rdm.pd.sub_device_status_report_threshold.status_type",
+        FT_UINT8, BASE_HEX, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_product_detail_id_list,
+      { "Sensor Count", "rdm.pd.product_detail_id_list",
+        FT_UINT16, BASE_HEX, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_factory_defaults,
+      { "Factory Defaults", "rdm.pd.factory_defaults",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_background_discovery_endpoint_id,
+      { "Endpoint ID", "rdm.pd.background_discovery.endpoint_id",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_background_discovery_enabled,
+      { "Enabled", "rdm.pd.background_discovery.enabled",
+        FT_UINT8, BASE_DEC, VALS(enabled_disabled_vals), 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_background_queued_status_policy_current_policy,
+      { "Current Policy", "rdm.pd.background_queued_status_policy.current_policy",
+        FT_UINT8, BASE_DEC, VALS(rdm_status_vals), 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_background_queued_status_policy_number_of_policies,
+      { "Number Of Policies", "rdm.pd.background_queued_status_policy.number_of_policies",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_background_queued_status_policy_description_policy,
+      { "Policy", "rdm.pd.background_queued_status_policy_description.policy",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_background_queued_status_policy_description_description,
+      { "Description", "rdm.pd.background_queued_status_policy_description.description",
+        FT_STRING, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_search_domain_dns_domain_name,
+      { "DNS Domain Name", "rdm.pd.search_domain.dns_domain_name",
+        FT_STRING, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_binding_control_fields_endpoint_id,
+      { "Endpoint ID", "rdm.pd.binding_control_fields.endpoint_id",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_binding_control_fields_uid,
+      { "UID", "rdm.pd.binding_control_fields.uid",
+        FT_BYTES, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_binding_control_fields_control_field,
+      { "Control Field", "rdm.pd.binding_control_fields.control_field",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_binding_control_fields_binding_uid,
+      { "Binding UID", "rdm.pd.binding_control_fields.binding_uid",
+        FT_BYTES, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rem_pd_broker_status_set_allowed,
+      { "Set Allowed", "rdm.pd.broker_status.set_allowed",
+        FT_UINT8, BASE_DEC, VALS(true_false_vals), 0x0,
+        NULL, HFILL }},
+
+    { &hf_rem_pd_broker_status_state,
+      { "State", "rdm.pd.broker_status.state",
+        FT_UINT8, BASE_DEC, VALS(rdmnet_broker_status_states_vals), 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_burn_in,
+      { "Burn In", "rdm.pd.burn_in",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_component_scope_scope_slot,
+      { "Scope Slot", "rdm.pd.component_scope.scope_slot",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_component_scope_scope_string,
+      { "Scope String", "rdm.pd.component_scope.scope_string",
+        FT_STRING, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_component_scope_scope_static_config_type,
+      { "Static Config. Type", "rdm.pd.component_scope.static_config_type",
+        FT_UINT8, BASE_DEC, VALS(rdmnet_component_scope_static_config_type_vals), 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_component_scope_scope_static_ipv4_address,
+      { "Static IPv4 Address", "rdm.pd.component_scope.static_ipv4_address",
+        FT_IPv4, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_component_scope_scope_static_ipv6_address,
+      { "Static IPv6 Address", "rdm.pd.component_scope.static_ipv6_address",
+        FT_IPv6, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_component_scope_scope_static_port,
+      { "Static Port", "rdm.pd.component_scope.static_port",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_current_address_interface_identifier,
+      { "Interface Identifier", "rdm.pd.current_address.interface_identifier",
+        FT_UINT32, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_current_address_ipv4_address,
+      { "IPv4 Address", "rdm.pd.current_address.ipv4_address",
+        FT_IPv4, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_current_address_netmask,
+      { "Netmask", "rdm.pd.current_address.netmask",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_current_address_dhcp_status,
+      { "DHCP Status", "rdm.pd.current_address.dhcp_status",
+        FT_UINT8, BASE_DEC, VALS(rdm_dhcp_status_vals), 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_curve_curve,
+      { "Curve", "rdm.pd.curve.curve",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_curve_number_of_curves,
+      { "Number Of Curves", "rdm.pd.curve.number_of_curves",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_curve_description_curve,
+      { "Curve", "rdm.pd.curve_description.curve",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_curve_description_text,
+      { "Description", "rdm.pd.curve_description.description",
+        FT_STRING, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_dhcp_mode_interface_identifier,
+      { "Interface Identifier", "rdm.pd.dhcp_mode.interface_identifier",
+        FT_UINT32, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_dhcp_mode_enabled,
+      { "Enabled", "rdm.pd.dhcp_mode.enabled",
+        FT_UINT8, BASE_DEC, VALS(enabled_disabled_vals), 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_dimmer_info_minimum_level_lower_limit,
+      { "Minimum Level Lower Limit", "rdm.pd.dimmer_info.minimum_level_lower_limit",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_dimmer_info_minimum_level_upper_limit,
+      { "Minimum Level Upper Limit", "rdm.pd.dimmer_info.minimum_level_upper_limit",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_dimmer_info_maximum_level_lower_limit,
+      { "Maximum Level Lower Limit", "rdm.pd.dimmer_info.maximum_level_lower_limit",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_dimmer_info_maximum_level_upper_limit,
+      { "Maximum Level Upper Limit", "rdm.pd.dimmer_info.maximum_level_upper_limit",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_dimmer_info_number_of_supported_curves,
+      { "Number Of Supported Curves", "rdm.pd.dimmer_info.number_of_supported_curves",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_dimmer_info_levels_resolution,
+      { "Levels Resolution", "rdm.pd.dimmer_info.levels_resolution",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_dimmer_info_minimum_level_split_levels_supported,
+      { "Minimum Level Split Levels Supported", "rdm.pd.dimmer_info.minimum_level_split_levels_supported",
+        FT_UINT8, BASE_DEC, VALS(true_false_vals), 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_discovery_state_endpoint_id,
+      { "Endpoint ID", "rdm.pd.discovery_state.endpoint_id",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_discovery_state_device_count,
+      { "Device Count", "rdm.pd.discovery_state.device_count",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_discovery_state_discovery_state,
+      { "State", "rdm.pd.discovery_state.state",
+        FT_UINT8, BASE_DEC, VALS(rdm_discovery_state_vals), 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_dmx_block_address_base_dmx_address,
+      { "Base DMX Address", "rdm.pd.dmx_block_address.base_dmx_address",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_dmx_block_address_subdevice_footprint,
+      { "Sub-Device Footprint", "rdm.pd.dmx_block_address.subdevice_footprint",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_dmx_fail_mode_scene_number,
+      { "Scene Number", "rdm.pd.dmx_fail_mode.scene_number",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_dmx_fail_mode_loss_of_signal_delay,
+      { "Loss Of Signal Delay", "rdm.pd.dmx_fail_mode.loss_of_signal_delay",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_dmx_fail_mode_hold_time,
+      { "Hold Time", "rdm.pd.dmx_fail_mode.hold_time",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_dmx_fail_mode_level,
+      { "Level", "rdm.pd.dmx_fail_mode.level",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_dmx_pers_nr,
+      { "DMX Pers. Nr.", "rdm.pd.dmx_pers.nr",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_dmx_pers_count,
+      { "DMX Pers. Count", "rdm.pd.dmx_pers.count",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_dmx_pers_requested,
+      { "DMX Pers. Requested", "rdm.pd.dmx_pers.requested",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_dmx_pers_slots,
+      { "DMX Pers. Slots", "rdm.pd.dmx_pers.slots",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_dmx_pers_text,
+      { "DMX Pers. Text", "rdm.pd.dmx_pers.text",
+        FT_STRING, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_dmx_startup_mode_scene_number,
+      { "Scene Number", "rdm.pd.dmx_startup_mode.scene_number",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_dmx_startup_mode_loss_of_signal_delay,
+      { "Startup Delay Time", "rdm.pd.dmx_startup_mode.startup_delay_time",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_dmx_startup_mode_hold_time,
+      { "Hold Time", "rdm.pd.dmx_startup_mode.hold_time",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_dmx_startup_mode_level,
+      { "Level", "rdm.pd.dmx_startup_mode.level",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_dns_domain_name,
+      { "Domain Name", "rdm.pd.dns_domain_name",
+        FT_STRING, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_dns_hostname,
+      { "Host Name", "rdm.pd.dns_hostname",
+        FT_STRING, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_dns_ipv4_name_server_index,
+      { "Index", "rdm.pd.dns_ipv4_name_server.index",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_dns_ipv4_name_server_address,
+      { "Index", "rdm.pd.dns_ipv4_name_server.address",
+        FT_IPv4, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_endpoint_label_endpoint_id,
+      { "Endpoint ID", "rdm.pd.endpoint_label.endpoint_id",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_endpoint_label_label,
+      { "Label", "rdm.pd.endpoint_label.label",
+        FT_STRING, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_endpoint_list_change_number,
+      { "List Change Number", "rdm.pd.endpoint_list.change_number",
+        FT_UINT32, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_endpoint_list_endpoint_id,
+      { "Endpoint ID", "rdm.pd.endpoint_list.endpoint_id",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_endpoint_list_endpoint_type,
+      { "Endpoint Type", "rdm.pd.endpoint_list.endpoint_type",
+        FT_UINT8, BASE_DEC, VALS(rdm_endpoint_type_vals), 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_endpoint_list_change_change_number,
+      { "List Change Number", "rdm.pd.endpoint_list_change.change_number",
+        FT_UINT32, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_endpoint_mode_endpoint_id,
+      { "Endpoint ID", "rdm.pd.endpoint_mode.endpoint_id",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_endpoint_mode_endpoint_mode,
+      { "Endpoint ID", "rdm.pd.endpoint_mode.endpoint_mode",
+        FT_UINT8, BASE_DEC, VALS(rdm_endpoint_mode_vals), 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_endpoint_responder_list_change_endpoint_id,
+      { "Endpoint ID", "rdm.pd.endpoint_responder_list_change.endpoint_id",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_endpoint_responder_list_change_change_number,
+      { "Change Number", "rdm.pd.endpoint_responder_list_change.change_number",
+        FT_UINT32, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_endpoint_responders_endpoint_id,
+      { "Endpoint ID", "rdm.pd.endpoint_responders.endpoint_id",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_endpoint_responders_change_number,
+      { "Change Number", "rdm.pd.endpoint_responders.change_number",
+        FT_UINT32, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_endpoint_responders_uid,
+      { "UID", "rdm.pd.endpoint_responders.uid",
+        FT_BYTES, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_endpoint_timing_endpoint_id,
+      { "Endpoint ID", "rdm.pd.endpoint_timing.endpoint_id",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_endpoint_timing_setting,
+      { "Setting", "rdm.pd.endpoint_timing.setting",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_endpoint_timing_number_of_settings,
+      { "Number Of Settings", "rdm.pd.endpoint_timing.number_of_settings",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_endpoint_timing_description_setting,
+      { "Setting", "rdm.pd.endpoint_timing_description.setting",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_endpoint_timing_description_description,
+      { "Description", "rdm.pd.endpoint_timing_description.description",
+        FT_STRING, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_endpoint_to_universe_endpoint_id,
+      { "Endpoint ID", "rdm.pd.endpoint_to_universe.endpoint_id",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_endpoint_to_universe_universe_number,
+      { "Universe Number", "rdm.pd.endpoint_to_universe.universe_number",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_hardware_address_type1_interface_identifier,
+      { "Interface Identifier", "rdm.pd.hardware_address_type1.interface_identifier",
+        FT_UINT32, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_hardware_address_type1_hardware_address,
+      { "Hardware Address", "rdm.pd.hardware_address_type1.hardware_address",
+        FT_BYTES, SEP_COLON, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_identify_endpoint_endpoint_id,
+      { "Endpoint ID", "rdm.pd.identify_endpoint.endpoint_id",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_identify_endpoint_identify_state,
+      { "Identify State", "rdm.pd.identify_endpoint.identify_state",
+        FT_UINT8, BASE_DEC, VALS(on_off_vals), 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_identify_mode,
+      { "Identify Mode", "rdm.pd.identify_mode.identify_mode",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_interface_apply_configuration_interface_identifier,
+      { "Interface Identifier", "rdm.pd.interface_apply_configuration.interface_identifier",
+        FT_UINT32, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_interface_label_interface_identifier,
+      { "Interface Identifier", "rdm.pd.interface_label.interface_identifier",
+        FT_UINT32, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_interface_label_label,
+      { "Label", "rdm.pd.interface_label.label",
+        FT_STRING, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_interface_release_dhcp_interface_identifier,
+      { "Interface Identifier", "rdm.pd.interface_release_dhcp.interface_identifier",
+        FT_UINT32, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_interface_renew_dhcp_interface_identifier,
+      { "Interface Identifier", "rdm.pd.interface_renew_dhcp.interface_identifier",
+        FT_UINT32, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_ipv4_default_route_interface_identifier,
+      { "Interface Identifier", "rdm.pd.ipv4_default_route.interface_identifier",
+        FT_UINT32, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_ipv4_default_route_ipv4_default_route,
+      { "Interface Identifier", "rdm.pd.ipv4_default_route.default_route",
+        FT_IPv4, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_list_interfaces_interface_identifier,
+      { "Interface Identifier", "rdm.pd.list_interfaces.interface_identifier",
+        FT_UINT32, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_list_interfaces_interface_hardware_type,
+      { "Interface Hardware Type", "rdm.pd.list_interfaces.interface_hardware_type",
+        FT_UINT16, BASE_DEC, VALS(arp_hrd_vals), 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_lock_pin_pin_code,
+      { "PIN Code", "rdm.pd.lock_pin.pin_code",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+    { &hf_rdm_pd_lock_pin_new_pin_code,
+      { "New PIN Code", "rdm.pd.lock_pin.new_pin_code",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_lock_state_lock_state,
+      { "Lock State", "rdm.pd.lock_state.lock_state",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_lock_state_number_of_lock_states,
+      { "Number Of Lock States", "rdm.pd.lock_state.number_of_lock_states",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_lock_state_pin_code,
+      { "PIN Code", "rdm.pd.lock_state.pin_code",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_lock_state_description_lock_state,
+      { "Lock State", "rdm.pd.lock_state_description.lock_state",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_lock_state_description_text,
+      { "Description", "rdm.pd.lock_state_description.description",
+        FT_STRING, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_maximum_level_level,
+      { "Level", "rdm.pd.maximum_level.level",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_preset_mergemode,
+      { "Merge Mode", "rdm.pd.preset_mergemode",
+        FT_UINT8, BASE_DEC, VALS(rdm_mergemode_vals), 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_power_on_self_test,
+      { "Power On Self Test", "rdm.pd.power_on_self_test",
+        FT_UINT8, BASE_DEC, VALS(enabled_disabled_vals), 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_minimum_level_increasing,
+      { "Increasing", "rdm.pd.minimum_level.increasing",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_minimum_level_decreasing,
+      { "Decreasing", "rdm.pd.minimum_level.decreasing",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_minimum_level_on_below_minimum,
+      { "On Below Minimum", "rdm.pd.minimum_level.on_below_minimum",
+        FT_UINT8, BASE_DEC, VALS(true_false_vals), 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_modulation_frequency_modulation_frequency,
+      { "Modulation Frequency", "rdm.pd.modulation_frequency.modulation_frequency",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_modulation_frequency_number_of_modulation_frequencies,
+      { "Number Of Modulation Frequencies", "rdm.pd.modulation_frequency.number_of_modulation_frequencies",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_modulation_frequency_description_modulation_frequency,
+      { "Modulation Frequency", "rdm.pd.modulation_frequency_description.modulation_frequency",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_modulation_frequency_description_text,
+      { "Description", "rdm.pd.modulation_frequency_description.description",
+        FT_STRING, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_output_response_time_response_time,
+      { "Response Time", "rdm.pd.response_time.response_time",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_output_response_time_number_of_response_times,
+      { "Number Of Response Times", "rdm.pd.response_time.number_of_response_times",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_output_response_time_description_output_response_time,
+      { "Output Response Time", "rdm.pd.output_response_time_description.output_response_time",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_output_response_time_description_text,
+      { "Description", "rdm.pd.output_response_time_description.description",
+        FT_STRING, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_preset_info_level_field_supported,
+      { "Level Field Supported", "rdm.pd.preset_info.level_field_supported",
+        FT_UINT8, BASE_DEC, VALS(true_false_vals), 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_preset_info_preset_sequence_supported,
+      { "Preset Sequence Supported", "rdm.pd.preset_info.preset_sequence_supported",
+        FT_UINT8, BASE_DEC, VALS(true_false_vals), 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_preset_info_split_times_supported,
+      { "Split Times Supported", "rdm.pd.preset_info.split_times_supported",
+        FT_UINT8, BASE_DEC, VALS(true_false_vals), 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_preset_info_dmx_fail_infinite_delay_time_supported,
+      { "DMX Fail Infinite Delay Time Supported", "rdm.pd.preset_info.dmx_fail_infinite_delay_time_supported",
+        FT_UINT8, BASE_DEC, VALS(true_false_vals), 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_preset_info_dmx_fail_infinite_hold_time_supported,
+      { "DMX Fail Infinite Hold Time Supported", "rdm.pd.preset_info.dmx_fail_infinite_hold_time_supported",
+        FT_UINT8, BASE_DEC, VALS(true_false_vals), 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_preset_info_start_up_infinite_hold_time_supported,
+      { "Start Up_ Infinite Hold Time Supported", "rdm.pd.preset_info.start_up_infinite_hold_time_supported",
+        FT_UINT8, BASE_DEC, VALS(true_false_vals), 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_preset_info_maximum_scene_number,
+      { "Maximum Scene Number", "rdm.pd.preset_info.maximum_scene_number",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_preset_info_minimum_preset_fade_time_supported,
+      { "Minimum Preset Fade Time Supported", "rdm.pd.preset_info.minimum_preset_fade_time_supported",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_preset_info_maximum_preset_fade_time_supported,
+      { "Maximum Preset Fade Time Supported", "rdm.pd.preset_info.maximum_preset_fade_time_supported",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_preset_info_minimum_preset_wait_time_supported,
+      { "Minimum Preset Wait Time Supported", "rdm.pd.preset_info.minimum_preset_wait_time_supported",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_preset_info_maximum_preset_wait_time_supported,
+      { "Maximum Preset Wait Time Supported", "rdm.pd.preset_info.maximum_preset_wait_time_supported",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_preset_info_minimum_dmx_fail_delay_time_supported,
+      { "Minimum DMX Fail Delay Time Supported", "rdm.pd.preset_info.minimum_dmx_fail_delay_time_supported",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_preset_info_maximum_dmx_fail_delay_time_supported,
+      { "Maximum DMX Fail Delay Time Supported", "rdm.pd.preset_info.maximum_dmx_fail_delay_time_supported",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_preset_info_minimum_dmx_fail_hold_time_supported,
+      { "Minimum DMX Fail Hold Time Supported", "rdm.pd.preset_info.minimum_dmx_fail_hold_time_supported",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_preset_info_maximum_dmx_fail_hold_time_supported,
+      { "Maximum DMX Fail Hold Time Supported", "rdm.pd.preset_info.maximum_dmx_fail_hold_time_supported",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_preset_info_minimum_start_up_delay_time_supported,
+      { "Minimum Start Up Delay Time Supported", "rdm.pd.preset_info.minimum_start_up_delay_time_supported",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_preset_info_maximum_start_up_delay_time_supported,
+      { "Maximum Start Up Delay Time Supported", "rdm.pd.preset_info.maximum_start_up_delay_time_supported",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_preset_info_minimum_start_up_hold_time_supported,
+      { "Minimum Start Up Hold Time Supported", "rdm.pd.preset_info.minimum_start_up_hold_time_supported",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_preset_info_maximum_start_up_hold_time_supported,
+      { "Maximum Start Up Hold Time Supported", "rdm.pd.preset_info.maximum_start_up_hold_time_supported",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_preset_status_scene_number,
+      { "Scene Number", "rdm.pd.preset_status.scene_number",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_preset_status_up_fade_time,
+      { "Up Fade Time", "rdm.pd.preset_status.up_fade_time",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_preset_status_down_fade_time,
+      { "Down Fade Time", "rdm.pd.preset_status.down_fade_time",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_preset_status_wait_time,
+      { "Wait Time", "rdm.pd.preset_status.wait_time",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_preset_status_programmed,
+      { "Programmed", "rdm.pd.preset_status.programmed",
+        FT_UINT8, BASE_DEC, VALS(rdm_preset_programmed_vals), 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_preset_status_clear_preset,
+      { "Clear Preset", "rdm.pd.preset_status.clear_preset",
+        FT_UINT8, BASE_DEC, VALS(true_false_vals), 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_rdm_traffic_enable_endpoint_id,
+      { "Endpoint ID", "rdm.pd.rdm_traffic_enable.endpoint_id",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_rdm_traffic_enable_rdm_enabled,
+      { "Enabled", "rdm.pd.rdm_traffic_enable.endpoint_id",
+        FT_UINT8, BASE_DEC, VALS(true_false_vals), 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_slot_offset,
+      { "Slot Offset", "rdm.pd.slot_offset",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_slot_type,
+      { "Slot Type", "rdm.pd.slot_type",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_slot_label_id,
+      { "Slot Label ID", "rdm.pd.slot_label_id",
+        FT_UINT16, BASE_HEX, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_slot_nr,
+      { "Slot Nr.", "rdm.pd.slot_nr",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_slot_description,
+      { "Slot Description", "rdm.pd.slot_description",
+        FT_STRING, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_slot_value,
+      { "Slot Value", "rdm.pd.slot_value",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_static_address_interface_identifier,
+      { "Interface Identifier", "rdm.pd.static_address.interface_identifier",
+        FT_UINT32, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_static_address_ipv4_address,
+      { "IPv4 Address", "rdm.pd.static_address.ipv4_address",
+        FT_IPv4, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_static_address_netmask,
+      { "Netmask", "rdm.pd.static_address.netmask",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_tcp_comms_status_scope_string,
+      { "Scope String", "rdm.pd.tcp_comms_status.scope_string",
+        FT_STRING, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_tcp_comms_status_broker_ipv4_address,
+      { "Broker IPV4 Address", "rdm.pd.tcp_comms_status.broker_ipv4_address",
+        FT_IPv4, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_tcp_comms_status_broker_ipv6_address,
+      { "Broker IPV6 Address", "rdm.pd.tcp_comms_status.broker_ipv6_address",
+        FT_IPv6, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_tcp_comms_status_broker_port,
+      { "Broker Port", "rdm.pd.tcp_comms_status.broker_port",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_tcp_comms_status_unhealthy_tcp_events,
+      { "Unhealthy TCP Events", "rdm.pd.tcp_comms_status.unhealthy_tcp_events",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_zeroconf_mode_interface_identifier,
+      { "Interface Identifier", "rdm.pd.zeroconf_mode.interface_identifier",
+        FT_UINT32, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_zeroconf_mode_enabled,
+      { "Enabled", "rdm.pd.zeroconf_mode.enabled",
+        FT_UINT8, BASE_DEC, VALS(enabled_disabled_vals), 0x0,
+        NULL, HFILL }},
+
+    { &hf_rdm_pd_rec_value_support,
+      { "Rec. Value Support", "rdm.pd.rec_value_support",
+        FT_UINT8, BASE_HEX, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_parameter_id,
+      { "Parameter ID", "rdm.pid",
+        FT_UINT16, BASE_HEX | BASE_EXT_STRING, &etc_param_id_vals_ext, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_parameter_id,
+      { "ID", "rdm.pd.parameter.id",
+        FT_UINT16, BASE_HEX, VALS(etc_param_id_vals), 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_device_model_id,
+      { "Device Model ID", "rdm.pd.device_model_id",
+        FT_UINT16, BASE_HEX, VALS(etc_model_id_vals), 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_led_curve,
+      { "Curve", "rdm.pd.led_curve.curve",
+        FT_UINT8, BASE_DEC, VALS(etc_led_curve_vals), 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_led_curve_description_curve,
+      { "Curve", "rdm.pd.led_curve_description.curve",
+        FT_UINT8, BASE_DEC, VALS(etc_led_curve_vals), 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_led_curve_description_text,
+      { "Description", "rdm.pd.led_curve_description.description",
+        FT_STRING, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_led_strobe,
+      { "Strobe", "rdm.pd.led_strobe",
+        FT_UINT8, BASE_DEC, VALS(enabled_disabled_vals), 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_led_output_mode,
+      { "Output Mode", "rdm.pd.led_output_mode",
+        FT_UINT8, BASE_DEC, VALS(etc_led_output_mode_vals), 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_led_output_mode_description_mode,
+      { "Output Mode", "rdm.pd.led_output_mode_description.output_mode",
+        FT_UINT8, BASE_DEC, VALS(etc_led_output_mode_vals), 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_led_output_mode_description_text,
+      { "Description", "rdm.pd.lled_output_mode_description.description",
+        FT_STRING, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_led_red_shift,
+      { "Red Shift", "rdm.pd.led_red_shift",
+        FT_UINT8, BASE_DEC, VALS(enabled_disabled_vals), 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_led_white_point,
+      { "White Point", "rdm.pd.led_white_point",
+        FT_UINT8, BASE_DEC, VALS(etc_led_white_point_vals), 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_led_white_point_description_white_point,
+      { "White Point", "rdm.pd.led_white_point_description.white_point",
+        FT_UINT8, BASE_DEC, VALS(etc_led_white_point_vals), 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_led_white_point_description_text,
+      { "Description", "rdm.pd.led_white_point_description.description",
+        FT_STRING, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_led_frequency,
+      { "LED Frequency (Hz)", "rdm.pd.led_frequency",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_dmx_data_loss_behavior,
+      { "DMX Data Loss Behavior", "rdm.pd.dmx_data_loss_behavior",
+        FT_UINT8, BASE_DEC, VALS(etc_dmx_data_loss_vals), 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_dmx_data_loss_behavior_description_behavior,
+      { "DMX Data Loss Behavior", "rdm.pd.dmx_data_loss_behavior_description.behavior",
+        FT_UINT8, BASE_DEC, VALS(etc_dmx_data_loss_vals), 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_dmx_data_loss_behavior_description_text,
+      { "Description", "rdm.pd.dmx_data_loss_behavior_description.description",
+        FT_STRING, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_led_plus_seven,
+      { "LED Plus Seven", "rdm.pd.led_plus_seven",
+        FT_UINT8, BASE_DEC, VALS(enabled_disabled_vals), 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_backlight_brightness,
+      { "Backlight Brightness", "rdm.pd.backlight_brightness",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_backlight_timeout,
+      { "Backlight Timeout", "rdm.pd.backlight_timeout",
+        FT_UINT8, BASE_DEC, VALS(etc_backlight_timeout_vals), 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_status_indicators,
+      { "Status Indicators", "rdm.pd.status_indicators",
+        FT_UINT8, BASE_DEC, VALS(on_off_vals), 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_overtemp_mode,
+      { "Overtemp Mode", "rdm.pd.overtemp_mode",
+        FT_UINT8, BASE_DEC, VALS(etc_overtemp_mode_vals), 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_simple_setup_mode,
+      { "Simple Setup Mode", "rdm.pd.simple_setup_mode",
+        FT_UINT8, BASE_DEC, VALS(etc_simple_setup_mode_vals), 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_led_strobe_description_strobe,
+      { "Strobe", "rdm.pd.led_strobe_description.led_strobe",
+        FT_UINT8, BASE_DEC, VALS(enabled_disabled_vals), 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_led_strobe_description_text,
+      { "Description", "rdm.pd.led_strobe_description.description",
+        FT_STRING, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_red_shift_description_red_shift,
+      { "Red Shift", "rdm.pd.red_shift_description.red_shift",
+        FT_UINT8, BASE_DEC, VALS(enabled_disabled_vals), 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_red_shift_description_text,
+      { "Description", "rdm.pd.red_shift_description.description",
+        FT_STRING, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_plus_seven_description_plus_seven,
+      { "Plus Seven", "rdm.pd.plus_seven_description.plus_seven",
+        FT_UINT8, BASE_DEC, VALS(enabled_disabled_vals), 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_plus_seven_description_text,
+      { "Description", "rdm.pd.plus_seven_description.description",
+        FT_STRING, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_backlight_timeout_description_timeout,
+      { "Backlight Timeout", "rdm.pd.backlight_timeout_description.backlight_timeout",
+        FT_UINT8, BASE_DEC, VALS(etc_backlight_timeout_vals), 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_backlight_timeout_description_text,
+      { "Description", "rdm.pd.backlight_timeout_description.description",
+        FT_STRING, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_simple_setup_mode_description_mode,
+      { "Simple Setup Mode", "rdm.pd.simple_setup_mode_description.mode",
+        FT_UINT8, BASE_DEC, VALS(etc_simple_setup_mode_vals), 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_simple_setup_mode_description_text,
+      { "Description", "rdm.pd.simple_setup_mode_description.description",
+        FT_STRING, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_overtemp_mode_description_mode,
+      { "Overtemp Mode", "rdm.pd.overtemp_mode_description.mode",
+        FT_UINT8, BASE_DEC, VALS(etc_overtemp_mode_vals), 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_overtemp_mode_description_text,
+      { "Description", "rdm.pd.overtemp_mode_description.description",
+        FT_STRING, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_led_requested_xy_x,
+      { "X Coordinate", "rdm.pd.led_requested_xy.x",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_led_requested_xy_y,
+      { "Y Coordinate", "rdm.pd.led_requested_xy.y",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_led_current_xy_x,
+      { "X Coordinate", "rdm.pd.led_current_xy.x",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_led_current_xy_y,
+      { "Y Coordinate", "rdm.pd.led_current_xy.y",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_current_pwm_led_number,
+      { "LED Number", "rdm.pd.current_pwm.led_number",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_current_pwm_channel_duty_cycle,
+      { "Channel Duty Cycle", "rdm.pd.current_pwm.channel_duty_cycle",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_tristimulus_led_number,
+      { "LED Number", "rdm.pd.tristimulus.led_number",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_tristimulus_x,
+      { "X", "rdm.pd.tristimulus.x",
+        FT_UINT32, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_tristimulus_y,
+      { "Y", "rdm.pd.tristimulus.y",
+        FT_UINT32, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_tristimulus_z,
+      { "Z", "rdm.pd.tristimulus.z",
+        FT_UINT32, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_led_information_led_number,
+      { "LED Number", "rdm.pd.led_information.led_number",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_led_information_type,
+      { "Type", "rdm.pd.led_information.type",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_led_information_dmx_control_channel,
+      { "DMX Control Channel", "rdm.pd.led_information.dmx_control_channel",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_led_information_drive_current,
+      { "Drive Current (ma)", "rdm.pd.led_information.drive_current",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_led_information_gamut_polygon_order,
+      { "Gamut Polygon Order", "rdm.pd.led_information.gamut_polygon_order",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_led_information_quantity,
+      { "Quantity", "rdm.pd.led_information.quantity",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_preset_config_preset_number,
+      { "Preset Number", "rdm.pd.preset_config.preset_number",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_preset_config_fade_time,
+      { "Fade Time (seconds)", "rdm.pd.preset_config.fade_time",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_preset_config_delay_time,
+      { "Delay Time (seconds)", "rdm.pd.preset_config.delay_time",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_preset_config_hue,
+      { "Hue", "rdm.pd.preset_config.hue",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_preset_config_saturation,
+      { "Saturation", "rdm.pd.preset_config.saturation",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_preset_config_intensity,
+      { "Intensity", "rdm.pd.preset_config.intensity",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_preset_config_strobe,
+      { "Strobe", "rdm.pd.preset_config.strobe",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_sequence_playback_sequence_number,
+      { "Sequence Number", "rdm.pd.sequence_playback.sequence_number",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_sequence_config_sequence_number,
+      { "Sequence Number", "rdm.pd.sequence_config.sequence_number",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_sequence_config_preset_steps,
+      { "Preset Steps", "rdm.pd.sequence_config.preset_steps",
+        FT_NONE, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_sequence_config_preset_step,
+      { "Preset Step", "rdm.pd.sequence_config.preset_step",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_sequence_config_step_link_times,
+      { "Step Link Times (seconds)", "rdm.pd.sequence_config.step_link_times",
+        FT_NONE, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_sequence_config_step_link_time,
+      { "Step Link Time", "rdm.pd.sequence_config.step_link_time",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_sequence_config_rate,
+      { "Rate", "rdm.pd.sequence_config.rate",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_sequence_config_end_state,
+      { "End State", "rdm.pd.sequence_config.end_state",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_low_power_timeout,
+      { "Low Power Timeout", "rdm.pd.low_power_timeout",
+        FT_UINT8, BASE_DEC, VALS(etc_low_power_timeout_vals), 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_low_power_timeout_description_timeout,
+      { "Low Power Timeout", "rdm.pd.low_power_timeout_description.timeout",
+        FT_UINT8, BASE_DEC, VALS(etc_low_power_timeout_vals), 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_low_power_timeout_description_text,
+      { "Description", "rdm.pd.low_power_timeout_description.description",
+        FT_STRING, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_led_enum_frequency,
+      { "Frequency", "rdm.pd.led_enum_frequency",
+        FT_UINT8, BASE_DEC, VALS(etc_led_frequency_enum_vals), 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_led_enum_frequency_description_frequency,
+      { "Frequency", "rdm.pd.led_enum_frequency_description.frequency",
+        FT_UINT8, BASE_DEC, VALS(etc_led_frequency_enum_vals), 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_led_enum_frequency_description_text,
+      { "Description", "rdm.pd.led_enum_frequency_description.description",
+        FT_UINT8, BASE_DEC, VALS(etc_led_frequency_enum_vals), 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_rgbi_preset_config_preset_number,
+      { "Preset Number", "rdm.pd.rgbi_preset_config.preset_number",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_rgbi_preset_config_fade_time,
+      { "Fade Time (seconds)", "rdm.pd.rgbi_preset_config.fade_time",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_rgbi_preset_config_delay_time,
+      { "Delay Time (seconds)", "rdm.pd.rgbi_preset_config.delay_time",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_rgbi_preset_config_red,
+      { "Red", "rdm.pd.rgbi_preset_config.red",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_rgbi_preset_config_green,
+      { "Green", "rdm.pd.rgbi_preset_config.green",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_rgbi_preset_config_blue,
+      { "Blue", "rdm.pd.rgbi_preset_config.blue",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_rgbi_preset_config_intensity,
+      { "Intensity", "rdm.pd.rgbi_preset_config.intensity",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_rgbi_preset_config_strobe,
+      { "Strobe", "rdm.pd.rgbi_preset_config.strobe",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_cct_preset_config_preset_number,
+      { "Preset Number", "rdm.pd.cct_preset_config.preset_number",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_cct_preset_config_fade_time,
+      { "Fade Time (seconds)", "rdm.pd.cct_preset_config.fade_time",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_cct_preset_config_delay_time,
+      { "Delay Time (seconds)", "rdm.pd.cct_preset_config.delay_time",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_cct_preset_config_white_point,
+      { "White Point", "rdm.pd.cct_preset_config.white_point",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_cct_preset_config_tint,
+      { "Tint", "rdm.pd.cct_preset_config.tint",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_cct_preset_config_strobe,
+      { "Strobe", "rdm.pd.cct_preset_config.strobe",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_cct_preset_config_intensity,
+      { "Intensity", "rdm.pd.cct_preset_config.intensity",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_cct_preset_config_tone,
+      { "Tone", "rdm.pd.cct_preset_config.tone",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_cct_preset_config_reserved,
+      { "Reserved", "rdm.pd.cct_preset_config.reserved",
+        FT_UINT32, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_supplementary_device_version_param_index,
+      { "Param Index", "rdm.pd.supplementary_device_version.param_index",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_supplementary_device_version_param_description,
+      { "Param Description", "rdm.pd.supplementary_device_version.param_description",
+        FT_BYTES, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_power_command,
+      { "State", "rdm.pd.power_command",
+        FT_UINT8, BASE_DEC, VALS(on_off_vals), 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_power_command_description_state,
+      { "State", "rdm.pd.power_command_description.state",
+        FT_UINT8, BASE_DEC, VALS(on_off_vals), 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_power_command_description_text,
+      { "Description", "rdm.pd.power_command_description.description",
+        FT_STRING, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_dali_short_address,
+      { "Short Address", "rdm.pd.dali_short_address",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_dali_group_membership,
+      { "Group Membership", "rdm.pd.dali_group_membership",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_auto_bind,
+      { "Auto Bind", "rdm.pd.auto_bind",
+        FT_UINT8, BASE_DEC, VALS(true_false_vals), 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_packet_delay,
+      { "Packet Delay", "rdm.pd.packet_delay",
+        FT_UINT8, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_has_enum_text_pid,
+      { "PID", "rdm.pd.has_enum_text.pid",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_has_enum_text_true_false,
+      { "Value", "rdm.pd.has_enum_text.value",
+        FT_UINT8, BASE_DEC, VALS(true_false_vals), 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_get_enum_text_pid,
+      { "PID", "rdm.pd.get_enum_text.pid",
+        FT_UINT16, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_get_enum_text_enum,
+      { "Enum", "rdm.pd.get_enum_text.enum",
+        FT_UINT32, BASE_DEC, NULL, 0x0,
+        NULL, HFILL }},
+
+    { &hf_etc_pd_get_enum_text_description,
+      { "Description", "rdm.pd.get_enum_text.description",
+        FT_STRING, BASE_NONE, NULL, 0x0,
+        NULL, HFILL }},
+
+  };
+
+  static gint *ett[] = {
+    &ett_rdm,
+    &ett_etc_sequence_config_steps,
+    &ett_etc_sequence_config_times
+  };
+
+  static ei_register_info ei[] = {
+    { &ei_rdm_checksum, { "rdm.bad_checksum", PI_CHECKSUM, PI_ERROR, "Bad checksum", EXPFILL }},
+  };
+
+  expert_module_t* expert_rdm;
+
+  proto_rdm = proto_register_protocol("Remote Device Management", "RDM", "rdm");
+  proto_register_field_array(proto_rdm, hf, array_length(hf));
+  proto_register_subtree_array(ett, array_length(ett));
+  register_dissector("rdm", dissect_rdm, proto_rdm);
+  expert_rdm = expert_register_protocol(proto_rdm);
+  expert_register_field_array(expert_rdm, ei, array_length(ei));
 }
 
 void
 proto_reg_handoff_rdm(void) {
-	dissector_add_uint("dmx", 0xCC, create_dissector_handle(dissect_rdm, proto_rdm));
+  dissector_add_uint("dmx", 0xCC, create_dissector_handle(dissect_rdm, proto_rdm));
 }
 
 /*