sensor_msgs_msg

type BatteryState struct {
	Header                std_msgs_msg.Header `yaml:"header"`
	Voltage               float32             `yaml:"voltage"`                 // Voltage in Volts (Mandatory)
	Temperature           float32             `yaml:"temperature"`             // Temperature in Degrees Celsius (If unmeasured NaN)
	Current               float32             `yaml:"current"`                 // Negative when discharging (A)  (If unmeasured NaN)
	Charge                float32             `yaml:"charge"`                  // Current charge in Ah  (If unmeasured NaN)
	Capacity              float32             `yaml:"capacity"`                // Capacity in Ah (last full capacity)  (If unmeasured NaN)
	DesignCapacity        float32             `yaml:"design_capacity"`         // Capacity in Ah (design capacity)  (If unmeasured NaN)
	Percentage            float32             `yaml:"percentage"`              // Charge percentage on 0 to 1 range  (If unmeasured NaN)
	PowerSupplyStatus     uint8               `yaml:"power_supply_status"`     // The charging status as reported. Values defined above
	PowerSupplyHealth     uint8               `yaml:"power_supply_health"`     // The battery health metric. Values defined above
	PowerSupplyTechnology uint8               `yaml:"power_supply_technology"` // The battery chemistry. Values defined above
	Present               bool                `yaml:"present"`                 // True if the battery is present
	CellVoltage           []float32           `yaml:"cell_voltage"`            // An array of individual cell voltages for each cell in the pack
	CellTemperature       []float32           `yaml:"cell_temperature"`        // An array of individual cell temperatures for each cell in the pack. If individual voltages unknown but number of cells known set each to NaN
	Location              string              `yaml:"location"`                // The location into which the battery is inserted. (slot number or plug). If individual voltages unknown but number of cells known set each to NaNIf individual temperatures unknown but number of cells known set each to NaN
	SerialNumber          string              `yaml:"serial_number"`           // The best approximation of the battery serial number. If individual voltages unknown but number of cells known set each to NaNIf individual temperatures unknown but number of cells known set each to NaN
}

type CBatteryState = C.sensor_msgs__msg__BatteryState

type CBatteryState__Sequence = C.sensor_msgs__msg__BatteryState__Sequence

type CCameraInfo = C.sensor_msgs__msg__CameraInfo

type CCameraInfo__Sequence = C.sensor_msgs__msg__CameraInfo__Sequence

type CChannelFloat32 = C.sensor_msgs__msg__ChannelFloat32

type CChannelFloat32__Sequence = C.sensor_msgs__msg__ChannelFloat32__Sequence

type CCompressedImage = C.sensor_msgs__msg__CompressedImage

type CCompressedImage__Sequence = C.sensor_msgs__msg__CompressedImage__Sequence

type CFluidPressure = C.sensor_msgs__msg__FluidPressure

type CFluidPressure__Sequence = C.sensor_msgs__msg__FluidPressure__Sequence

type CIlluminance = C.sensor_msgs__msg__Illuminance

type CIlluminance__Sequence = C.sensor_msgs__msg__Illuminance__Sequence

type CImage = C.sensor_msgs__msg__Image

type CImage__Sequence = C.sensor_msgs__msg__Image__Sequence

type CImu = C.sensor_msgs__msg__Imu

type CImu__Sequence = C.sensor_msgs__msg__Imu__Sequence

type CJointState = C.sensor_msgs__msg__JointState

type CJointState__Sequence = C.sensor_msgs__msg__JointState__Sequence

type CJoy = C.sensor_msgs__msg__Joy

type CJoyFeedback = C.sensor_msgs__msg__JoyFeedback

type CJoyFeedbackArray = C.sensor_msgs__msg__JoyFeedbackArray

type CJoyFeedbackArray__Sequence = C.sensor_msgs__msg__JoyFeedbackArray__Sequence

type CJoyFeedback__Sequence = C.sensor_msgs__msg__JoyFeedback__Sequence

type CJoy__Sequence = C.sensor_msgs__msg__Joy__Sequence

type CLaserEcho = C.sensor_msgs__msg__LaserEcho

type CLaserEcho__Sequence = C.sensor_msgs__msg__LaserEcho__Sequence

type CLaserScan = C.sensor_msgs__msg__LaserScan

type CLaserScan__Sequence = C.sensor_msgs__msg__LaserScan__Sequence

type CMagneticField = C.sensor_msgs__msg__MagneticField

type CMagneticField__Sequence = C.sensor_msgs__msg__MagneticField__Sequence

type CMultiDOFJointState = C.sensor_msgs__msg__MultiDOFJointState

