public static void write(sensor_msgs.msg.Image data, Halodi.CDR.CDRSerializer cdr)
        {
            std_msgs.msg.HeaderPubSubType.write(data.header, cdr);

            cdr.write_type_4(data.height);

            cdr.write_type_4(data.width);

            cdr.write_type_d(data.encoding);

            cdr.write_type_9(data.is_bigendian);

            cdr.write_type_4(data.step);

            if (data.data == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int data_length = data.data.Count;
                cdr.write_type_2(data_length);
                for (int i0 = 0; i0 < data_length; i0++)
                {
                    cdr.write_type_9(data.data[i0]);
                }
            }
        }
Beispiel #2
0
        public static void write(visualization_msgs.msg.InteractiveMarkerControl data, Halodi.CDR.CDRSerializer cdr)
        {
            cdr.write_type_d(data.name);

            geometry_msgs.msg.QuaternionPubSubType.write(data.orientation, cdr);

            cdr.write_type_9(data.orientation_mode);

            cdr.write_type_9(data.interaction_mode);

            cdr.write_type_7(data.always_visible);

            if (data.markers == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int markers_length = data.markers.Count;
                cdr.write_type_2(markers_length);
                for (int i0 = 0; i0 < markers_length; i0++)
                {
                    visualization_msgs.msg.MarkerPubSubType.write(data.markers[i0], cdr);
                }
            }
            cdr.write_type_7(data.independent_marker_orientation);

            cdr.write_type_d(data.description);
        }
        public static void write(halodi_msgs.msg.MotorStatus data, Halodi.CDR.CDRSerializer cdr)
        {
            cdr.write_type_9(data.status_level);

            if (data.joints == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int joints_length = data.joints.Count;
                cdr.write_type_2(joints_length);
                for (int i0 = 0; i0 < joints_length; i0++)
                {
                    halodi_msgs.msg.JointNamePubSubType.write(data.joints[i0], cdr);
                }
            }
            cdr.write_type_9(data.motor_id);

            cdr.write_type_7(data.sto_enabled);

            cdr.write_type_7(data.over_temperature);

            cdr.write_type_4(data.motor_serial_number);

            cdr.write_type_4(data.driver_serial_number);

            cdr.write_type_7(data.motor_initialized);

            cdr.write_type_6(data.motor_temperature);

            cdr.write_type_6(data.driver_temperature);

            cdr.write_type_9(data.motor_error);
        }
        public static void write(sensor_msgs.msg.JoyFeedback data, Halodi.CDR.CDRSerializer cdr)
        {
            cdr.write_type_9(data.type);

            cdr.write_type_9(data.id);

            cdr.write_type_5(data.intensity);
        }
        public static void write(sensor_msgs.msg.BatteryState data, Halodi.CDR.CDRSerializer cdr)
        {
            std_msgs.msg.HeaderPubSubType.write(data.header, cdr);

            cdr.write_type_5(data.voltage);

            cdr.write_type_5(data.temperature);

            cdr.write_type_5(data.current);

            cdr.write_type_5(data.charge);

            cdr.write_type_5(data.capacity);

            cdr.write_type_5(data.design_capacity);

            cdr.write_type_5(data.percentage);

            cdr.write_type_9(data.power_supply_status);

            cdr.write_type_9(data.power_supply_health);

            cdr.write_type_9(data.power_supply_technology);

            cdr.write_type_7(data.present);

            if (data.cell_voltage == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int cell_voltage_length = data.cell_voltage.Count;
                cdr.write_type_2(cell_voltage_length);
                for (int i0 = 0; i0 < cell_voltage_length; i0++)
                {
                    cdr.write_type_5(data.cell_voltage[i0]);
                }
            }
            if (data.cell_temperature == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int cell_temperature_length = data.cell_temperature.Count;
                cdr.write_type_2(cell_temperature_length);
                for (int i0 = 0; i0 < cell_temperature_length; i0++)
                {
                    cdr.write_type_5(data.cell_temperature[i0]);
                }
            }
            cdr.write_type_d(data.location);

            cdr.write_type_d(data.serial_number);
        }
 public static void write(unique_identifier_msgs.msg.UUID data, Halodi.CDR.CDRSerializer cdr)
 {
     for (int i0 = 0; i0 < 16; ++i0)
     {
         cdr.write_type_9(data.uuid[i0]);
     }
 }
        public static void write(actionlib_msgs.msg.GoalStatus data, Halodi.CDR.CDRSerializer cdr)
        {
            actionlib_msgs.msg.GoalIDPubSubType.write(data.goal_id, cdr);

            cdr.write_type_9(data.status);

            cdr.write_type_d(data.text);
        }
