コード例 #1
0
ファイル: DiagnosticStatus.msg.go プロジェクト: ppg/rosgo
func (m *DiagnosticStatus) Serialize(w io.Writer) (err error) {
	if err = ros.SerializeMessageField(w, "byte", &m.Level); err != nil {
		return err
	}

	if err = ros.SerializeMessageField(w, "string", &m.Name); err != nil {
		return err
	}

	if err = ros.SerializeMessageField(w, "string", &m.Message); err != nil {
		return err
	}

	if err = ros.SerializeMessageField(w, "string", &m.HardwareID); err != nil {
		return err
	}

	// Write size little endian
	err = binary.Write(w, binary.LittleEndian, uint32(len(m.Values)))
	if err != nil {
		return fmt.Errorf("could not write array length: %s", err)
	}
	for _, elem := range m.Values {
		if err = ros.SerializeMessageField(w, "KeyValue", &elem); err != nil {
			return err
		}
	}

	return
}
コード例 #2
0
func (m *FollowJointTrajectoryGoal) Serialize(w io.Writer) (err error) {
	if err = ros.SerializeMessageField(w, "trajectory_msgs/JointTrajectory", &m.Trajectory); err != nil {
		return err
	}

	// Write size little endian
	err = binary.Write(w, binary.LittleEndian, uint32(len(m.PathTolerance)))
	if err != nil {
		return fmt.Errorf("could not write array length: %s", err)
	}
	for _, elem := range m.PathTolerance {
		if err = ros.SerializeMessageField(w, "JointTolerance", &elem); err != nil {
			return err
		}
	}

	// Write size little endian
	err = binary.Write(w, binary.LittleEndian, uint32(len(m.GoalTolerance)))
	if err != nil {
		return fmt.Errorf("could not write array length: %s", err)
	}
	for _, elem := range m.GoalTolerance {
		if err = ros.SerializeMessageField(w, "JointTolerance", &elem); err != nil {
			return err
		}
	}

	if err = ros.SerializeMessageField(w, "duration", &m.GoalTimeTolerance); err != nil {
		return err
	}

	return
}
コード例 #3
0
ファイル: Joy.msg.go プロジェクト: ppg/rosgo
func (m *Joy) Serialize(w io.Writer) (err error) {
	if err = ros.SerializeMessageField(w, "Header", &m.Header); err != nil {
		return err
	}

	// Write size little endian
	err = binary.Write(w, binary.LittleEndian, uint32(len(m.Axes)))
	if err != nil {
		return fmt.Errorf("could not write array length: %s", err)
	}
	for _, elem := range m.Axes {
		if err = ros.SerializeMessageField(w, "float32", &elem); err != nil {
			return err
		}
	}

	// Write size little endian
	err = binary.Write(w, binary.LittleEndian, uint32(len(m.Buttons)))
	if err != nil {
		return fmt.Errorf("could not write array length: %s", err)
	}
	for _, elem := range m.Buttons {
		if err = ros.SerializeMessageField(w, "int32", &elem); err != nil {
			return err
		}
	}

	return
}
コード例 #4
0
func (m *FollowJointTrajectoryFeedback) Serialize(w io.Writer) (err error) {
	if err = ros.SerializeMessageField(w, "Header", &m.Header); err != nil {
		return err
	}

	// Write size little endian
	err = binary.Write(w, binary.LittleEndian, uint32(len(m.JointNames)))
	if err != nil {
		return fmt.Errorf("could not write array length: %s", err)
	}
	for _, elem := range m.JointNames {
		if err = ros.SerializeMessageField(w, "string", &elem); err != nil {
			return err
		}
	}

	if err = ros.SerializeMessageField(w, "trajectory_msgs/JointTrajectoryPoint", &m.Desired); err != nil {
		return err
	}

	if err = ros.SerializeMessageField(w, "trajectory_msgs/JointTrajectoryPoint", &m.Actual); err != nil {
		return err
	}

	if err = ros.SerializeMessageField(w, "trajectory_msgs/JointTrajectoryPoint", &m.Error); err != nil {
		return err
	}

	return
}
コード例 #5
0
ファイル: Mesh.msg.go プロジェクト: ppg/rosgo
func (m *Mesh) Serialize(w io.Writer) (err error) {
	// Write size little endian
	err = binary.Write(w, binary.LittleEndian, uint32(len(m.Triangles)))
	if err != nil {
		return fmt.Errorf("could not write array length: %s", err)
	}
	for _, elem := range m.Triangles {
		if err = ros.SerializeMessageField(w, "MeshTriangle", &elem); err != nil {
			return err
		}
	}

	// Write size little endian
	err = binary.Write(w, binary.LittleEndian, uint32(len(m.Vertices)))
	if err != nil {
		return fmt.Errorf("could not write array length: %s", err)
	}
	for _, elem := range m.Vertices {
		if err = ros.SerializeMessageField(w, "geometry_msgs/Point", &elem); err != nil {
			return err
		}
	}

	return
}
コード例 #6
0
ファイル: JointTrajectory.msg.go プロジェクト: ppg/rosgo
func (m *JointTrajectory) Serialize(w io.Writer) (err error) {
	if err = ros.SerializeMessageField(w, "Header", &m.Header); err != nil {
		return err
	}

	// Write size little endian
	err = binary.Write(w, binary.LittleEndian, uint32(len(m.JointNames)))
	if err != nil {
		return fmt.Errorf("could not write array length: %s", err)
	}
	for _, elem := range m.JointNames {
		if err = ros.SerializeMessageField(w, "string", &elem); err != nil {
			return err
		}
	}

	// Write size little endian
	err = binary.Write(w, binary.LittleEndian, uint32(len(m.Points)))
	if err != nil {
		return fmt.Errorf("could not write array length: %s", err)
	}
	for _, elem := range m.Points {
		if err = ros.SerializeMessageField(w, "JointTrajectoryPoint", &elem); err != nil {
			return err
		}
	}

	return
}
コード例 #7
0
ファイル: GridCells.msg.go プロジェクト: ppg/rosgo
func (m *GridCells) Serialize(w io.Writer) (err error) {
	if err = ros.SerializeMessageField(w, "Header", &m.Header); err != nil {
		return err
	}

	if err = ros.SerializeMessageField(w, "float32", &m.CellWidth); err != nil {
		return err
	}

	if err = ros.SerializeMessageField(w, "float32", &m.CellHeight); err != nil {
		return err
	}

	// Write size little endian
	err = binary.Write(w, binary.LittleEndian, uint32(len(m.Cells)))
	if err != nil {
		return fmt.Errorf("could not write array length: %s", err)
	}
	for _, elem := range m.Cells {
		if err = ros.SerializeMessageField(w, "geometry_msgs/Point", &elem); err != nil {
			return err
		}
	}

	return
}
コード例 #8
0
ファイル: LaserScan.msg.go プロジェクト: ppg/rosgo
func (m *LaserScan) Serialize(w io.Writer) (err error) {
	if err = ros.SerializeMessageField(w, "Header", &m.Header); err != nil {
		return err
	}

	if err = ros.SerializeMessageField(w, "float32", &m.AngleMin); err != nil {
		return err
	}

	if err = ros.SerializeMessageField(w, "float32", &m.AngleMax); err != nil {
		return err
	}

	if err = ros.SerializeMessageField(w, "float32", &m.AngleIncrement); err != nil {
		return err
	}

	if err = ros.SerializeMessageField(w, "float32", &m.TimeIncrement); err != nil {
		return err
	}

	if err = ros.SerializeMessageField(w, "float32", &m.ScanTime); err != nil {
		return err
	}

	if err = ros.SerializeMessageField(w, "float32", &m.RangeMin); err != nil {
		return err
	}

	if err = ros.SerializeMessageField(w, "float32", &m.RangeMax); err != nil {
		return err
	}

	// Write size little endian
	err = binary.Write(w, binary.LittleEndian, uint32(len(m.Ranges)))
	if err != nil {
		return fmt.Errorf("could not write array length: %s", err)
	}
	for _, elem := range m.Ranges {
		if err = ros.SerializeMessageField(w, "float32", &elem); err != nil {
			return err
		}
	}

	// Write size little endian
	err = binary.Write(w, binary.LittleEndian, uint32(len(m.Intensities)))
	if err != nil {
		return fmt.Errorf("could not write array length: %s", err)
	}
	for _, elem := range m.Intensities {
		if err = ros.SerializeMessageField(w, "float32", &elem); err != nil {
			return err
		}
	}

	return
}
コード例 #9
0
ファイル: TwistStamped.msg.go プロジェクト: ppg/rosgo
func (m *TwistStamped) Serialize(w io.Writer) (err error) {
	if err = ros.SerializeMessageField(w, "Header", &m.Header); err != nil {
		return err
	}

	if err = ros.SerializeMessageField(w, "Twist", &m.Twist); err != nil {
		return err
	}

	return
}
コード例 #10
0
func (m *LookupTransformResult) Serialize(w io.Writer) (err error) {
	if err = ros.SerializeMessageField(w, "geometry_msgs/TransformStamped", &m.Transform); err != nil {
		return err
	}

	if err = ros.SerializeMessageField(w, "tf2_msgs/TF2Error", &m.Error); err != nil {
		return err
	}

	return
}
コード例 #11
0
ファイル: AddTwoInts.srv.go プロジェクト: ppg/rosgo
func (m *AddTwoIntsRequest) Serialize(w io.Writer) (err error) {
	if err = ros.SerializeMessageField(w, "int32", &m.A); err != nil {
		return err
	}

	if err = ros.SerializeMessageField(w, "int32", &m.B); err != nil {
		return err
	}

	return
}
コード例 #12
0
ファイル: GoalID.msg.go プロジェクト: ppg/rosgo
func (m *GoalID) Serialize(w io.Writer) (err error) {
	if err = ros.SerializeMessageField(w, "time", &m.Stamp); err != nil {
		return err
	}

	if err = ros.SerializeMessageField(w, "string", &m.ID); err != nil {
		return err
	}

	return
}
コード例 #13
0
ファイル: TF2Error.msg.go プロジェクト: ppg/rosgo
func (m *TF2Error) Serialize(w io.Writer) (err error) {
	if err = ros.SerializeMessageField(w, "uint8", &m.Error); err != nil {
		return err
	}

	if err = ros.SerializeMessageField(w, "string", &m.ErrorString); err != nil {
		return err
	}

	return
}
コード例 #14
0
ファイル: Transform.msg.go プロジェクト: ppg/rosgo
func (m *Transform) Serialize(w io.Writer) (err error) {
	if err = ros.SerializeMessageField(w, "Vector3", &m.Translation); err != nil {
		return err
	}

	if err = ros.SerializeMessageField(w, "Quaternion", &m.Rotation); err != nil {
		return err
	}

	return
}
コード例 #15
0
ファイル: GripperCommand.msg.go プロジェクト: ppg/rosgo
func (m *GripperCommand) Serialize(w io.Writer) (err error) {
	if err = ros.SerializeMessageField(w, "float64", &m.Position); err != nil {
		return err
	}

	if err = ros.SerializeMessageField(w, "float64", &m.MaxEffort); err != nil {
		return err
	}

	return
}
コード例 #16
0
ファイル: WrenchStamped.msg.go プロジェクト: ppg/rosgo
func (m *WrenchStamped) Serialize(w io.Writer) (err error) {
	if err = ros.SerializeMessageField(w, "Header", &m.Header); err != nil {
		return err
	}

	if err = ros.SerializeMessageField(w, "Wrench", &m.Wrench); err != nil {
		return err
	}

	return
}
コード例 #17
0
ファイル: AccelStamped.msg.go プロジェクト: ppg/rosgo
func (m *AccelStamped) Serialize(w io.Writer) (err error) {
	if err = ros.SerializeMessageField(w, "Header", &m.Header); err != nil {
		return err
	}

	if err = ros.SerializeMessageField(w, "Accel", &m.Accel); err != nil {
		return err
	}

	return
}
コード例 #18
0
ファイル: Pose.msg.go プロジェクト: ppg/rosgo
func (m *Pose) Serialize(w io.Writer) (err error) {
	if err = ros.SerializeMessageField(w, "Point", &m.Position); err != nil {
		return err
	}

	if err = ros.SerializeMessageField(w, "Quaternion", &m.Orientation); err != nil {
		return err
	}

	return
}
コード例 #19
0
ファイル: Twist.msg.go プロジェクト: ppg/rosgo
func (m *Twist) Serialize(w io.Writer) (err error) {
	if err = ros.SerializeMessageField(w, "Vector3", &m.Linear); err != nil {
		return err
	}

	if err = ros.SerializeMessageField(w, "Vector3", &m.Angular); err != nil {
		return err
	}

	return
}
コード例 #20
0
func (m *PoseWithCovarianceStamped) Serialize(w io.Writer) (err error) {
	if err = ros.SerializeMessageField(w, "Header", &m.Header); err != nil {
		return err
	}

	if err = ros.SerializeMessageField(w, "PoseWithCovariance", &m.Pose); err != nil {
		return err
	}

	return
}
コード例 #21
0
ファイル: KeyValue.msg.go プロジェクト: ppg/rosgo
func (m *KeyValue) Serialize(w io.Writer) (err error) {
	if err = ros.SerializeMessageField(w, "string", &m.Key); err != nil {
		return err
	}

	if err = ros.SerializeMessageField(w, "string", &m.Value); err != nil {
		return err
	}

	return
}
コード例 #22
0
ファイル: Vector3Stamped.msg.go プロジェクト: ppg/rosgo
func (m *Vector3Stamped) Serialize(w io.Writer) (err error) {
	if err = ros.SerializeMessageField(w, "Header", &m.Header); err != nil {
		return err
	}

	if err = ros.SerializeMessageField(w, "Vector3", &m.Vector); err != nil {
		return err
	}

	return
}
コード例 #23
0
ファイル: QuaternionStamped.msg.go プロジェクト: ppg/rosgo
func (m *QuaternionStamped) Serialize(w io.Writer) (err error) {
	if err = ros.SerializeMessageField(w, "Header", &m.Header); err != nil {
		return err
	}

	if err = ros.SerializeMessageField(w, "Quaternion", &m.Quaternion); err != nil {
		return err
	}

	return
}
コード例 #24
0
ファイル: Wrench.msg.go プロジェクト: ppg/rosgo
func (m *Wrench) Serialize(w io.Writer) (err error) {
	if err = ros.SerializeMessageField(w, "Vector3", &m.Force); err != nil {
		return err
	}

	if err = ros.SerializeMessageField(w, "Vector3", &m.Torque); err != nil {
		return err
	}

	return
}
コード例 #25
0
ファイル: SetBool.srv.go プロジェクト: ppg/rosgo
func (m *SetBoolResponse) Serialize(w io.Writer) (err error) {
	if err = ros.SerializeMessageField(w, "bool", &m.Success); err != nil {
		return err
	}

	if err = ros.SerializeMessageField(w, "string", &m.Message); err != nil {
		return err
	}

	return
}
コード例 #26
0
ファイル: InertiaStamped.msg.go プロジェクト: ppg/rosgo
func (m *InertiaStamped) Serialize(w io.Writer) (err error) {
	if err = ros.SerializeMessageField(w, "Header", &m.Header); err != nil {
		return err
	}

	if err = ros.SerializeMessageField(w, "Inertia", &m.Inertia); err != nil {
		return err
	}

	return
}
コード例 #27
0
ファイル: JointState.msg.go プロジェクト: ppg/rosgo
func (m *JointState) Serialize(w io.Writer) (err error) {
	if err = ros.SerializeMessageField(w, "Header", &m.Header); err != nil {
		return err
	}

	// Write size little endian
	err = binary.Write(w, binary.LittleEndian, uint32(len(m.Name)))
	if err != nil {
		return fmt.Errorf("could not write array length: %s", err)
	}
	for _, elem := range m.Name {
		if err = ros.SerializeMessageField(w, "string", &elem); err != nil {
			return err
		}
	}

	// Write size little endian
	err = binary.Write(w, binary.LittleEndian, uint32(len(m.Position)))
	if err != nil {
		return fmt.Errorf("could not write array length: %s", err)
	}
	for _, elem := range m.Position {
		if err = ros.SerializeMessageField(w, "float64", &elem); err != nil {
			return err
		}
	}

	// Write size little endian
	err = binary.Write(w, binary.LittleEndian, uint32(len(m.Velocity)))
	if err != nil {
		return fmt.Errorf("could not write array length: %s", err)
	}
	for _, elem := range m.Velocity {
		if err = ros.SerializeMessageField(w, "float64", &elem); err != nil {
			return err
		}
	}

	// Write size little endian
	err = binary.Write(w, binary.LittleEndian, uint32(len(m.Effort)))
	if err != nil {
		return fmt.Errorf("could not write array length: %s", err)
	}
	for _, elem := range m.Effort {
		if err = ros.SerializeMessageField(w, "float64", &elem); err != nil {
			return err
		}
	}

	return
}
コード例 #28
0
ファイル: MultiDOFJointState.msg.go プロジェクト: ppg/rosgo
func (m *MultiDOFJointState) Serialize(w io.Writer) (err error) {
	if err = ros.SerializeMessageField(w, "Header", &m.Header); err != nil {
		return err
	}

	// Write size little endian
	err = binary.Write(w, binary.LittleEndian, uint32(len(m.JointNames)))
	if err != nil {
		return fmt.Errorf("could not write array length: %s", err)
	}
	for _, elem := range m.JointNames {
		if err = ros.SerializeMessageField(w, "string", &elem); err != nil {
			return err
		}
	}

	// Write size little endian
	err = binary.Write(w, binary.LittleEndian, uint32(len(m.Transforms)))
	if err != nil {
		return fmt.Errorf("could not write array length: %s", err)
	}
	for _, elem := range m.Transforms {
		if err = ros.SerializeMessageField(w, "geometry_msgs/Transform", &elem); err != nil {
			return err
		}
	}

	// Write size little endian
	err = binary.Write(w, binary.LittleEndian, uint32(len(m.Twist)))
	if err != nil {
		return fmt.Errorf("could not write array length: %s", err)
	}
	for _, elem := range m.Twist {
		if err = ros.SerializeMessageField(w, "geometry_msgs/Twist", &elem); err != nil {
			return err
		}
	}

	// Write size little endian
	err = binary.Write(w, binary.LittleEndian, uint32(len(m.Wrench)))
	if err != nil {
		return fmt.Errorf("could not write array length: %s", err)
	}
	for _, elem := range m.Wrench {
		if err = ros.SerializeMessageField(w, "geometry_msgs/Wrench", &elem); err != nil {
			return err
		}
	}

	return
}
コード例 #29
0
ファイル: JointTrajectoryPoint.msg.go プロジェクト: ppg/rosgo
func (m *JointTrajectoryPoint) Serialize(w io.Writer) (err error) {
	// Write size little endian
	err = binary.Write(w, binary.LittleEndian, uint32(len(m.Positions)))
	if err != nil {
		return fmt.Errorf("could not write array length: %s", err)
	}
	for _, elem := range m.Positions {
		if err = ros.SerializeMessageField(w, "float64", &elem); err != nil {
			return err
		}
	}

	// Write size little endian
	err = binary.Write(w, binary.LittleEndian, uint32(len(m.Velocities)))
	if err != nil {
		return fmt.Errorf("could not write array length: %s", err)
	}
	for _, elem := range m.Velocities {
		if err = ros.SerializeMessageField(w, "float64", &elem); err != nil {
			return err
		}
	}

	// Write size little endian
	err = binary.Write(w, binary.LittleEndian, uint32(len(m.Accelerations)))
	if err != nil {
		return fmt.Errorf("could not write array length: %s", err)
	}
	for _, elem := range m.Accelerations {
		if err = ros.SerializeMessageField(w, "float64", &elem); err != nil {
			return err
		}
	}

	// Write size little endian
	err = binary.Write(w, binary.LittleEndian, uint32(len(m.Effort)))
	if err != nil {
		return fmt.Errorf("could not write array length: %s", err)
	}
	for _, elem := range m.Effort {
		if err = ros.SerializeMessageField(w, "float64", &elem); err != nil {
			return err
		}
	}

	if err = ros.SerializeMessageField(w, "duration", &m.TimeFromStart); err != nil {
		return err
	}

	return
}
コード例 #30
0
ファイル: Inertia.msg.go プロジェクト: ppg/rosgo
func (m *Inertia) Serialize(w io.Writer) (err error) {
	if err = ros.SerializeMessageField(w, "float64", &m.M); err != nil {
		return err
	}

	if err = ros.SerializeMessageField(w, "geometry_msgs/Vector3", &m.Com); err != nil {
		return err
	}

	if err = ros.SerializeMessageField(w, "float64", &m.Ixx); err != nil {
		return err
	}

	if err = ros.SerializeMessageField(w, "float64", &m.Ixy); err != nil {
		return err
	}

	if err = ros.SerializeMessageField(w, "float64", &m.Ixz); err != nil {
		return err
	}

	if err = ros.SerializeMessageField(w, "float64", &m.Iyy); err != nil {
		return err
	}

	if err = ros.SerializeMessageField(w, "float64", &m.Iyz); err != nil {
		return err
	}

	if err = ros.SerializeMessageField(w, "float64", &m.Izz); err != nil {
		return err
	}

	return
}