/* packet-cipmotion.c

 * Routines for CIP (Common Industrial Protocol) Motion dissection

 * CIP Motion Home: www.odva.org

 *

 * This dissector includes items from:

 *    CIP Volume 9: CIP Motion, Edition 1.13

 *

 * Copyright 2006-2007

 * Benjamin M. Stocks <bmstocks@ra.rockwell.com>

 *

 * Wireshark - Network traffic analyzer

 * By Gerald Combs <gerald@wireshark.org>

 * Copyright 1998 Gerald Combs

 *

 * SPDX-License-Identifier: GPL-2.0-or-later

 */

#include "config.h"

#include <epan/packet.h>

#include <epan/expert.h>

#include <epan/unit_strings.h>

#include <wsutil/ws_roundup.h>

#include "packet-cipmotion.h"

#include "packet-cip.h"

#include "packet-enip.h"

void proto_register_cipmotion(void);

/* The entry point to the actual dissection is: dissect_cipmotion */

void proto_reg_handoff_cipmotion(void);

/* Protocol handle for CIP Motion */

static int proto_cipmotion;

static int proto_cipmotion3;

/* Header field identifiers, these are registered in the

 * proto_register_cipmotion function along with the bites/bytes

 * they represent */

static int hf_cip_format;

static int hf_cip_revision;

static int hf_cip_class1_seqnum;

static int hf_configuration_block_format_rev;

static int hf_configuration_block_drive_power_struct_id;

static int hf_cip_updateid;

static int hf_cip_instance_cnt;

static int hf_cip_last_update;

static int hf_cip_node_status;

static int hf_cip_node_control;

static int hf_cip_node_control_remote;

static int hf_cip_node_control_sync;

static int hf_cip_node_data_valid;

static int hf_cip_node_fault_reset;

static int hf_cip_node_device_faulted;

static int hf_cip_time_data_set;

static int hf_cip_time_data_stamp;

static int hf_cip_time_data_offset;

static int hf_cip_time_data_diag;

static int hf_cip_time_data_time_diag;

static int hf_cip_cont_time_stamp;

static int hf_cip_cont_time_offset;

static int hf_cip_devc_time_stamp;

static int hf_cip_devc_time_offset;

static int hf_cip_lost_update;

static int hf_cip_late_update;

static int hf_cip_data_rx_time_stamp;

static int hf_cip_data_tx_time_stamp;

static int hf_cip_node_fltalarms;

static int hf_cip_motor_cntrl;

static int hf_cip_feedback;

static int hf_cip_feedback_mode;

static int hf_cip_feedback_data_type;

static int hf_cip_controller_update_delay_high_limit;

static int hf_cip_controller_update_delay_low_limit;

static int hf_cip_sync_threshold;

static int hf_cip_step_threshold;

static int hf_cip_control_method;

static int hf_cip_feedback_unit_ratio;

static int hf_cip_velocity_threshold;

static int hf_cip_velocity_lock_tolerance;

static int hf_cip_velocity_standstill_window;

static int hf_cip_proving_configuration;

static int hf_cip_torque_prove_current;

static int hf_cip_brake_test_torque;

static int hf_cip_zero_speed;

static int hf_cip_zero_speed_time;

static int hf_cip_dc_bus_voltage;

static int hf_cip_bus_regulator_action;

static int hf_cip_inverter_capacity;

static int hf_cip_converter_thermal_overload_user_limit;

static int hf_cip_bus_undervoltage_user_limit;

static int hf_cip_rotary_motor_poles;

static int hf_cip_rotary_motor_inertia;

static int hf_cip_rotary_motor_max_speed;

static int hf_connection_configuration_bits;

static int hf_connection_configuration_bits_power;

static int hf_connection_configuration_bits_safety_bit_valid;

static int hf_connection_configuration_bits_allow_network_safety;

static int hf_cip_axis_control;

static int hf_cip_control_status;

static int hf_cip_control_status_complete;

static int hf_cip_control_status_bus_up;

static int hf_cip_control_status_bus_unload;

static int hf_cip_control_status_power_loss;

static int hf_cip_axis_response;

static int hf_cip_axis_resp_stat;

static int hf_cip_cmd_data_pos_cmd;

static int hf_cip_cmd_data_vel_cmd;

static int hf_cip_cmd_data_acc_cmd;

static int hf_cip_cmd_data_trq_cmd;

static int hf_cip_cmd_data_unwind_cycle_count;

static int hf_cip_cmd_data_pos_displacement;

static int hf_cip_act_data_pos;

static int hf_cip_act_data_vel;

static int hf_cip_act_data_acc;

static int hf_cip_act_unwind_cycle_count;

static int hf_cip_act_pos_displacement;

static int hf_cip_sts_flt;

static int hf_cip_sts_alrm;

static int hf_cip_sts_sts;

static int hf_cip_sts_iosts;

static int hf_cip_sts_axis_safety;

static int hf_cip_intrp;

static int hf_cip_position_data_type;

static int hf_cip_axis_state;

static int hf_cip_evnt_ctrl_reg1_pos;

static int hf_cip_evnt_ctrl_reg1_neg;

static int hf_cip_evnt_ctrl_reg2_pos;

static int hf_cip_evnt_ctrl_reg2_neg;

static int hf_cip_evnt_ctrl_reg1_posrearm;

static int hf_cip_evnt_ctrl_reg1_negrearm;

static int hf_cip_evnt_ctrl_reg2_posrearm;

static int hf_cip_evnt_ctrl_reg2_negrearm;

static int hf_cip_evnt_ctrl_marker_pos;

static int hf_cip_evnt_ctrl_marker_neg;

static int hf_cip_evnt_ctrl_home_pos;

static int hf_cip_evnt_ctrl_home_neg;

static int hf_cip_evnt_ctrl_home_pp;

static int hf_cip_evnt_ctrl_home_pm;

static int hf_cip_evnt_ctrl_home_mp;

static int hf_cip_evnt_ctrl_home_mm;

static int hf_cip_evnt_ctrl_acks;

static int hf_cip_evnt_extend_format;

static int hf_cip_evnt_sts_reg1_pos;

static int hf_cip_evnt_sts_reg1_neg;

static int hf_cip_evnt_sts_reg2_pos;

static int hf_cip_evnt_sts_reg2_neg;