type CMultiDOFJointState__Sequence = C.sensor_msgs__msg__MultiDOFJointState__Sequence

type CMultiEchoLaserScan = C.sensor_msgs__msg__MultiEchoLaserScan

type CMultiEchoLaserScan__Sequence = C.sensor_msgs__msg__MultiEchoLaserScan__Sequence

type CNavSatFix = C.sensor_msgs__msg__NavSatFix

type CNavSatFix__Sequence = C.sensor_msgs__msg__NavSatFix__Sequence

type CNavSatStatus = C.sensor_msgs__msg__NavSatStatus

type CNavSatStatus__Sequence = C.sensor_msgs__msg__NavSatStatus__Sequence

type CPointCloud = C.sensor_msgs__msg__PointCloud

type CPointCloud2 = C.sensor_msgs__msg__PointCloud2

type CPointCloud2__Sequence = C.sensor_msgs__msg__PointCloud2__Sequence

type CPointCloud__Sequence = C.sensor_msgs__msg__PointCloud__Sequence

type CPointField = C.sensor_msgs__msg__PointField

type CPointField__Sequence = C.sensor_msgs__msg__PointField__Sequence

type CRange = C.sensor_msgs__msg__Range

type CRange__Sequence = C.sensor_msgs__msg__Range__Sequence

type CRegionOfInterest = C.sensor_msgs__msg__RegionOfInterest

type CRegionOfInterest__Sequence = C.sensor_msgs__msg__RegionOfInterest__Sequence

type CRelativeHumidity = C.sensor_msgs__msg__RelativeHumidity

type CRelativeHumidity__Sequence = C.sensor_msgs__msg__RelativeHumidity__Sequence

type CTemperature = C.sensor_msgs__msg__Temperature

type CTemperature__Sequence = C.sensor_msgs__msg__Temperature__Sequence

type CTimeReference = C.sensor_msgs__msg__TimeReference

type CTimeReference__Sequence = C.sensor_msgs__msg__TimeReference__Sequence

type CameraInfo struct {
	Header          std_msgs_msg.Header `yaml:"header"`           // Header timestamp should be acquisition time of image. Time of image acquisition, camera coordinate frame ID
	Height          uint32              `yaml:"height"`           // The image dimensions with which the camera was calibrated.Normally this will be the full camera resolution in pixels.
	Width           uint32              `yaml:"width"`            // The image dimensions with which the camera was calibrated.Normally this will be the full camera resolution in pixels.
	DistortionModel string              `yaml:"distortion_model"` // The distortion model used. Supported models are listed insensor_msgs/distortion_models.hpp. For most cameras, "plumb_bob" - asimple model of radial and tangential distortion - is sufficent.
	D               []float64           `yaml:"d"`                // The distortion parameters, size depending on the distortion model.For "plumb_bob", the 5 parameters are: (k1, k2, t1, t2, k3).
	K               [9]float64          `yaml:"k"`                // 3x3 row-major matrix. Intrinsic camera matrix for the raw (distorted) images.[fx  0 cx]K = [ 0 fy cy][ 0  0  1]Projects 3D points in the camera coordinate frame to 2D pixelcoordinates using the focal lengths (fx, fy) and principal point(cx, cy).
	R               [9]float64          `yaml:"r"`                // 3x3 row-major matrix. Rectification matrix (stereo cameras only)A rotation matrix aligning the camera coordinate system to the idealstereo image plane so that epipolar lines in both stereo images areparallel.
	P               [12]float64         `yaml:"p"`                // 3x4 row-major matrix. Projection/camera matrix[fx'  0  cx' Tx]P = [ 0  fy' cy' Ty][ 0   0   1   0]By convention, this matrix specifies the intrinsic (camera) matrixof the processed (rectified) image. That is, the left 3x3 portionis the normal camera intrinsic matrix for the rectified image.It projects 3D points in the camera coordinate frame to 2D pixelcoordinates using the focal lengths (fx', fy') and principal point(cx', cy') - these may differ from the values in K.For monocular cameras, Tx = Ty = 0. Normally, monocular cameras willalso have R = the identity and P[1:3,1:3] = K.For a stereo pair, the fourth column [Tx Ty 0]' is related to theposition of the optical center of the second camera in the firstcamera's frame. We assume Tz = 0 so both cameras are in the samestereo image plane. The first camera always has Tx = Ty = 0. Forthe right (second) camera of a horizontal stereo pair, Ty = 0 andTx = -fx' * B, where B is the baseline between the cameras.Given a 3D point [X Y Z]', the projection (x, y) of the point ontothe rectified image is given by:[u v w]' = P * [X Y Z 1]'x = u / wy = v / wThis holds for both images of a stereo pair.
	BinningX        uint32              `yaml:"binning_x"`        // Binning refers here to any camera setting which combines rectangularneighborhoods of pixels into larger "super-pixels." It reduces theresolution of the output image to(width / binning_x) x (height / binning_y).The default values binning_x = binning_y = 0 is considered the sameas binning_x = binning_y = 1 (no subsampling).
	BinningY        uint32              `yaml:"binning_y"`        // Binning refers here to any camera setting which combines rectangularneighborhoods of pixels into larger "super-pixels." It reduces theresolution of the output image to(width / binning_x) x (height / binning_y).The default values binning_x = binning_y = 0 is considered the sameas binning_x = binning_y = 1 (no subsampling).
	Roi             RegionOfInterest    `yaml:"roi"`              // Region of interest (subwindow of full camera resolution), given infull resolution (unbinned) image coordinates. A particular ROIalways denotes the same window of pixels on the camera sensor,regardless of binning settings.The default setting of roi (all values 0) is considered the same asfull resolution (roi.width = width, roi.height = height).
}