Beispiel #8
0
        public static void write(sensor_msgs.msg.PointField data, Halodi.CDR.CDRSerializer cdr)
        {
            cdr.write_type_d(data.name);

            cdr.write_type_4(data.offset);

            cdr.write_type_9(data.datatype);

            cdr.write_type_4(data.count);
        }
Beispiel #9
0
        public static void write(halodi_msgs.msg.BatteryStatus data, Halodi.CDR.CDRSerializer cdr)
        {
            cdr.write_type_9(data.battery_status_level);

            cdr.write_type_6(data.battery_voltage);

            cdr.write_type_6(data.low_battery_voltage);

            cdr.write_type_6(data.shutdown_battery_voltage);
        }
Beispiel #10
0
        public static void write(ocs2_ros2_msgs.msg.MpcObservation data, Halodi.CDR.CDRSerializer cdr)
        {
            cdr.write_type_5(data.time);

            ocs2_ros2_msgs.msg.MpcStatePubSubType.write(data.state, cdr);

            ocs2_ros2_msgs.msg.MpcInputPubSubType.write(data.input, cdr);

            cdr.write_type_9(data.mode);
        }
        public static void write(halodi_msgs.msg.JointStatus data, Halodi.CDR.CDRSerializer cdr)
        {
            halodi_msgs.msg.JointNamePubSubType.write(data.joint, cdr);

            cdr.write_type_9(data.status_level);

            cdr.write_type_7(data.critical_for_balance);

            cdr.write_type_7(data.output_encoder_fault);

            cdr.write_type_7(data.tension_ropes);
        }
Beispiel #12
0
        public static void write(visualization_msgs.msg.MenuEntry data, Halodi.CDR.CDRSerializer cdr)
        {
            cdr.write_type_4(data.id);

            cdr.write_type_4(data.parent_id);

            cdr.write_type_d(data.title);

            cdr.write_type_d(data.command);

            cdr.write_type_9(data.command_type);
        }
        public static void write(visualization_msgs.msg.ImageMarker data, Halodi.CDR.CDRSerializer cdr)
        {
            std_msgs.msg.HeaderPubSubType.write(data.header, cdr);

            cdr.write_type_d(data.ns);

            cdr.write_type_2(data.id);

            cdr.write_type_2(data.type);

            cdr.write_type_2(data.action);

            geometry_msgs.msg.PointPubSubType.write(data.position, cdr);

            cdr.write_type_5(data.scale);

            std_msgs.msg.ColorRGBAPubSubType.write(data.outline_color, cdr);

            cdr.write_type_9(data.filled);

            std_msgs.msg.ColorRGBAPubSubType.write(data.fill_color, cdr);

            builtin_interfaces.msg.DurationPubSubType.write(data.lifetime, cdr);

            if (data.points == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int points_length = data.points.Count;
                cdr.write_type_2(points_length);
                for (int i0 = 0; i0 < points_length; i0++)
                {
                    geometry_msgs.msg.PointPubSubType.write(data.points[i0], cdr);
                }
            }
            if (data.outline_colors == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int outline_colors_length = data.outline_colors.Count;
                cdr.write_type_2(outline_colors_length);
                for (int i0 = 0; i0 < outline_colors_length; i0++)
                {
                    std_msgs.msg.ColorRGBAPubSubType.write(data.outline_colors[i0], cdr);
                }
            }
        }