static int hf_cip_evnt_sts_reg1_posrearm;

static int hf_cip_evnt_sts_reg1_negrearm;

static int hf_cip_evnt_sts_reg2_posrearm;

static int hf_cip_evnt_sts_reg2_negrearm;

static int hf_cip_evnt_sts_marker_pos;

static int hf_cip_evnt_sts_marker_neg;

static int hf_cip_evnt_sts_home_pos;

static int hf_cip_evnt_sts_home_neg;

static int hf_cip_evnt_sts_home_pp;

static int hf_cip_evnt_sts_home_pm;

static int hf_cip_evnt_sts_home_mp;

static int hf_cip_evnt_sts_home_mm;

static int hf_cip_evnt_sts_nfs;

static int hf_cip_evnt_sts_stat;

static int hf_cip_evnt_type;

static int hf_cip_svc_code;

static int hf_cip_svc_sts;

static int hf_cip_svc_set_axis_attr_sts;

static int hf_cip_svc_get_axis_attr_sts;

static int hf_cip_svc_transction;

static int hf_cip_svc_ext_status;

static int hf_cip_svc_data;

static int hf_cip_ptp_grandmaster;

static int hf_cip_axis_alarm;

static int hf_cip_axis_fault;

static int hf_cip_axis_sts_local_ctrl;

static int hf_cip_axis_sts_alarm;

static int hf_cip_axis_sts_dc_bus;

static int hf_cip_axis_sts_pwr_struct;

static int hf_cip_axis_sts_flux_up;

static int hf_cip_axis_sts_tracking;

static int hf_cip_axis_sts_pos_lock;

static int hf_cip_axis_sts_vel_lock;

static int hf_cip_axis_sts_vel_standstill;

static int hf_cip_axis_sts_vel_threshold;

static int hf_cip_axis_sts_vel_limit;

static int hf_cip_axis_sts_acc_limit;

static int hf_cip_axis_sts_dec_limit;

static int hf_cip_axis_sts_torque_threshold;

static int hf_cip_axis_sts_torque_limit;

static int hf_cip_axis_sts_cur_limit;

static int hf_cip_axis_sts_therm_limit;

static int hf_cip_axis_sts_feedback_integ;

static int hf_cip_axis_sts_shutdown;

static int hf_cip_axis_sts_in_process;

static int hf_cip_axis_sts_dc_bus_unload;

static int hf_cip_axis_sts_ac_pwr_loss;

static int hf_cip_axis_sts_pos_cntrl_mode;

static int hf_cip_axis_sts_vel_cntrl_mode;

static int hf_cip_axis_sts_trq_cntrl_mode;

static int hf_cip_axis_status2;

static int hf_cip_axis_sts2_motor;

static int hf_cip_axis_sts2_regenerate;

static int hf_cip_axis_sts2_ride_thru;

static int hf_cip_axis_sts2_ac_line_sync;

static int hf_cip_axis_sts2_bus_volt_lock;

static int hf_cip_axis_sts2_react_pwr_only;

static int hf_cip_axis_sts2_volt_ctrl_mode;

static int hf_cip_axis_sts2_pwr_loss;

static int hf_cip_axis_sts2_ac_volt_sag;

static int hf_cip_axis_sts2_ac_phase_loss;

static int hf_cip_axis_sts2_ac_freq_change;

static int hf_cip_axis_sts2_ac_sync_loss;

static int hf_cip_axis_sts2_single_phase;

static int hf_cip_axis_sts2_bus_volt_limit;

static int hf_cip_axis_sts2_bus_volt_rate_limit;

static int hf_cip_axis_sts2_active_current_rate_limit;

static int hf_cip_axis_sts2_reactive_current_rate_limit;

static int hf_cip_axis_sts2_reactive_pwr_limit;

static int hf_cip_axis_sts2_reactive_pwr_rate_limit;

static int hf_cip_axis_sts2_active_current_limit;

static int hf_cip_axis_sts2_reactive_current_limit;

static int hf_cip_axis_sts2_motor_pwr_limit;

static int hf_cip_axis_sts2_regen_pwr_limit;

static int hf_cip_axis_sts2_convert_therm_limit;

static int hf_cip_cyclic_wrt_data;

static int hf_cip_cyclic_rd_data;

static int hf_cip_cyclic_write_blk;

static int hf_cip_cyclic_read_blk;

static int hf_cip_cyclic_write_sts;

static int hf_cip_cyclic_read_sts;

static int hf_cip_attribute_data;

static int hf_cip_event_checking;

static int hf_cip_event_ack;

static int hf_cip_event_status;

static int hf_cip_event_id;

static int hf_cip_event_pos;

static int hf_cip_event_ts;

static int hf_cip_pos_cmd;

static int hf_cip_pos_cmd_int;

static int hf_cip_vel_cmd;

static int hf_cip_accel_cmd;

static int hf_cip_trq_cmd;

static int hf_cip_pos_trim;

static int hf_cip_vel_trim;

static int hf_cip_accel_trim;

static int hf_cip_trq_trim;

static int hf_cip_act_pos;

static int hf_cip_act_pos_64;

static int hf_cip_act_vel;

static int hf_cip_act_accel;

static int hf_cip_fault_type;

static int hf_cip_fault_sub_code;

static int hf_cip_fault_action;

static int hf_cip_fault_time_stamp;

static int hf_cip_alarm_type;

static int hf_cip_alarm_sub_code;

static int hf_cip_alarm_state;

static int hf_cip_alarm_time_stamp;

static int hf_cip_axis_status;

static int hf_cip_axis_status_mfg;

static int hf_cip_axis_io_status;

static int hf_cip_axis_io_status_mfg;

static int hf_cip_axis_safety_status;

static int hf_cip_axis_safety_status_mfg;

static int hf_cip_axis_safety_state;

static int hf_cip_cmd_data_set;

static int hf_cip_act_data_set;

static int hf_cip_sts_data_set;

static int hf_cip_group_sync;

static int hf_cip_command_control;

static int hf_get_axis_attr_list_attribute_cnt;

static int hf_get_axis_attr_list_attribute_id;

static int hf_get_axis_attr_list_dimension;

static int hf_get_axis_attr_list_element_size;

static int hf_get_axis_attr_list_start_index;

static int hf_get_axis_attr_list_data_elements;