type ChannelFloat32 struct {
	Name   string    `yaml:"name"`   // The channel name should give semantics of the channel (e.g."intensity" instead of "value").
	Values []float32 `yaml:"values"` // The values array should be 1-1 with the elements of the associatedPointCloud.
}

type CompressedImage struct {
	Header std_msgs_msg.Header `yaml:"header"` // Header timestamp should be acquisition time of image
	Format string              `yaml:"format"` // Specifies the format of the data
	Data   []uint8             `yaml:"data"`   // Compressed image buffer
}

type FluidPressure struct {
	Header        std_msgs_msg.Header `yaml:"header"`         // timestamp of the measurement
	FluidPressure float64             `yaml:"fluid_pressure"` // Absolute pressure reading in Pascals.
	Variance      float64             `yaml:"variance"`       // 0 is interpreted as variance unknown
}

type Illuminance struct {
	Header      std_msgs_msg.Header `yaml:"header"`      // timestamp is the time the illuminance was measured
	Illuminance float64             `yaml:"illuminance"` // Measurement of the Photometric Illuminance in Lux.
	Variance    float64             `yaml:"variance"`    // 0 is interpreted as variance unknown
}

type Image struct {
	Header      std_msgs_msg.Header `yaml:"header"`       // Header timestamp should be acquisition time of image
	Height      uint32              `yaml:"height"`       // image height, that is, number of rows
	Width       uint32              `yaml:"width"`        // image width, that is, number of columns
	Encoding    string              `yaml:"encoding"`     // Encoding of pixels -- channel meaning, ordering, size
	IsBigendian uint8               `yaml:"is_bigendian"` // is this data bigendian?
	Step        uint32              `yaml:"step"`         // Full row length in bytes
	Data        []uint8             `yaml:"data"`         // actual matrix data, size is (step * rows)
}

type Imu struct {
	Header                       std_msgs_msg.Header          `yaml:"header"`
	Orientation                  geometry_msgs_msg.Quaternion `yaml:"orientation"`
	OrientationCovariance        [9]float64                   `yaml:"orientation_covariance"` // Row major about x, y, z axes
	AngularVelocity              geometry_msgs_msg.Vector3    `yaml:"angular_velocity"`
	AngularVelocityCovariance    [9]float64                   `yaml:"angular_velocity_covariance"` // Row major about x, y, z axes
	LinearAcceleration           geometry_msgs_msg.Vector3    `yaml:"linear_acceleration"`
	LinearAccelerationCovariance [9]float64                   `yaml:"linear_acceleration_covariance"` // Row major x, y z
}

type JointState struct {
	Header   std_msgs_msg.Header `yaml:"header"`
	Name     []string            `yaml:"name"`
	Position []float64           `yaml:"position"`
	Velocity []float64           `yaml:"velocity"`
	Effort   []float64           `yaml:"effort"`
}

type Joy struct {
	Header  std_msgs_msg.Header `yaml:"header"`  // The timestamp is the time at which data is received from the joystick.
	Axes    []float32           `yaml:"axes"`    // The axes measurements from a joystick.
	Buttons []int32             `yaml:"buttons"` // The buttons measurements from a joystick.
}

type JoyFeedback struct {
	Type      uint8   `yaml:"type"`
	Id        uint8   `yaml:"id"`        // This will hold an id number for each type of each feedback.Example, the first led would be id=0, the second would be id=1
	Intensity float32 `yaml:"intensity"` // Intensity of the feedback, from 0.0 to 1.0, inclusive.  If device isactually binary, driver should treat 0<=x<0.5 as off, 0.5<=x<=1 as on.
}