Beispiel #14
0
        public static void write(sensor_msgs.msg.Range data, Halodi.CDR.CDRSerializer cdr)
        {
            std_msgs.msg.HeaderPubSubType.write(data.header, cdr);

            cdr.write_type_9(data.radiation_type);

            cdr.write_type_5(data.field_of_view);

            cdr.write_type_5(data.min_range);

            cdr.write_type_5(data.max_range);

            cdr.write_type_5(data.range);
        }
Beispiel #15
0
        public static void write(halodi_msgs.msg.RobotStatus data, Halodi.CDR.CDRSerializer cdr)
        {
            std_msgs.msg.HeaderPubSubType.write(data.header, cdr);

            cdr.write_type_9(data.robot_status_level);

            halodi_msgs.msg.BatteryStatusPubSubType.write(data.battery_status, cdr);

            cdr.write_type_7(data.backpack_estop_enabled);

            cdr.write_type_7(data.wireless_estop_enabled);

            cdr.write_type_7(data.over_temperature);

            cdr.write_type_7(data.driving_disabled);

            if (data.joint_status == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int joint_status_length = data.joint_status.Count;
                cdr.write_type_2(joint_status_length);
                for (int i0 = 0; i0 < joint_status_length; i0++)
                {
                    halodi_msgs.msg.JointStatusPubSubType.write(data.joint_status[i0], cdr);
                }
            }
            if (data.motor_status == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int motor_status_length = data.motor_status.Count;
                cdr.write_type_2(motor_status_length);
                for (int i0 = 0; i0 < motor_status_length; i0++)
                {
                    halodi_msgs.msg.MotorStatusPubSubType.write(data.motor_status[i0], cdr);
                }
            }
            cdr.write_type_4(data.runtime_since_start);

            cdr.write_type_4(data.total_runtime);

            cdr.write_type_4(data.numberOfRuns);
        }
Beispiel #16
0
        public static void write(visualization_msgs.msg.InteractiveMarkerUpdate data, Halodi.CDR.CDRSerializer cdr)
        {
            cdr.write_type_d(data.server_id);

            cdr.write_type_12(data.seq_num);

            cdr.write_type_9(data.type);

            if (data.markers == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int markers_length = data.markers.Count;
                cdr.write_type_2(markers_length);
                for (int i0 = 0; i0 < markers_length; i0++)
                {
                    visualization_msgs.msg.InteractiveMarkerPubSubType.write(data.markers[i0], cdr);
                }
            }
            if (data.poses == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int poses_length = data.poses.Count;
                cdr.write_type_2(poses_length);
                for (int i0 = 0; i0 < poses_length; i0++)
                {
                    visualization_msgs.msg.InteractiveMarkerPosePubSubType.write(data.poses[i0], cdr);
                }
            }
            if (data.erases == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int erases_length = data.erases.Count;
                cdr.write_type_2(erases_length);
                for (int i0 = 0; i0 < erases_length; i0++)
                {
                    cdr.write_type_d(data.erases[i0]);
                }
            }
        }
Beispiel #17
0
        public static void write(rcl_interfaces.msg.Log data, Halodi.CDR.CDRSerializer cdr)
        {
            builtin_interfaces.msg.TimePubSubType.write(data.stamp, cdr);

            cdr.write_type_9(data.level);

            cdr.write_type_d(data.name);

            cdr.write_type_d(data.msg);

            cdr.write_type_d(data.file);

            cdr.write_type_d(data.function);

            cdr.write_type_4(data.line);
        }
Beispiel #18
0
        public static void write(std_msgs.msg.Int8MultiArray data, Halodi.CDR.CDRSerializer cdr)
        {
            std_msgs.msg.MultiArrayLayoutPubSubType.write(data.layout, cdr);

            if (data.data == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int data_length = data.data.Count;
                cdr.write_type_2(data_length);
                for (int i0 = 0; i0 < data_length; i0++)
                {
                    cdr.write_type_9(data.data[i0]);
                }
            }
        }
        public static void write(shape_msgs.msg.SolidPrimitive data, Halodi.CDR.CDRSerializer cdr)
        {
            cdr.write_type_9(data.type);

            if (data.dimensions == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int dimensions_length = data.dimensions.Count;
                cdr.write_type_2(dimensions_length);
                for (int i0 = 0; i0 < dimensions_length; i0++)
                {
                    cdr.write_type_6(data.dimensions[i0]);
                }
            }
        }