static int hf_set_axis_attr_list_attribute_cnt;

static int hf_set_axis_attr_list_attribute_id;

static int hf_set_axis_attr_list_dimension;

static int hf_set_axis_attr_list_element_size;

static int hf_set_axis_attr_list_start_index;

static int hf_set_axis_attr_list_data_elements;

static int hf_set_cyclic_list_attribute_cnt;

static int hf_set_cyclic_list_attribute_id;

static int hf_set_cyclic_list_read_block_id;

static int hf_set_cyclic_list_attr_sts;

static int hf_var_devce_instance;

static int hf_var_devce_instance_block_size;

static int hf_var_devce_cyclic_block_size;

static int hf_var_devce_cyclic_data_block_size;

static int hf_var_devce_cyclic_rw_block_size;

static int hf_var_devce_event_block_size;

static int hf_var_devce_service_block_size;

static int hf_cip_data;

/* Subtree pointers for the dissection */

static int ett_cipmotion;

static int ett_cont_dev_header;

static int ett_control_status;

static int ett_node_control;

static int ett_node_status;

static int ett_time_data_set;

static int ett_inst_data_header;

static int ett_cyclic_data_block;

static int ett_cyclic_command_data;

static int ett_feedback_mode;

static int ett_connection_configuration_bits;

static int ett_control_mode;

static int ett_feedback_config;

static int ett_command_data_set;

static int ett_actual_data_set;

static int ett_status_data_set;

static int ett_interp_control;

static int ett_cyclic_rd_wt;

static int ett_event;

static int ett_event_check_ctrl;

static int ett_event_check_sts;

static int ett_service;

static int ett_get_axis_attribute;

static int ett_set_axis_attribute;

static int ett_get_axis_attr_list;

static int ett_set_axis_attr_list;

static int ett_set_cyclic_list;

static int ett_group_sync;

static int ett_axis_status_set;

static int ett_command_control;

static int ett_configuration_block;

static expert_field ei_format_rev_conn_pt;

static dissector_handle_t cipmotion_handle;

static dissector_handle_t cipmotion3_handle;

static bool display_full_attribute_data;

/* These are the BITMASKS for the Time Data Set header field */

#define TIME_DATA_SET_TIME_STAMP                0x1

#define TIME_DATA_SET_TIME_OFFSET               0x2

#define TIME_DATA_SET_UPDATE_DIAGNOSTICS        0x4

#define TIME_DATA_SET_TIME_DIAGNOSTICS          0x8

/* These are the BITMASKS for the Command Data Set cyclic field */

#define COMMAND_DATA_SET_POSITION           0x01

#define COMMAND_DATA_SET_VELOCITY           0x02

#define COMMAND_DATA_SET_ACCELERATION       0x04

#define COMMAND_DATA_SET_TORQUE             0x08

#define COMMAND_DATA_SET_UNWIND_CYCLE_COUNT 0x40

#define COMMAND_DATA_SET_POSITION_DISPLACE  0x80

/* These are the BITMASKS for the Actual Data Set cyclic field */

#define ACTUAL_DATA_SET_POSITION        0x01

#define ACTUAL_DATA_SET_VELOCITY        0x02

#define ACTUAL_DATA_SET_ACCELERATION    0x04

#define ACTUAL_DATA_SET_UNWIND_CYCLE_COUNT 0x40

#define ACTUAL_DATA_SET_POSITION_DISPLACE  0x80

/* These are the BITMASKS for the Status Data Set cyclic field */

#define STATUS_DATA_SET_AXIS_FAULT              0x01

#define STATUS_DATA_SET_AXIS_ALARM              0x02

#define STATUS_DATA_SET_AXIS_STATUS             0x04

#define STATUS_DATA_SET_AXIS_IO_STATUS          0x08

#define STATUS_DATA_SET_AXIS_SAFETY             0x10

/* These are the BITMASKS for the Command Control cyclic field */

#define COMMAND_CONTROL_TARGET_UPDATE       0x03

#define COMMAND_CONTROL_POSITION_DATA_TYPE  0x0C

/* These are the VALUES of the connection format header field of the

 * CIP Motion protocol */

#define FORMAT_FIXED_CONTROL_TO_DEVICE      2

#define FORMAT_FIXED_DEVICE_TO_CONTROL      3

#define FORMAT_VAR_CONTROL_TO_DEVICE        6

#define FORMAT_VAR_DEVICE_TO_CONTROL        7

#define FEEDBACK_MODE_BITS             0x0F

#define FEEDBACK_DATA_TYPE_BITS        0x30

/* Translate function to string - connection format values */

static const value_string cip_con_format_vals[] = {

   { FORMAT_FIXED_CONTROL_TO_DEVICE,       "Fixed Controller-to-Device"        },

   { FORMAT_FIXED_DEVICE_TO_CONTROL,       "Fixed Device-to-Controller"        },

   { FORMAT_VAR_CONTROL_TO_DEVICE,         "Variable Controller-to-Device"     },

   { FORMAT_VAR_DEVICE_TO_CONTROL,         "Variable Device-to-Controller"     },

   { 0,                                    NULL                                }

};

/* Translate function to string - motor control mode values */

static const value_string cip_motor_control_vals[] = {

   { 0,    "No Control"            },

   { 1,    "Position Control"      },

   { 2,    "Velocity Control"      },

   { 3,    "Acceleration Control"  },

   { 4,    "Torque Control"        },

   { 0,    NULL                    }

};

/* Translate function to string - feedback mode values */

static const value_string cip_feedback_mode_vals[] = {

   { 0,    "No Feedback"       },

   { 1,    "Master Feedback"   },

   { 2,    "Motor Feedback"    },

   { 3,    "Load Feedback"     },

   { 4,    "Dual Feedback"     },

   { 0,    NULL                }

};

static const value_string cip_feedback_type_vals[] = {

   { 0,   "DINT"               },

   { 1,   "LINT"               },

   { 0,    NULL                }

};

/* Translate function to string - axis control values */

static const value_string cip_axis_control_vals[] =