type JoyFeedbackArray struct {
	Array []JoyFeedback `yaml:"array"` // This message publishes values for multiple feedback at once.
}

type LaserEcho struct {
	Echoes []float32 `yaml:"echoes"` // Multiple values of ranges or intensities.
}

type LaserScan struct {
	Header         std_msgs_msg.Header `yaml:"header"`          // timestamp in the header is the acquisition time of
	AngleMin       float32             `yaml:"angle_min"`       // start angle of the scan [rad]
	AngleMax       float32             `yaml:"angle_max"`       // end angle of the scan [rad]
	AngleIncrement float32             `yaml:"angle_increment"` // angular distance between measurements [rad]
	TimeIncrement  float32             `yaml:"time_increment"`  // time between measurements [seconds] - if your scanner
	ScanTime       float32             `yaml:"scan_time"`       // time between scans [seconds]. is moving, this will be used in interpolating positionof 3d points
	RangeMin       float32             `yaml:"range_min"`       // minimum range value [m]
	RangeMax       float32             `yaml:"range_max"`       // maximum range value [m]
	Ranges         []float32           `yaml:"ranges"`          // range data [m]
	Intensities    []float32           `yaml:"intensities"`     // intensity data [device-specific units].  If your. (Note: values < range_min or > range_max should be discarded)
}

type MagneticField struct {
	Header                  std_msgs_msg.Header       `yaml:"header"`                    // timestamp is the time the
	MagneticField           geometry_msgs_msg.Vector3 `yaml:"magnetic_field"`            // x, y, and z components of the
	MagneticFieldCovariance [9]float64                `yaml:"magnetic_field_covariance"` // Row major about x, y, z axes
}

type MultiDOFJointState struct {
	Header     std_msgs_msg.Header           `yaml:"header"`
	JointNames []string                      `yaml:"joint_names"`
	Transforms []geometry_msgs_msg.Transform `yaml:"transforms"`
	Twist      []geometry_msgs_msg.Twist     `yaml:"twist"`
	Wrench     []geometry_msgs_msg.Wrench    `yaml:"wrench"`
}

type MultiEchoLaserScan struct {
	Header         std_msgs_msg.Header `yaml:"header"`          // timestamp in the header is the acquisition time of
	AngleMin       float32             `yaml:"angle_min"`       // start angle of the scan [rad]
	AngleMax       float32             `yaml:"angle_max"`       // end angle of the scan [rad]
	AngleIncrement float32             `yaml:"angle_increment"` // angular distance between measurements [rad]
	TimeIncrement  float32             `yaml:"time_increment"`  // time between measurements [seconds] - if your scanner
	ScanTime       float32             `yaml:"scan_time"`       // time between scans [seconds]. is moving, this will be used in interpolating positionof 3d points
	RangeMin       float32             `yaml:"range_min"`       // minimum range value [m]
	RangeMax       float32             `yaml:"range_max"`       // maximum range value [m]
	Ranges         []LaserEcho         `yaml:"ranges"`          // range data [m]
	Intensities    []LaserEcho         `yaml:"intensities"`     // intensity data [device-specific units].  If your. (Note: NaNs, values < range_min or > range_max should be discarded)+Inf measurements are out of range-Inf measurements are too close to determine exact distance.
}

type NavSatFix struct {
	Header                 std_msgs_msg.Header `yaml:"header"`              // header.stamp specifies the ROS time for this measurement (thecorresponding satellite time may be reported using thesensor_msgs/TimeReference message).header.frame_id is the frame of reference reported by the satellitereceiver, usually the location of the antenna.  This is aEuclidean frame relative to the vehicle, not a referenceellipsoid.
	Status                 NavSatStatus        `yaml:"status"`              // Satellite fix status information.
	Latitude               float64             `yaml:"latitude"`            // Latitude [degrees]. Positive is north of equator; negative is south.
	Longitude              float64             `yaml:"longitude"`           // Longitude [degrees]. Positive is east of prime meridian; negative is west.
	Altitude               float64             `yaml:"altitude"`            // Altitude [m]. Positive is above the WGS 84 ellipsoid(quiet NaN if no altitude is available).
	PositionCovariance     [9]float64          `yaml:"position_covariance"` // Position covariance [m^2] defined relative to a tangential planethrough the reported position. The components are East, North, andUp (ENU), in row-major order.Beware: this coordinate system exhibits singularities at the poles.
	PositionCovarianceType uint8               `yaml:"position_covariance_type"`
}