Beispiel #20
0
        public static void write(sensor_msgs.msg.NavSatFix data, Halodi.CDR.CDRSerializer cdr)
        {
            std_msgs.msg.HeaderPubSubType.write(data.header, cdr);

            sensor_msgs.msg.NavSatStatusPubSubType.write(data.status, cdr);

            cdr.write_type_6(data.latitude);

            cdr.write_type_6(data.longitude);

            cdr.write_type_6(data.altitude);

            for (int i0 = 0; i0 < 9; ++i0)
            {
                cdr.write_type_6(data.position_covariance[i0]);
            }

            cdr.write_type_9(data.position_covariance_type);
        }
        public static void write(sensor_msgs.msg.PointCloud2 data, Halodi.CDR.CDRSerializer cdr)
        {
            std_msgs.msg.HeaderPubSubType.write(data.header, cdr);

            cdr.write_type_4(data.height);

            cdr.write_type_4(data.width);

            if (data.fields == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int fields_length = data.fields.Count;
                cdr.write_type_2(fields_length);
                for (int i0 = 0; i0 < fields_length; i0++)
                {
                    sensor_msgs.msg.PointFieldPubSubType.write(data.fields[i0], cdr);
                }
            }
            cdr.write_type_7(data.is_bigendian);

            cdr.write_type_4(data.point_step);

            cdr.write_type_4(data.row_step);

            if (data.data == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int data_length = data.data.Count;
                cdr.write_type_2(data_length);
                for (int i0 = 0; i0 < data_length; i0++)
                {
                    cdr.write_type_9(data.data[i0]);
                }
            }
            cdr.write_type_7(data.is_dense);
        }
        public static void write(sensor_msgs.msg.CompressedImage data, Halodi.CDR.CDRSerializer cdr)
        {
            std_msgs.msg.HeaderPubSubType.write(data.header, cdr);

            cdr.write_type_d(data.format);

            if (data.data == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int data_length = data.data.Count;
                cdr.write_type_2(data_length);
                for (int i0 = 0; i0 < data_length; i0++)
                {
                    cdr.write_type_9(data.data[i0]);
                }
            }
        }