{

   { 0,    "No Request"               },

   { 1,    "Enable Request"           },

   { 2,    "Disable Request"          },

   { 3,    "Shutdown Request"         },

   { 4,    "Shutdown Reset Request"   },

   { 5,    "Abort Request"            },

   { 6,    "Fault Reset Request"      },

   { 7,    "Stop Process"             },

   { 8,    "Change Actual Pos"        },

   { 9,    "Change Command Pos Ref"   },

   { 127,  "Cancel Request"           },

   { 0,    NULL                       }

};

/* Translate function to string - group sync Status */

static const value_string cip_sync_status_vals[] =

{

   { 0,       "Synchronized"      },

   { 1,       "Not Synchronized"  },

   { 2,       "Wrong Grandmaster" },

   { 3,       "Clock Skew Detected" },

   { 0,       NULL }

};

/* Translate function to string - command target update */

static const value_string cip_interpolation_vals[] = {

   { 0,  "Immediate"         },

   { 1,  "Extrapolate (+1)"  },

   { 2,  "Interpolate (+2)"  },

   { 0,  NULL                }

};

/* These are the VALUES for the Command Position Data Type */

#define POSITION_DATA_LREAL 0x00

#define POSITION_DATA_DINT  0x01

/* Translate function to string - position data type */

static const value_string cip_pos_data_type_vals[] = {

   { POSITION_DATA_LREAL, "LREAL (64-bit Float)"   },

   { POSITION_DATA_DINT,  "DINT (32-bit Integer)"  },

   { 0,                   NULL                     }

};

/* Translate function to string - axis response values */

static const value_string cip_axis_response_vals[] = {

   { 0,    "No Acknowledge"                 },

   { 1,    "Enable Acknowledge"            },

   { 2,    "Disable Acknowledge"           },

   { 3,    "Shutdown Acknowledge"          },

   { 4,    "Shutdown Reset Acknowledge"    },

   { 5,    "Abort Acknowledge"             },

   { 6,    "Fault Reset Acknowledge"       },

   { 7,    "Stop Process Acknowledge"      },

   { 8,    "Change Actual Position Reference Acknowledge" },

   { 9,    "Change Command Position Reference Acknowledge" },

   { 127,  "Cancel Acknowledge"            },

   { 0,    NULL                            }

};

/* Translate function to string - axis state values */

static const value_string cip_axis_state_vals[] = {

   { 0,    "Initializing"      },

   { 1,    "Pre-Charge"        },

   { 2,    "Stopped"           },

   { 3,    "Starting"          },

   { 4,    "Running"           },

   { 5,    "Testing"           },

   { 6,    "Stopping"          },

   { 7,    "Aborting"          },

   { 8,    "Major Faulted"     },

   { 9,    "Start Inhibited"   },

   { 10,   "Shutdown"          },

   { 0,    NULL                }

};

/* Translate function to string - event type values */

static const value_string cip_event_type_vals[] = {

   { 0,    "Registration 1 Positive Edge"  },

   { 1,    "Registration 1 Negative Edge"  },

   { 2,    "Registration 2 Positive Edge"  },

   { 3,    "Registration 2 Negative Edge"  },

   { 4,    "Marker Positive Edge"          },

   { 5,    "Marker Negative Edge"          },

   { 6,    "Home Switch Positive Edge"     },

   { 7,    "Home Switch Negative Edge"     },

   { 8,    "Home Switch Marker ++"         },

   { 9,    "Home Switch Marker +-"         },

   { 10,   "Home Switch Marker -+"         },

   { 11,   "Home Switch Marker --"         },

   { 0,    NULL                            }

};

#define SC_GET_AXIS_ATTRIBUTE_LIST  0x4B

#define SC_SET_AXIS_ATTRIBUTE_LIST  0x4C

#define SC_SET_CYCLIC_WRITE_LIST    0x4D

#define SC_SET_CYCLIC_READ_LIST     0x4E

#define SC_RUN_MOTOR_TEST           0x4F

#define SC_GET_MOTOR_TEST_DATA      0x50

#define SC_RUN_INERTIA_TEST         0x51

#define SC_GET_INERTIA_TEST_DATA    0x52

#define SC_RUN_HOOKUP_TEST          0x53

#define SC_GET_HOOKUP_TEST_DATA     0x54

/* Translate function to string - CIP Service codes */

static const value_string cip_sc_vals[] = {

   GENERIC_SC_LIST

   { SC_GET_AXIS_ATTRIBUTE_LIST,   "Get Axis Attribute List"   },

   { SC_SET_AXIS_ATTRIBUTE_LIST,   "Set Axis Attribute List"   },

   { SC_SET_CYCLIC_WRITE_LIST,     "Set Cyclic Write List"     },

   { SC_SET_CYCLIC_READ_LIST,      "Set Cyclic Read List"      },

   { SC_RUN_MOTOR_TEST,            "Run Motor Test"            },

   { SC_GET_MOTOR_TEST_DATA,       "Get Motor Test Data"       },

   { SC_RUN_INERTIA_TEST,          "Run Inertia Test"          },

   { SC_GET_INERTIA_TEST_DATA,     "Get Inertia Test Data"     },

   { SC_RUN_HOOKUP_TEST,           "Run Hookup Test"           },

   { SC_GET_HOOKUP_TEST_DATA,      "Get Hookup Test Data"      },

   { 0,                            NULL                        }

};

static int dissect_axis_status(packet_info *pinfo _U_, proto_tree *tree, proto_item *item _U_, tvbuff_t *tvb,

   int offset, int total_len _U_)

{

   static int* const bits[] = {

      &hf_cip_axis_sts_local_ctrl,

      &hf_cip_axis_sts_alarm,

      &hf_cip_axis_sts_dc_bus,

      &hf_cip_axis_sts_pwr_struct,

      &hf_cip_axis_sts_flux_up,

      &hf_cip_axis_sts_tracking,

      &hf_cip_axis_sts_pos_lock,

      &hf_cip_axis_sts_vel_lock,

      &hf_cip_axis_sts_vel_standstill,

      &hf_cip_axis_sts_vel_threshold,

      &hf_cip_axis_sts_vel_limit,

      &hf_cip_axis_sts_acc_limit,

      &hf_cip_axis_sts_dec_limit,

      &hf_cip_axis_sts_torque_threshold,

      &hf_cip_axis_sts_torque_limit,

      &hf_cip_axis_sts_cur_limit,

      &hf_cip_axis_sts_therm_limit,

      &hf_cip_axis_sts_feedback_integ,

      &hf_cip_axis_sts_shutdown,

      &hf_cip_axis_sts_in_process,

      &hf_cip_axis_sts_dc_bus_unload,

      &hf_cip_axis_sts_ac_pwr_loss,

      &hf_cip_axis_sts_pos_cntrl_mode,

      &hf_cip_axis_sts_vel_cntrl_mode,

      &hf_cip_axis_sts_trq_cntrl_mode,

      NULL

   };

   proto_tree_add_bitmask(tree, tvb, offset, hf_cip_axis_status, ett_axis_status_set, bits, ENC_LITTLE_ENDIAN);

   return 4;

}

