How to connect to a PX4 SITL?

[nareshbhatia]

I am just starting out with gomavlib and wanted some help in connecting my example to a PX4 SITL.

Here's my setup:

Headless PX4 SITL running in a docker container

> docker run --rm -it jonasvautherin/px4-gazebo-headless:1.16.0
px4 starting.
...
INFO  [mavlink] mode: Normal, data rate: 4000000 B/s on udp port 18570 remote port 14550
INFO  [mavlink] mode: Onboard, data rate: 4000000 B/s on udp port 14580 remote port 14540
INFO  [mavlink] mode: Onboard, data rate: 4000 B/s on udp port 14280 remote port 14030
INFO  [mavlink] mode: Gimbal, data rate: 400000 B/s on udp port 13030 remote port 13280
INFO  [commander] Ready for takeoff!
...
pxh>

From this I understand that the SITL is broadcasting on UDP port 14550 (as expected) and accepting commands on UDP port 18570. Is this correct?

     ┌──────────────┐                     ┌──────────────┐
     │     PX4      │                     │     GCS      │
     │   on SITL    │                     │    (QGC)     │
     └──────┬───────┘                     └──────┬───────┘
            │                                    │
            │     broadcast messages from PX4    │
            │  ────────────────────────────────> │  Port 14550
            │                                    │
            │          commands from GCS         │
 Port 18570 |  <───────────────────────────────- │
            │                                    │
            │                                    │

Test with QGroundControl – Success!

I tested with QGroundControl and everything works fine

• I can see messages from the PX4 SITL in QGC's Analyze Tool
• I can send commands to the SITL (Takeoff, Land, etc.) and they work just fine

Test with gomavlib Example – Doesn't Work

I tried the node-endpoint-udp-broadcast example (slightly modified) and it just sits waiting for messages. I believe that it is binding correctly to port 14550, because I don't see any connection errors.

My Code

package main

import (
	"log"

	"github.com/bluenviron/gomavlib/v3"
	"github.com/bluenviron/gomavlib/v3/pkg/dialects/all"
)

func main() {
	node := &gomavlib.Node{
		Endpoints: []gomavlib.EndpointConf{
			gomavlib.EndpointUDPBroadcast{BroadcastAddress: "192.168.1.255:14550"},
		},
		Dialect:     all.Dialect,
		OutVersion:  gomavlib.V2,
		OutSystemID: 10,
	}
	err := node.Initialize()
	if err != nil {
		panic(err)
	}
	defer node.Close()

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

My Questions

1. What is the difference between the 3 UDP examples: node-endpoint-udp-broadcast, node-endpoint-udp-client, node-endpoint-udp-server? Which is the correct one for my use case where I am trying to make my example work like a GCS.
2. The official example uses 192.168.7.255:5600 as the broadcast address. I was getting an error on that address, so I changed it to 192.168.1.255:14550 which seems to be the broadcast address on my Mac. At least it is not giving any errors. Is this a good choice?
3. The github example uses the ardupilotmega dialect. I didn't find any px4 dialect, so I switched to the all dialect. Is that a good choice?
4. Any guesses on why I am not seeing the broadcast messages from the SITL?

[nareshbhatia]

Ok, I got it working.

Answering my own questions – please let me know if my understanding is correct.

1. As far as I can tell, gomavlib.EndpointUDPServer is for the use case when the app want to behave like a server (e.g. a ground station), gomavlib.EndpointUDPClient for the use case when the app want to behave like a client (e.g. a drone). Not sure about gomavlib.EndpointUDPBroadcast.
2. I finally ended up using the address 0.0.0.0:14550
3. I finally ended up using the common dialect

Here's my final code:

package main

import (
	"encoding/json"
	"log"

	"github.com/bluenviron/gomavlib/v3"
	"github.com/bluenviron/gomavlib/v3/pkg/dialects/common"
	"github.com/flightpath-dev/flightpath/internal/mavlink"
)

func main() {
	// Create a node which acts as a GCS, communicating with a UDP endpoint in server mode.
	// We use port 14550 because that's where the PX4 broadcasts its messages.
	// We use system ID 254 to coexist with QGroundControl (which uses 255).
	node := &gomavlib.Node{
		Endpoints: []gomavlib.EndpointConf{
			gomavlib.EndpointUDPServer{Address: "0.0.0.0:14550"},
		},
		Dialect:     common.Dialect,
		OutVersion:  gomavlib.V2,
		OutSystemID: 254,
	}
	err := node.Initialize()
	if err != nil {
		panic(err)
	}
	defer node.Close()

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