Beispiel #23
0
        public static void write(nav_msgs.msg.OccupancyGrid data, Halodi.CDR.CDRSerializer cdr)
        {
            std_msgs.msg.HeaderPubSubType.write(data.header, cdr);

            nav_msgs.msg.MapMetaDataPubSubType.write(data.info, cdr);

            if (data.data == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int data_length = data.data.Count;
                cdr.write_type_2(data_length);
                for (int i0 = 0; i0 < data_length; i0++)
                {
                    cdr.write_type_9(data.data[i0]);
                }
            }
        }
        public static void write(visualization_msgs.msg.InteractiveMarkerFeedback data, Halodi.CDR.CDRSerializer cdr)
        {
            std_msgs.msg.HeaderPubSubType.write(data.header, cdr);

            cdr.write_type_d(data.client_id);

            cdr.write_type_d(data.marker_name);

            cdr.write_type_d(data.control_name);

            cdr.write_type_9(data.event_type);

            geometry_msgs.msg.PosePubSubType.write(data.pose, cdr);

            cdr.write_type_4(data.menu_entry_id);

            geometry_msgs.msg.PointPubSubType.write(data.mouse_point, cdr);

            cdr.write_type_7(data.mouse_point_valid);
        }
        public static void write(rcl_interfaces.msg.ParameterDescriptor data, Halodi.CDR.CDRSerializer cdr)
        {
            cdr.write_type_d(data.name);

            cdr.write_type_9(data.type);

            cdr.write_type_d(data.description);

            cdr.write_type_d(data.additional_constraints);

            cdr.write_type_7(data.read_only);

            if (data.floating_point_range == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int floating_point_range_length = data.floating_point_range.Count;
                cdr.write_type_2(floating_point_range_length);
                for (int i0 = 0; i0 < floating_point_range_length; i0++)
                {
                    rcl_interfaces.msg.FloatingPointRangePubSubType.write(data.floating_point_range[i0], cdr);
                }
            }
            if (data.integer_range == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int integer_range_length = data.integer_range.Count;
                cdr.write_type_2(integer_range_length);
                for (int i0 = 0; i0 < integer_range_length; i0++)
                {
                    rcl_interfaces.msg.IntegerRangePubSubType.write(data.integer_range[i0], cdr);
                }
            }
        }
        public static void write(diagnostic_msgs.msg.DiagnosticStatus data, Halodi.CDR.CDRSerializer cdr)
        {
            cdr.write_type_9(data.level);

            cdr.write_type_d(data.name);

            cdr.write_type_d(data.message);

            cdr.write_type_d(data.hardware_id);

            if (data.values == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int values_length = data.values.Count;
                cdr.write_type_2(values_length);
                for (int i0 = 0; i0 < values_length; i0++)
                {
                    diagnostic_msgs.msg.KeyValuePubSubType.write(data.values[i0], cdr);
                }
            }
        }
        public static void write(sensor_msgs.msg.NavSatStatus data, Halodi.CDR.CDRSerializer cdr)
        {
            cdr.write_type_9(data.status);

            cdr.write_type_3(data.service);
        }
Beispiel #28
0
 public static void write(std_msgs.msg.Int8 data, Halodi.CDR.CDRSerializer cdr)
 {
     cdr.write_type_9(data.data);
 }
Beispiel #29
0
        public static void write(halodi_msgs.msg.WholeBodyState data, Halodi.CDR.CDRSerializer cdr)
        {
            std_msgs.msg.HeaderPubSubType.write(data.header, cdr);

            cdr.write_type_2(data.last_received_sequence_id);

            cdr.write_type_7(data.accepts_commands);

            cdr.write_type_d(data.controller_state);

            halodi_msgs.msg.BalanceModePubSubType.write(data.current_balance_mode, cdr);

            cdr.write_type_9(data.robot_status);

            geometry_msgs.msg.PosePubSubType.write(data.pose, cdr);

            geometry_msgs.msg.Vector3PubSubType.write(data.angular_velocity, cdr);

            geometry_msgs.msg.Vector3PubSubType.write(data.linear_velocity, cdr);

            geometry_msgs.msg.PosePubSubType.write(data.map_pose, cdr);

            if (data.imu_measurements == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int imu_measurements_length = data.imu_measurements.Count;
                cdr.write_type_2(imu_measurements_length);
                for (int i0 = 0; i0 < imu_measurements_length; i0++)
                {
                    halodi_msgs.msg.ImuMeasurementPubSubType.write(data.imu_measurements[i0], cdr);
                }
            }
            if (data.joint_states == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int joint_states_length = data.joint_states.Count;
                cdr.write_type_2(joint_states_length);
                for (int i0 = 0; i0 < joint_states_length; i0++)
                {
                    halodi_msgs.msg.JointMeasurementPubSubType.write(data.joint_states[i0], cdr);
                }
            }
            if (data.taskspace_feedback == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int taskspace_feedback_length = data.taskspace_feedback.Count;
                cdr.write_type_2(taskspace_feedback_length);
                for (int i0 = 0; i0 < taskspace_feedback_length; i0++)
                {
                    halodi_msgs.msg.TaskSpaceFeedbackPubSubType.write(data.taskspace_feedback[i0], cdr);
                }
            }
        }
Beispiel #30
0
        public static void write(action_msgs.msg.GoalStatus data, Halodi.CDR.CDRSerializer cdr)
        {
            action_msgs.msg.GoalInfoPubSubType.write(data.goal_info, cdr);

            cdr.write_type_9(data.status);
        }