static int dissect_axis_status2(packet_info *pinfo _U_, proto_tree *tree, proto_item *item _U_, tvbuff_t *tvb,

   int offset, int total_len _U_)

{

   static int* const bits[] = {

      &hf_cip_axis_sts2_motor,

      &hf_cip_axis_sts2_regenerate,

      &hf_cip_axis_sts2_ride_thru,

      &hf_cip_axis_sts2_ac_line_sync,

      &hf_cip_axis_sts2_bus_volt_lock,

      &hf_cip_axis_sts2_react_pwr_only,

      &hf_cip_axis_sts2_volt_ctrl_mode,

      &hf_cip_axis_sts2_pwr_loss,

      &hf_cip_axis_sts2_ac_volt_sag,

      &hf_cip_axis_sts2_ac_phase_loss,

      &hf_cip_axis_sts2_ac_freq_change,

      &hf_cip_axis_sts2_ac_sync_loss,

      &hf_cip_axis_sts2_single_phase,

      &hf_cip_axis_sts2_bus_volt_limit,

      &hf_cip_axis_sts2_bus_volt_rate_limit,

      &hf_cip_axis_sts2_active_current_rate_limit,

      &hf_cip_axis_sts2_reactive_current_rate_limit,

      &hf_cip_axis_sts2_reactive_pwr_limit,

      &hf_cip_axis_sts2_reactive_pwr_rate_limit,

      &hf_cip_axis_sts2_active_current_limit,

      &hf_cip_axis_sts2_reactive_current_limit,

      &hf_cip_axis_sts2_motor_pwr_limit,

      &hf_cip_axis_sts2_regen_pwr_limit,

      &hf_cip_axis_sts2_convert_therm_limit,

      NULL

   };

   proto_tree_add_bitmask(tree, tvb, offset, hf_cip_axis_status2, ett_axis_status_set, bits, ENC_LITTLE_ENDIAN);

   return 4;

}

static int dissect_event_checking_control(packet_info *pinfo _U_, proto_tree *tree, proto_item *item _U_, tvbuff_t *tvb,

   int offset, int total_len _U_)

{

   static int* const bits[] = {

      &hf_cip_evnt_ctrl_reg1_pos,

      &hf_cip_evnt_ctrl_reg1_neg,

      &hf_cip_evnt_ctrl_reg2_pos,

      &hf_cip_evnt_ctrl_reg2_neg,

      &hf_cip_evnt_ctrl_reg1_posrearm,

      &hf_cip_evnt_ctrl_reg1_negrearm,

      &hf_cip_evnt_ctrl_reg2_posrearm,

      &hf_cip_evnt_ctrl_reg2_negrearm,

      &hf_cip_evnt_ctrl_marker_pos,

      &hf_cip_evnt_ctrl_marker_neg,

      &hf_cip_evnt_ctrl_home_pos,

      &hf_cip_evnt_ctrl_home_neg,

      &hf_cip_evnt_ctrl_home_pp,

      &hf_cip_evnt_ctrl_home_pm,

      &hf_cip_evnt_ctrl_home_mp,

      &hf_cip_evnt_ctrl_home_mm,

      &hf_cip_evnt_ctrl_acks,

      // The dissector will indicate if the protocol is requesting an extended event format but will not dissect it.

      &hf_cip_evnt_extend_format,

      NULL

   };

   proto_tree_add_bitmask(tree, tvb, offset, hf_cip_event_checking, ett_event_check_ctrl, bits, ENC_LITTLE_ENDIAN);

   return 4;

}

static int dissect_event_checking_status(packet_info *pinfo _U_, proto_tree *tree, proto_item *item _U_, tvbuff_t *tvb,

   int offset, int total_len _U_)

{

   static int* const bits[] = {

      &hf_cip_evnt_sts_reg1_pos,

      &hf_cip_evnt_sts_reg1_neg,

      &hf_cip_evnt_sts_reg2_pos,

      &hf_cip_evnt_sts_reg2_neg,

      &hf_cip_evnt_sts_reg1_posrearm,

      &hf_cip_evnt_sts_reg1_negrearm,

      &hf_cip_evnt_sts_reg2_posrearm,

      &hf_cip_evnt_sts_reg2_negrearm,

      &hf_cip_evnt_sts_marker_pos,

      &hf_cip_evnt_sts_marker_neg,

      &hf_cip_evnt_sts_home_pos,

      &hf_cip_evnt_sts_home_neg,

      &hf_cip_evnt_sts_home_pp,

      &hf_cip_evnt_sts_home_pm,

      &hf_cip_evnt_sts_home_mp,

      &hf_cip_evnt_sts_home_mm,

      &hf_cip_evnt_sts_nfs,

      // The dissector will indicate if the protocol is requesting an extended event format but will not dissect it.

      &hf_cip_evnt_extend_format,

      NULL

   };

   proto_tree_add_bitmask(tree, tvb, offset, hf_cip_event_status, ett_event_check_sts, bits, ENC_LITTLE_ENDIAN);

   return 4;

}

static int dissect_actual_data_set_bits(packet_info *pinfo _U_, proto_tree *tree, proto_item *item _U_, tvbuff_t *tvb,

   int offset, int total_len _U_)

{

   static int* const bits[] = {

      &hf_cip_act_data_pos,

      &hf_cip_act_data_vel,

      &hf_cip_act_data_acc,

      &hf_cip_act_unwind_cycle_count,

      &hf_cip_act_pos_displacement,

      NULL

   };

   proto_tree_add_bitmask(tree, tvb, offset, hf_cip_act_data_set, ett_actual_data_set, bits, ENC_LITTLE_ENDIAN);

   return 1;

}

