Trying to send a takeoff command to the SITL but nothing happens.

[razsa]

SITL on port 5763 and QGroundControl. When I run this code nothing happens in the simulator.
I can only receive heartbeats from the SITL.

// DroneCommander handles MAVLink communication with the drone
type DroneCommander struct {
	node *gomavlib.Node
}

// NewDroneCommander creates a new instance of DroneCommander
func NewDroneCommander() (*DroneCommander, error) {
	node, err := gomavlib.NewNode(gomavlib.NodeConf{
		Endpoints: []gomavlib.EndpointConf{
			gomavlib.EndpointTCPClient{"127.0.0.1:5763"},
		},
		Dialect:     ardupilotmega.Dialect,
		OutVersion:  gomavlib.V2,
		OutSystemID: 10,
	})
	if err != nil {
		return nil, err
	}

	return &DroneCommander{
		node: node,
	}, nil
}

// SendTakeoff sends a takeoff command to the drone
func (dc *DroneCommander) SendTakeoff(altitude float32, targetSystem uint8, targetComponent uint8) error {
	msg := &ardupilotmega.MessageCommandLong{
		TargetSystem:    targetSystem,
		TargetComponent: targetComponent,
		Command:         common.MAV_CMD_NAV_TAKEOFF,
		Confirmation:    0,
		Param1:         0,    // Pitch angle (currently ignored)
		Param2:         0,    // Empty
		Param3:         0,    // Empty
		Param4:         0,    // Yaw angle (ignored if absolute yaw is used)
		Param5:         0,    // Latitude (ignored)
		Param6:         0,    // Longitude (ignored)
		Param7:         altitude, // Altitude in meters
	}

	return dc.node.WriteMessageAll(msg)
}

// Close closes the MAVLink connection
func (dc *DroneCommander) Close() {
	if dc.node != nil {
		dc.node.Close()
	}
}

func main() {
	// Create new drone commander
	dc, err := NewDroneCommander()
	if err != nil {
		log.Fatalf("Failed to create drone commander: %v", err)
	}
	defer dc.Close()

	// Send takeoff command
	targetSystem := uint8(1)    // Usually 1 for a single vehicle
	targetComponent := uint8(1) // Usually 1 for the autopilot
	altitude := float32(10.0)   // Takeoff altitude in meters

	log.Println("Sending takeoff command...")
	err = dc.SendTakeoff(altitude, targetSystem, targetComponent)
	if err != nil {
		log.Fatalf("Failed to send takeoff command: %v", err)
	}

	// Wait for a few seconds to see the response
	log.Println("Waiting for response...")
	time.Sleep(5 * time.Second)

	// Monitor incoming messages
	for evt := range dc.node.Events() {
		if frm, ok := evt.(*gomavlib.EventFrame); ok {
			log.Printf("Received: id=%d, %+v\n", frm.Message().GetID(), frm.Message())
		}
	}
}

[aler9]

Hello, the only error i see in your code is that you are stopping the event queue for 5 seconds:

// Wait for a few seconds to see the response
log.Println("Waiting for response...")
time.Sleep(5 * time.Second)

This stops event processing, that might be related to the ability to send or receive messages.

The right approach consists in always listening for incoming messages. The listen procedure is "blocking", not "non-blocking", therefore there's no need to wait, since the waiting is already performed by dc.node.Events():

for evt := range dc.node.Events() {
	if frm, ok := evt.(*gomavlib.EventFrame); ok {
		log.Printf("Received: id=%d, %+v\n", frm.Message().GetID(), frm.Message())
	}
}

Even better if you perform the SendTakeOff() call in another routine, maybe on repeat:

go func() {
	for {
		err = dc.SendTakeoff(altitude, targetSystem, targetComponent)
		if err != nil {
			log.Fatalf("Failed to send takeoff command: %v", err)
		}
		time.Sleep(1 * time.Second)
	}
}()

for evt := range dc.node.Events() {
	...
}

Other than this, the procedure to perform the take off entirely depends on your SITL. My advice is to link QGroundcontrol and the SITL through mavp2p, use mavp2p to listen for the exact command (or sequence of commands) that QGroundControl is using to perform the take off (there's the --print option for that), and then replicate them in Go.