type NavSatStatus struct {
	Status  int8   `yaml:"status"`
	Service uint16 `yaml:"service"`
}

type PointCloud struct {
	Header   std_msgs_msg.Header         `yaml:"header"`   // Time of sensor data acquisition, coordinate frame ID.
	Points   []geometry_msgs_msg.Point32 `yaml:"points"`   // Array of 3d points. Each Point32 should be interpreted as a 3d pointin the frame given in the header.
	Channels []ChannelFloat32            `yaml:"channels"` // Each channel should have the same number of elements as points array,and the data in each channel should correspond 1:1 with each point.Channel names in common practice are listed in ChannelFloat32.msg.
}

type PointCloud2 struct {
	Header      std_msgs_msg.Header `yaml:"header"`       // Time of sensor data acquisition, and the coordinate frame ID (for 3d points).
	Height      uint32              `yaml:"height"`       // 2D structure of the point cloud. If the cloud is unordered, height is1 and width is the length of the point cloud.
	Width       uint32              `yaml:"width"`        // 2D structure of the point cloud. If the cloud is unordered, height is1 and width is the length of the point cloud.
	Fields      []PointField        `yaml:"fields"`       // Describes the channels and their layout in the binary data blob.
	IsBigendian bool                `yaml:"is_bigendian"` // Is this data bigendian?
	PointStep   uint32              `yaml:"point_step"`   // Length of a point in bytes
	RowStep     uint32              `yaml:"row_step"`     // Length of a row in bytes
	Data        []uint8             `yaml:"data"`         // Actual point data, size is (row_step*height)
	IsDense     bool                `yaml:"is_dense"`     // True if there are no invalid points
}

type PointField struct {
	Name     string `yaml:"name"`     // Name of field. Common PointField names are x, y, z, intensity, rgb, rgba
	Offset   uint32 `yaml:"offset"`   // Offset from start of point struct. Common PointField names are x, y, z, intensity, rgb, rgba
	Datatype uint8  `yaml:"datatype"` // Datatype enumeration, see above. Common PointField names are x, y, z, intensity, rgb, rgba
	Count    uint32 `yaml:"count"`    // How many elements in the field. Common PointField names are x, y, z, intensity, rgb, rgba
}

type Range struct {
	Header        std_msgs_msg.Header `yaml:"header"`         // timestamp in the header is the time the ranger
	RadiationType uint8               `yaml:"radiation_type"` // the type of radiation used by the sensor
	FieldOfView   float32             `yaml:"field_of_view"`  // the size of the arc that the distance reading is
	MinRange      float32             `yaml:"min_range"`      // minimum range value [m]
	MaxRange      float32             `yaml:"max_range"`      // maximum range value [m]
	Range         float32             `yaml:"range"`          // range data [m]
}

type RegionOfInterest struct {
	XOffset   uint32 `yaml:"x_offset"`   // Leftmost pixel of the ROI
	YOffset   uint32 `yaml:"y_offset"`   // Topmost pixel of the ROI. (0 if the ROI includes the left edge of the image)
	Height    uint32 `yaml:"height"`     // Height of ROI. (0 if the ROI includes the left edge of the image)(0 if the ROI includes the top edge of the image)
	Width     uint32 `yaml:"width"`      // Width of ROI. (0 if the ROI includes the left edge of the image)(0 if the ROI includes the top edge of the image)
	DoRectify bool   `yaml:"do_rectify"` // True if a distinct rectified ROI should be calculated from the "raw"ROI in this message. Typically this should be False if the full imageis captured (ROI not used), and True if a subwindow is captured (ROIused).
}

type RelativeHumidity struct {
	Header           std_msgs_msg.Header `yaml:"header"`            // timestamp of the measurement
	RelativeHumidity float64             `yaml:"relative_humidity"` // Expression of the relative humidity
	Variance         float64             `yaml:"variance"`          // 0 is interpreted as variance unknown
}

type Temperature struct {
	Header      std_msgs_msg.Header `yaml:"header"`      // timestamp is the time the temperature was measured
	Temperature float64             `yaml:"temperature"` // Measurement of the Temperature in Degrees Celsius.
	Variance    float64             `yaml:"variance"`    // 0 is interpreted as variance unknown.
}

type TimeReference struct {
	Header  std_msgs_msg.Header         `yaml:"header"`   // stamp is system time for which measurement was valid
	TimeRef builtin_interfaces_msg.Time `yaml:"time_ref"` // corresponding time from this external source
	Source  string                      `yaml:"source"`   // (optional) name of time source
}