static int dissect_command_data_set_bits(packet_info *pinfo _U_, proto_tree *tree, proto_item *item _U_, tvbuff_t *tvb,

   int offset, int total_len _U_)

{

   static int* const bits[] = {

      &hf_cip_cmd_data_pos_cmd,

      &hf_cip_cmd_data_vel_cmd,

      &hf_cip_cmd_data_acc_cmd,

      &hf_cip_cmd_data_trq_cmd,

      &hf_cip_cmd_data_unwind_cycle_count,

      &hf_cip_cmd_data_pos_displacement,

      NULL

   };

   proto_tree_add_bitmask(tree, tvb, offset, hf_cip_cmd_data_set, ett_command_data_set, bits, ENC_LITTLE_ENDIAN);

   return 1;

}

static int dissect_command_control(packet_info *pinfo _U_, proto_tree *tree, proto_item *item _U_, tvbuff_t *tvb,

   int offset, int total_len _U_)

{

   static int* const bits[] = {

      &hf_cip_intrp,

      &hf_cip_position_data_type,

      NULL

   };

   proto_tree_add_bitmask(tree, tvb, offset, hf_cip_command_control, ett_command_control, bits, ENC_LITTLE_ENDIAN);

   return 1;

}

static int dissect_status_data_set_bits(packet_info *pinfo _U_, proto_tree *tree, proto_item *item _U_, tvbuff_t *tvb,

   int offset, int total_len _U_)

{

   static int* const bits[] = {

      &hf_cip_sts_flt,

      &hf_cip_sts_alrm,

      &hf_cip_sts_sts,

      &hf_cip_sts_iosts,

      &hf_cip_sts_axis_safety,

      NULL

   };

   proto_tree_add_bitmask(tree, tvb, offset, hf_cip_sts_data_set, ett_status_data_set, bits, ENC_LITTLE_ENDIAN);

   return 1;

}

static int dissect_node_control(packet_info *pinfo _U_, proto_tree *tree, proto_item *item _U_, tvbuff_t *tvb,

   int offset, int total_len _U_)

{

   static int* const bits[] = {

      &hf_cip_node_control_remote,

      &hf_cip_node_control_sync,

      &hf_cip_node_data_valid,

      &hf_cip_node_fault_reset,

      NULL

   };

   proto_tree_add_bitmask(tree, tvb, offset, hf_cip_node_control, ett_node_control, bits, ENC_LITTLE_ENDIAN);

   return 1;

}

static int dissect_node_status(packet_info *pinfo _U_, proto_tree *tree, proto_item *item _U_, tvbuff_t *tvb,

   int offset, int total_len _U_)

{

   static int* const bits[] = {

      &hf_cip_node_control_remote,

      &hf_cip_node_control_sync,

      &hf_cip_node_data_valid,

      &hf_cip_node_device_faulted,

      NULL

   };

   proto_tree_add_bitmask(tree, tvb, offset, hf_cip_node_status, ett_node_status, bits, ENC_LITTLE_ENDIAN);

   return 1;

}

static int dissect_time_data_set(packet_info *pinfo _U_, proto_tree *tree, proto_item *item _U_, tvbuff_t *tvb,

   int offset, int total_len _U_)

{

   static int* const bits[] = {

      &hf_cip_time_data_stamp,

      &hf_cip_time_data_offset,

      &hf_cip_time_data_diag,

      &hf_cip_time_data_time_diag,

      NULL

   };

   proto_tree_add_bitmask(tree, tvb, offset, hf_cip_time_data_set, ett_time_data_set, bits, ENC_LITTLE_ENDIAN);

   return 1;

}

static int dissect_control_status(packet_info *pinfo _U_, proto_tree *tree, proto_item *item _U_, tvbuff_t *tvb,

   int offset, int total_len _U_)

{

   static int* const bits[] = {

      &hf_cip_control_status_complete,

      &hf_cip_control_status_bus_up,

      &hf_cip_control_status_bus_unload,

      &hf_cip_control_status_power_loss,

      NULL

   };

   proto_tree_add_bitmask(tree, tvb, offset, hf_cip_control_status, ett_control_status, bits, ENC_LITTLE_ENDIAN);

   return 1;

}

static int dissect_feedback_mode(packet_info *pinfo _U_, proto_tree *tree, proto_item *item _U_, tvbuff_t *tvb,

   int offset, int total_len _U_)

{

   static int* const bits[] = {

      &hf_cip_feedback_mode,

      &hf_cip_feedback_data_type,

      NULL

   };

   proto_tree_add_bitmask(tree, tvb, offset, hf_cip_feedback, ett_feedback_mode, bits, ENC_LITTLE_ENDIAN);

   return 1;

}

static int dissect_connection_configuration_bits(packet_info* pinfo _U_, proto_tree* tree, proto_item* item _U_, tvbuff_t* tvb,

   int offset, int total_len _U_)

{

   static int* const bits[] = {

      &hf_connection_configuration_bits_power,

      &hf_connection_configuration_bits_safety_bit_valid,

      &hf_connection_configuration_bits_allow_network_safety,

      NULL

   };

   proto_tree_add_bitmask(tree, tvb, offset, hf_connection_configuration_bits, ett_connection_configuration_bits, bits, ENC_LITTLE_ENDIAN);

   return 1;

}

const attribute_info_t cip_motion_attribute_vals[] = {

   { CI_CLS_MOTION, CIP_ATTR_CLASS, 14, -1, "Node Control", cip_dissector_func, NULL, dissect_node_control },

   { CI_CLS_MOTION, CIP_ATTR_CLASS, 15, -1, "Node Status", cip_dissector_func, NULL, dissect_node_status },

   { CI_CLS_MOTION, CIP_ATTR_CLASS, 21, -1, "Controller Update Delay High Limit", cip_usint, &hf_cip_controller_update_delay_high_limit, NULL },

   { CI_CLS_MOTION, CIP_ATTR_CLASS, 22, -1, "Controller Update Delay Low Limit", cip_usint, &hf_cip_controller_update_delay_low_limit, NULL },

   { CI_CLS_MOTION, CIP_ATTR_CLASS, 29, -1, "Sync Threshold", cip_udint, &hf_cip_sync_threshold, NULL },

   { CI_CLS_MOTION, CIP_ATTR_CLASS, 31, -1, "Time Data Set", cip_dissector_func, NULL, dissect_time_data_set },

   { CI_CLS_MOTION, CIP_ATTR_CLASS, 34, -1, "Drive Power Structure Class ID", cip_udint, &hf_configuration_block_drive_power_struct_id, NULL },

   { CI_CLS_MOTION, CIP_ATTR_CLASS, 35, -1, "Step Threshold", cip_udint, &hf_cip_step_threshold, NULL },

   { CI_CLS_MOTION, CIP_ATTR_CLASS, 36, -1, "Connection Configuration Bits", cip_dissector_func, NULL, dissect_connection_configuration_bits },

   { CI_CLS_MOTION, CIP_ATTR_INSTANCE, 40, -1, "Control Mode", cip_usint, &hf_cip_motor_cntrl, NULL },

   { CI_CLS_MOTION, CIP_ATTR_INSTANCE, 41, -1, "Control Method", cip_usint, &hf_cip_control_method, NULL },

   { CI_CLS_MOTION, CIP_ATTR_INSTANCE, 42, -1, "Feedback Mode", cip_dissector_func, NULL, dissect_feedback_mode },

   { CI_CLS_MOTION, CIP_ATTR_INSTANCE, 44, -1, "Feedback Unit Ratio", cip_real, &hf_cip_feedback_unit_ratio, NULL },

   { CI_CLS_MOTION, CIP_ATTR_INSTANCE, 60, -1, "Event Checking Control", cip_dissector_func, NULL, dissect_event_checking_control },

   { CI_CLS_MOTION, CIP_ATTR_INSTANCE, 61, -1, "Event Checking Status", cip_dissector_func, NULL, dissect_event_checking_status },

   { CI_CLS_MOTION, CIP_ATTR_INSTANCE, 89, -1, "Control Status", cip_dissector_func, NULL, dissect_control_status },

   { CI_CLS_MOTION, CIP_ATTR_INSTANCE, 90, -1, "Actual Data Set", cip_dissector_func, NULL, dissect_actual_data_set_bits },

   { CI_CLS_MOTION, CIP_ATTR_INSTANCE, 91, -1, "Command Data Set", cip_dissector_func, NULL, dissect_command_data_set_bits },

   { CI_CLS_MOTION, CIP_ATTR_INSTANCE, 92, -1, "Command Control", cip_dissector_func, NULL, dissect_command_control },

   { CI_CLS_MOTION, CIP_ATTR_INSTANCE, 94, -1, "Status Data Set", cip_dissector_func, NULL, dissect_status_data_set_bits },

   { CI_CLS_MOTION, CIP_ATTR_INSTANCE, 431, -1, "Position Trim", cip_dint, &hf_cip_pos_trim, NULL },

   { CI_CLS_MOTION, CIP_ATTR_INSTANCE, 451, -1, "Velocity Trim", cip_real, &hf_cip_vel_trim, NULL },

   { CI_CLS_MOTION, CIP_ATTR_INSTANCE, 470, -1, "Velocity Threshold", cip_real, &hf_cip_velocity_threshold, NULL },

   { CI_CLS_MOTION, CIP_ATTR_INSTANCE, 471, -1, "Velocity Lock Tolerance", cip_real, &hf_cip_velocity_lock_tolerance, NULL },

   { CI_CLS_MOTION, CIP_ATTR_INSTANCE, 472, -1, "Velocity Standstill Window", cip_real, &hf_cip_velocity_standstill_window, NULL },

   { CI_CLS_MOTION, CIP_ATTR_INSTANCE, 481, -1, "Acceleration Trim", cip_real, &hf_cip_accel_trim, NULL },

   { CI_CLS_MOTION, CIP_ATTR_INSTANCE, 491, -1, "Torque Trim", cip_real, &hf_cip_trq_trim, NULL },

   { CI_CLS_MOTION, CIP_ATTR_INSTANCE, 590, -1, "Proving Configuration", cip_usint, &hf_cip_proving_configuration, NULL },

   { CI_CLS_MOTION, CIP_ATTR_INSTANCE, 591, -1, "Torque Prove Current", cip_real, &hf_cip_torque_prove_current, NULL },

   { CI_CLS_MOTION, CIP_ATTR_INSTANCE, 592, -1, "Brake Test Torque", cip_real, &hf_cip_brake_test_torque, NULL },

   { CI_CLS_MOTION, CIP_ATTR_INSTANCE, 608, -1, "Zero Speed", cip_real, &hf_cip_zero_speed, NULL },

   { CI_CLS_MOTION, CIP_ATTR_INSTANCE, 609, -1, "Zero Speed Time", cip_real, &hf_cip_zero_speed_time, NULL },

   { CI_CLS_MOTION, CIP_ATTR_INSTANCE, 620, -1, "DC Bus Voltage", cip_real, &hf_cip_dc_bus_voltage, NULL },

   { CI_CLS_MOTION, CIP_ATTR_INSTANCE, 624, -1, "Bus Regulator Action", cip_usint, &hf_cip_bus_regulator_action, NULL },

   { CI_CLS_MOTION, CIP_ATTR_INSTANCE, 636, -1, "Inverter Capacity", cip_real, &hf_cip_inverter_capacity, NULL },

   { CI_CLS_MOTION, CIP_ATTR_INSTANCE, 651, -1, "Axis Status", cip_dissector_func, NULL, dissect_axis_status },

   { CI_CLS_MOTION, CIP_ATTR_INSTANCE, 701, -1, "Converter Thermal Overload User Limit", cip_real, &hf_cip_converter_thermal_overload_user_limit, NULL },

   { CI_CLS_MOTION, CIP_ATTR_INSTANCE, 705, -1, "Bus Undervoltage User Limit", cip_real, &hf_cip_bus_undervoltage_user_limit, NULL },

   { CI_CLS_MOTION, CIP_ATTR_INSTANCE, 740, -1, "Axis Status 2", cip_dissector_func, NULL, dissect_axis_status2 },

   { CI_CLS_MOTION, CIP_ATTR_INSTANCE, 1329, -1, "Rotary Motor Poles", cip_uint, &hf_cip_rotary_motor_poles, NULL },

   { CI_CLS_MOTION, CIP_ATTR_INSTANCE, 1330, -1, "Rotary Motor Inertia", cip_real, &hf_cip_rotary_motor_inertia, NULL },

   { CI_CLS_MOTION, CIP_ATTR_INSTANCE, 1332, -1, "Rotary Motor Max Speed", cip_real, &hf_cip_rotary_motor_max_speed, NULL },

};

/*

 * Function name: dissect_cmd_data_set

 *

 * Purpose: Dissect the "Cyclic Command Data" of a Controller-to-Device format message

 *

 * Based on the Command Data Set bits of the Cyclic Command Data Block header, display

 * any of those command values.

 *

 * Returns: The number of bytes in the cyclic data used

 */

static uint32_t

dissect_cmd_data_set(uint32_t cmd_data_set, proto_tree* parent_tree, tvbuff_t* tvb, uint32_t offset, bool lreal_pos)

{

   // If no Command Data Set bits are set, then we don't need to display any additional data.

   if (cmd_data_set == 0)

   {

      return 0;

   }

   uint32_t bytes_used = 0;

   proto_item* item;

   proto_tree* tree = proto_tree_add_subtree(parent_tree, tvb, offset, 0, ett_cyclic_command_data, &item, "Cyclic Command Data");

   /* The order of these if statements is VERY important, this is the order the values will

    * appear in the cyclic data */

   if ( (cmd_data_set & COMMAND_DATA_SET_POSITION) == COMMAND_DATA_SET_POSITION )

   {

      /* Based on the Command Position Data Type value embedded in the Command Control

      * header field the position is either 64-bit floating or 32-bit integer */

      if (lreal_pos)

      {

         /* Display the command data set position command value */

         proto_tree_add_item(tree, hf_cip_pos_cmd, tvb, offset + bytes_used, 8, ENC_LITTLE_ENDIAN );

         bytes_used += 8;

      }

      else

      {

         /* Display the command data set position command value */

         proto_tree_add_item(tree, hf_cip_pos_cmd_int, tvb, offset + bytes_used, 4, ENC_LITTLE_ENDIAN );

         bytes_used += 4;

      }

   }

   if ( (cmd_data_set & COMMAND_DATA_SET_VELOCITY) == COMMAND_DATA_SET_VELOCITY )

   {

      /* Display the command data set velocity command value */

      proto_tree_add_item(tree, hf_cip_vel_cmd, tvb, offset + bytes_used, 4, ENC_LITTLE_ENDIAN );

      bytes_used += 4;

   }

   if ( (cmd_data_set & COMMAND_DATA_SET_ACCELERATION) == COMMAND_DATA_SET_ACCELERATION )

   {

      /* Display the command data set acceleration command value */

      proto_tree_add_item(tree, hf_cip_accel_cmd, tvb, offset + bytes_used, 4, ENC_LITTLE_ENDIAN );

      bytes_used += 4;

   }

   if ( (cmd_data_set & COMMAND_DATA_SET_TORQUE) == COMMAND_DATA_SET_TORQUE )

   {

      /* Display the command data set torque command value */

      proto_tree_add_item(tree, hf_cip_trq_cmd, tvb, offset + bytes_used, 4, ENC_LITTLE_ENDIAN );

      bytes_used += 4;

   }

   proto_item_set_len(item, bytes_used);

   return bytes_used;

}

/*

 * Function name: dissect_act_data_set

 *

 * Purpose: Dissect the "Cyclic Actual Data" of a Device-to-Controller format message

 *

 * Based on the Actual Data Set bits of the "Cyclic Actual Data Block" header, display

 * any of those feedback values.

 *

 * Returns: The number of bytes in the cyclic data used

 */

static uint32_t

dissect_act_data_set(uint32_t act_data_set, proto_tree* parent_tree, tvbuff_t* tvb, uint32_t offset, uint8_t feedback_mode)

{

   // If no Actual Data Set bits are set, then we don't need to display any additional data.

   if (act_data_set == 0)

   {

      return 0;

   }

   uint32_t bytes_used = 0;

   proto_item* item;

   proto_tree* tree = proto_tree_add_subtree(parent_tree, tvb, offset, 0, ett_cyclic_command_data, &item, "Cyclic Actual Data");

   /* The order of these if statements is VERY important, this is the order the values will

   * appear in the cyclic data */

   if ( (act_data_set & ACTUAL_DATA_SET_POSITION) == ACTUAL_DATA_SET_POSITION )

   {

      /* Display the actual data set position feedback value in either 32 or 64 bit */

      bool is_64_bit_position = (feedback_mode & FEEDBACK_DATA_TYPE_BITS) == 0x10;

      if (is_64_bit_position)

      {

         proto_tree_add_item(tree, hf_cip_act_pos_64, tvb, offset + bytes_used, 8, ENC_LITTLE_ENDIAN);

         bytes_used += 8;

      }

      else

      {

         proto_tree_add_item(tree, hf_cip_act_pos, tvb, offset + bytes_used, 4, ENC_LITTLE_ENDIAN);

         bytes_used += 4;

      }

   }

   if ( (act_data_set & ACTUAL_DATA_SET_VELOCITY) == ACTUAL_DATA_SET_VELOCITY )

   {

      /* Display the actual data set velocity feedback value */

      proto_tree_add_item(tree, hf_cip_act_vel, tvb, offset + bytes_used, 4, ENC_LITTLE_ENDIAN );

      bytes_used += 4;

   }

   if ( (act_data_set & ACTUAL_DATA_SET_ACCELERATION) == ACTUAL_DATA_SET_ACCELERATION )

   {

      /* Display the actual data set acceleration feedback value */

      proto_tree_add_item(tree, hf_cip_act_accel, tvb, offset + bytes_used, 4, ENC_LITTLE_ENDIAN );

      bytes_used += 4;

   }

   proto_item_set_len(item, bytes_used);

   return bytes_used;

}

/*

 * Function name: dissect_status_data_set

 *

 * Purpose: Dissect the "Cyclic Status Data" of a Device-to-Controller format message

 *

 * Based on the Status Data Set bits of the "Cyclic Actual Data Block" header, display

 * any of those status values.

 *

 * Returns: The number of bytes in the cyclic data used

 */

static uint32_t

dissect_status_data_set(uint32_t status_data_set, proto_tree* parent_tree, tvbuff_t* tvb, uint32_t offset)

{