mirror of https://github.com/ArduPilot/ardupilot
469 lines
19 KiB
C++
469 lines
19 KiB
C++
// -*- tab-width: 4; Mode: C++; c-basic-offset: 4; indent-tabs-mode: nil -*-
|
|
|
|
/*
|
|
This program is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
/// @file MAVLink_routing.h
|
|
/// @brief handle routing of MAVLink packets by sysid/componentid
|
|
|
|
#include <stdio.h>
|
|
#include <AP_HAL.h>
|
|
#include <AP_Common.h>
|
|
#include <GCS.h>
|
|
#include <MAVLink_routing.h>
|
|
|
|
extern const AP_HAL::HAL& hal;
|
|
|
|
#define ROUTING_DEBUG 0
|
|
|
|
// constructor
|
|
MAVLink_routing::MAVLink_routing(void) : num_routes(0) {}
|
|
|
|
/*
|
|
forward a MAVLink message to the right port. This also
|
|
automatically learns the route for the sender if it is not
|
|
already known.
|
|
|
|
This returns true if the message should be processed locally
|
|
|
|
Theory of MAVLink routing:
|
|
|
|
When a flight controller receives a message it should process it
|
|
locally if any of these conditions hold:
|
|
|
|
1a) the message has no target_system field
|
|
|
|
1b) the message has a target_system of zero
|
|
|
|
1c) the message has the flight controllers target system and has no
|
|
target_component field
|
|
|
|
1d) the message has the flight controllers target system and has
|
|
the flight controllers target_component
|
|
|
|
1e) the message has the flight controllers target system and the
|
|
flight controller has not seen any messages on any of its links
|
|
from a system that has the messages
|
|
target_system/target_component combination
|
|
|
|
When a flight controller receives a message it should forward it
|
|
onto another different link if any of these conditions hold for that
|
|
link:
|
|
|
|
2a) the message has no target_system field
|
|
|
|
2b) the message has a target_system of zero
|
|
|
|
2c) the message does not have the flight controllers target_system
|
|
and the flight controller has seen a message from the messages
|
|
target_system on the link
|
|
|
|
2d) the message has the flight controllers target_system and has a
|
|
target_component field and the flight controllers has seen a
|
|
message from the target_system/target_component combination on
|
|
the link
|
|
|
|
Note: This proposal assumes that ground stations will not send command
|
|
packets to a non-broadcast destination (sysid/compid combination)
|
|
until they have received at least one package from that destination
|
|
over the link. This is essential to prevent a flight controller from
|
|
acting on a message that is not meant for it. For example, a PARAM_SET
|
|
cannot be sent to a specific sysid/compid combination until the GCS
|
|
has seen a packet from that sysid/compid combination on the link.
|
|
|
|
The GCS must also reset what sysid/compid combinations it has seen on
|
|
a link when it sees a SYSTEM_TIME message with a decrease in
|
|
time_boot_ms from a particular sysid/compid. That is essential to
|
|
detect a reset of the flight controller, which implies a reset of its
|
|
routing table.
|
|
|
|
*/
|
|
bool MAVLink_routing::check_and_forward(mavlink_channel_t in_channel, const mavlink_message_t* msg)
|
|
{
|
|
// handle the case of loopback of our own messages, due to
|
|
// incorrect serial configuration.
|
|
if (msg->sysid == mavlink_system.sysid &&
|
|
msg->compid == mavlink_system.compid) {
|
|
return true;
|
|
}
|
|
|
|
// learn new routes
|
|
learn_route(in_channel, msg);
|
|
|
|
if (msg->msgid == MAVLINK_MSG_ID_HEARTBEAT) {
|
|
// heartbeat needs special handling
|
|
handle_heartbeat(in_channel, msg);
|
|
return true;
|
|
}
|
|
|
|
// extract the targets for this packet
|
|
int16_t target_system = -1;
|
|
int16_t target_component = -1;
|
|
get_targets(msg, target_system, target_component);
|
|
|
|
bool broadcast_system = (target_system == 0 || target_system == -1);
|
|
bool broadcast_component = (target_component == 0 || target_component == -1);
|
|
bool match_system = broadcast_system || (target_system == mavlink_system.sysid);
|
|
bool match_component = match_system && (broadcast_component ||
|
|
(target_component == mavlink_system.compid));
|
|
bool process_locally = match_system && match_component;
|
|
|
|
if (process_locally && !broadcast_system && !broadcast_component) {
|
|
// nothing more to do - it can only be for us
|
|
return true;
|
|
}
|
|
|
|
// forward on any channels matching the targets
|
|
bool forwarded = false;
|
|
for (uint8_t i=0; i<num_routes; i++) {
|
|
if (broadcast_system || (target_system == routes[i].sysid &&
|
|
(broadcast_component ||
|
|
target_component == routes[i].compid))) {
|
|
if (in_channel != routes[i].channel) {
|
|
if (comm_get_txspace(routes[i].channel) >=
|
|
((uint16_t)msg->len) + MAVLINK_NUM_NON_PAYLOAD_BYTES) {
|
|
#if ROUTING_DEBUG
|
|
::printf("fwd msg %u from chan %u on chan %u sysid=%u compid=%u\n",
|
|
msg->msgid,
|
|
(unsigned)in_channel,
|
|
(unsigned)routes[i].channel,
|
|
(unsigned)target_system,
|
|
(unsigned)target_component);
|
|
#endif
|
|
_mavlink_resend_uart(routes[i].channel, msg);
|
|
}
|
|
forwarded = true;
|
|
}
|
|
}
|
|
}
|
|
if (!forwarded && match_system) {
|
|
process_locally = true;
|
|
}
|
|
|
|
return process_locally;
|
|
}
|
|
|
|
/*
|
|
send a MAVLink message to all components with this vehicle's system id
|
|
|
|
This is a no-op if no routes to components have been learned
|
|
*/
|
|
void MAVLink_routing::send_to_components(const mavlink_message_t* msg)
|
|
{
|
|
bool sent_to_chan[MAVLINK_COMM_NUM_BUFFERS];
|
|
memset(sent_to_chan, 0, sizeof(sent_to_chan));
|
|
|
|
// check learned routes
|
|
for (uint8_t i=0; i<num_routes; i++) {
|
|
if ((routes[i].sysid == mavlink_system.sysid) && !sent_to_chan[routes[i].channel]) {
|
|
if (comm_get_txspace(routes[i].channel) >= ((uint16_t)msg->len) + MAVLINK_NUM_NON_PAYLOAD_BYTES) {
|
|
#if ROUTING_DEBUG
|
|
::printf("send msg %u on chan %u sysid=%u compid=%u\n",
|
|
msg->msgid,
|
|
(unsigned)routes[i].channel,
|
|
(unsigned)routes[i].sysid,
|
|
(unsigned)routes[i].compid);
|
|
#endif
|
|
_mavlink_resend_uart(routes[i].channel, msg);
|
|
sent_to_chan[routes[i].channel] = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
see if the message is for a new route and learn it
|
|
*/
|
|
void MAVLink_routing::learn_route(mavlink_channel_t in_channel, const mavlink_message_t* msg)
|
|
{
|
|
uint8_t i;
|
|
if (msg->sysid == 0 ||
|
|
(msg->sysid == mavlink_system.sysid &&
|
|
msg->compid == mavlink_system.compid)) {
|
|
return;
|
|
}
|
|
for (i=0; i<num_routes; i++) {
|
|
if (routes[i].sysid == msg->sysid &&
|
|
routes[i].compid == msg->compid &&
|
|
routes[i].channel == in_channel) {
|
|
break;
|
|
}
|
|
}
|
|
if (i == num_routes && i<MAVLINK_MAX_ROUTES) {
|
|
routes[i].sysid = msg->sysid;
|
|
routes[i].compid = msg->compid;
|
|
routes[i].channel = in_channel;
|
|
num_routes++;
|
|
#if ROUTING_DEBUG
|
|
::printf("learned route %u %u via %u\n",
|
|
(unsigned)msg->sysid,
|
|
(unsigned)msg->compid,
|
|
(unsigned)in_channel);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
special handling for heartbeat messages. To ensure routing
|
|
propogation heartbeat messages need to be forwarded on all channels
|
|
except channels where the sysid/compid of the heartbeat could come from
|
|
*/
|
|
void MAVLink_routing::handle_heartbeat(mavlink_channel_t in_channel, const mavlink_message_t* msg)
|
|
{
|
|
uint16_t mask = GCS_MAVLINK::active_channel_mask();
|
|
|
|
// don't send on the incoming channel. This should only matter if
|
|
// the routing table is full
|
|
mask &= ~(1U<<(in_channel-MAVLINK_COMM_0));
|
|
|
|
// mask out channels that are known sources for this sysid/compid
|
|
for (uint8_t i=0; i<num_routes; i++) {
|
|
if (routes[i].sysid == msg->sysid && routes[i].compid == msg->compid) {
|
|
mask &= ~(1U<<((unsigned)(routes[i].channel-MAVLINK_COMM_0)));
|
|
}
|
|
}
|
|
|
|
if (mask == 0) {
|
|
// nothing to send to
|
|
return;
|
|
}
|
|
|
|
// send on the remaining channels
|
|
for (uint8_t i=0; i<MAVLINK_COMM_NUM_BUFFERS; i++) {
|
|
if (mask & (1U<<i)) {
|
|
mavlink_channel_t channel = (mavlink_channel_t)(MAVLINK_COMM_0 + i);
|
|
if (comm_get_txspace(channel) >= ((uint16_t)msg->len) + MAVLINK_NUM_NON_PAYLOAD_BYTES) {
|
|
#if ROUTING_DEBUG
|
|
::printf("fwd HB from chan %u on chan %u from sysid=%u compid=%u\n",
|
|
(unsigned)in_channel,
|
|
(unsigned)channel,
|
|
(unsigned)msg->sysid,
|
|
(unsigned)msg->compid);
|
|
#endif
|
|
_mavlink_resend_uart(channel, msg);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
extract target sysid and compid from a message. int16_t is used so
|
|
that the caller can set them to -1 and know when a sysid or compid
|
|
target is found in the message
|
|
*/
|
|
void MAVLink_routing::get_targets(const mavlink_message_t* msg, int16_t &sysid, int16_t &compid)
|
|
{
|
|
// unfortunately the targets are not in a consistent position in
|
|
// the packets, so we need a switch. Using the single element
|
|
// extraction functions (which are inline) makes this a bit faster
|
|
// than it would otherwise be.
|
|
// This list of messages below was extracted using:
|
|
//
|
|
// cat ardupilotmega/*h common/*h|egrep
|
|
// 'get_target_system|get_target_component' |grep inline | cut
|
|
// -d'(' -f1 | cut -d' ' -f4 > /tmp/targets.txt
|
|
//
|
|
// TODO: we should write a python script to extract this list
|
|
// properly
|
|
|
|
switch (msg->msgid) {
|
|
// these messages only have a target system
|
|
case MAVLINK_MSG_ID_CAMERA_FEEDBACK:
|
|
sysid = mavlink_msg_camera_feedback_get_target_system(msg);
|
|
break;
|
|
case MAVLINK_MSG_ID_CAMERA_STATUS:
|
|
sysid = mavlink_msg_camera_status_get_target_system(msg);
|
|
break;
|
|
case MAVLINK_MSG_ID_CHANGE_OPERATOR_CONTROL:
|
|
sysid = mavlink_msg_change_operator_control_get_target_system(msg);
|
|
break;
|
|
case MAVLINK_MSG_ID_SET_MODE:
|
|
sysid = mavlink_msg_set_mode_get_target_system(msg);
|
|
break;
|
|
case MAVLINK_MSG_ID_SET_GPS_GLOBAL_ORIGIN:
|
|
sysid = mavlink_msg_set_gps_global_origin_get_target_system(msg);
|
|
break;
|
|
|
|
// these support both target system and target component
|
|
case MAVLINK_MSG_ID_DIGICAM_CONFIGURE:
|
|
sysid = mavlink_msg_digicam_configure_get_target_system(msg);
|
|
compid = mavlink_msg_digicam_configure_get_target_component(msg);
|
|
break;
|
|
case MAVLINK_MSG_ID_DIGICAM_CONTROL:
|
|
sysid = mavlink_msg_digicam_control_get_target_system(msg);
|
|
compid = mavlink_msg_digicam_control_get_target_component(msg);
|
|
break;
|
|
case MAVLINK_MSG_ID_FENCE_FETCH_POINT:
|
|
sysid = mavlink_msg_fence_fetch_point_get_target_system(msg);
|
|
compid = mavlink_msg_fence_fetch_point_get_target_component(msg);
|
|
break;
|
|
case MAVLINK_MSG_ID_FENCE_POINT:
|
|
sysid = mavlink_msg_fence_point_get_target_system(msg);
|
|
compid = mavlink_msg_fence_point_get_target_component(msg);
|
|
break;
|
|
case MAVLINK_MSG_ID_MOUNT_CONFIGURE:
|
|
sysid = mavlink_msg_mount_configure_get_target_system(msg);
|
|
compid = mavlink_msg_mount_configure_get_target_component(msg);
|
|
break;
|
|
case MAVLINK_MSG_ID_MOUNT_CONTROL:
|
|
sysid = mavlink_msg_mount_control_get_target_system(msg);
|
|
compid = mavlink_msg_mount_control_get_target_component(msg);
|
|
break;
|
|
case MAVLINK_MSG_ID_MOUNT_STATUS:
|
|
sysid = mavlink_msg_mount_status_get_target_system(msg);
|
|
compid = mavlink_msg_mount_status_get_target_component(msg);
|
|
break;
|
|
case MAVLINK_MSG_ID_RALLY_FETCH_POINT:
|
|
sysid = mavlink_msg_rally_fetch_point_get_target_system(msg);
|
|
compid = mavlink_msg_rally_fetch_point_get_target_component(msg);
|
|
break;
|
|
case MAVLINK_MSG_ID_RALLY_POINT:
|
|
sysid = mavlink_msg_rally_point_get_target_system(msg);
|
|
compid = mavlink_msg_rally_point_get_target_component(msg);
|
|
break;
|
|
case MAVLINK_MSG_ID_SET_MAG_OFFSETS:
|
|
sysid = mavlink_msg_set_mag_offsets_get_target_system(msg);
|
|
compid = mavlink_msg_set_mag_offsets_get_target_component(msg);
|
|
break;
|
|
case MAVLINK_MSG_ID_COMMAND_INT:
|
|
sysid = mavlink_msg_command_int_get_target_system(msg);
|
|
compid = mavlink_msg_command_int_get_target_component(msg);
|
|
break;
|
|
case MAVLINK_MSG_ID_COMMAND_LONG:
|
|
sysid = mavlink_msg_command_long_get_target_system(msg);
|
|
compid = mavlink_msg_command_long_get_target_component(msg);
|
|
break;
|
|
case MAVLINK_MSG_ID_FILE_TRANSFER_PROTOCOL:
|
|
sysid = mavlink_msg_file_transfer_protocol_get_target_system(msg);
|
|
compid = mavlink_msg_file_transfer_protocol_get_target_component(msg);
|
|
break;
|
|
case MAVLINK_MSG_ID_GPS_INJECT_DATA:
|
|
sysid = mavlink_msg_gps_inject_data_get_target_system(msg);
|
|
compid = mavlink_msg_gps_inject_data_get_target_component(msg);
|
|
break;
|
|
case MAVLINK_MSG_ID_LOG_ERASE:
|
|
sysid = mavlink_msg_log_erase_get_target_system(msg);
|
|
compid = mavlink_msg_log_erase_get_target_component(msg);
|
|
break;
|
|
case MAVLINK_MSG_ID_LOG_REQUEST_DATA:
|
|
sysid = mavlink_msg_log_request_data_get_target_system(msg);
|
|
compid = mavlink_msg_log_request_data_get_target_component(msg);
|
|
break;
|
|
case MAVLINK_MSG_ID_LOG_REQUEST_END:
|
|
sysid = mavlink_msg_log_request_end_get_target_system(msg);
|
|
compid = mavlink_msg_log_request_end_get_target_component(msg);
|
|
break;
|
|
case MAVLINK_MSG_ID_LOG_REQUEST_LIST:
|
|
sysid = mavlink_msg_log_request_list_get_target_system(msg);
|
|
compid = mavlink_msg_log_request_list_get_target_component(msg);
|
|
break;
|
|
case MAVLINK_MSG_ID_MISSION_ACK:
|
|
sysid = mavlink_msg_mission_ack_get_target_system(msg);
|
|
compid = mavlink_msg_mission_ack_get_target_component(msg);
|
|
break;
|
|
case MAVLINK_MSG_ID_MISSION_CLEAR_ALL:
|
|
sysid = mavlink_msg_mission_clear_all_get_target_system(msg);
|
|
compid = mavlink_msg_mission_clear_all_get_target_component(msg);
|
|
break;
|
|
case MAVLINK_MSG_ID_MISSION_COUNT:
|
|
sysid = mavlink_msg_mission_count_get_target_system(msg);
|
|
compid = mavlink_msg_mission_count_get_target_component(msg);
|
|
break;
|
|
case MAVLINK_MSG_ID_MISSION_ITEM:
|
|
sysid = mavlink_msg_mission_item_get_target_system(msg);
|
|
compid = mavlink_msg_mission_item_get_target_component(msg);
|
|
break;
|
|
case MAVLINK_MSG_ID_MISSION_ITEM_INT:
|
|
sysid = mavlink_msg_mission_item_int_get_target_system(msg);
|
|
compid = mavlink_msg_mission_item_int_get_target_component(msg);
|
|
break;
|
|
case MAVLINK_MSG_ID_MISSION_REQUEST:
|
|
sysid = mavlink_msg_mission_request_get_target_system(msg);
|
|
compid = mavlink_msg_mission_request_get_target_component(msg);
|
|
break;
|
|
case MAVLINK_MSG_ID_MISSION_REQUEST_LIST:
|
|
sysid = mavlink_msg_mission_request_list_get_target_system(msg);
|
|
compid = mavlink_msg_mission_request_list_get_target_component(msg);
|
|
break;
|
|
case MAVLINK_MSG_ID_MISSION_REQUEST_PARTIAL_LIST:
|
|
sysid = mavlink_msg_mission_request_partial_list_get_target_system(msg);
|
|
compid = mavlink_msg_mission_request_partial_list_get_target_component(msg);
|
|
break;
|
|
case MAVLINK_MSG_ID_MISSION_SET_CURRENT:
|
|
sysid = mavlink_msg_mission_set_current_get_target_system(msg);
|
|
compid = mavlink_msg_mission_set_current_get_target_component(msg);
|
|
break;
|
|
case MAVLINK_MSG_ID_MISSION_WRITE_PARTIAL_LIST:
|
|
sysid = mavlink_msg_mission_write_partial_list_get_target_system(msg);
|
|
compid = mavlink_msg_mission_write_partial_list_get_target_component(msg);
|
|
break;
|
|
case MAVLINK_MSG_ID_PARAM_REQUEST_LIST:
|
|
sysid = mavlink_msg_param_request_list_get_target_system(msg);
|
|
compid = mavlink_msg_param_request_list_get_target_component(msg);
|
|
break;
|
|
case MAVLINK_MSG_ID_PARAM_REQUEST_READ:
|
|
sysid = mavlink_msg_param_request_read_get_target_system(msg);
|
|
compid = mavlink_msg_param_request_read_get_target_component(msg);
|
|
break;
|
|
case MAVLINK_MSG_ID_PARAM_SET:
|
|
sysid = mavlink_msg_param_set_get_target_system(msg);
|
|
compid = mavlink_msg_param_set_get_target_component(msg);
|
|
break;
|
|
case MAVLINK_MSG_ID_PING:
|
|
sysid = mavlink_msg_ping_get_target_system(msg);
|
|
compid = mavlink_msg_ping_get_target_component(msg);
|
|
break;
|
|
case MAVLINK_MSG_ID_RC_CHANNELS_OVERRIDE:
|
|
sysid = mavlink_msg_rc_channels_override_get_target_system(msg);
|
|
compid = mavlink_msg_rc_channels_override_get_target_component(msg);
|
|
break;
|
|
case MAVLINK_MSG_ID_REQUEST_DATA_STREAM:
|
|
sysid = mavlink_msg_request_data_stream_get_target_system(msg);
|
|
compid = mavlink_msg_request_data_stream_get_target_component(msg);
|
|
break;
|
|
case MAVLINK_MSG_ID_SAFETY_SET_ALLOWED_AREA:
|
|
sysid = mavlink_msg_safety_set_allowed_area_get_target_system(msg);
|
|
compid = mavlink_msg_safety_set_allowed_area_get_target_component(msg);
|
|
break;
|
|
case MAVLINK_MSG_ID_SET_ATTITUDE_TARGET:
|
|
sysid = mavlink_msg_set_attitude_target_get_target_system(msg);
|
|
compid = mavlink_msg_set_attitude_target_get_target_component(msg);
|
|
break;
|
|
case MAVLINK_MSG_ID_SET_POSITION_TARGET_GLOBAL_INT:
|
|
sysid = mavlink_msg_set_position_target_global_int_get_target_system(msg);
|
|
compid = mavlink_msg_set_position_target_global_int_get_target_component(msg);
|
|
break;
|
|
case MAVLINK_MSG_ID_SET_POSITION_TARGET_LOCAL_NED:
|
|
sysid = mavlink_msg_set_position_target_local_ned_get_target_system(msg);
|
|
compid = mavlink_msg_set_position_target_local_ned_get_target_component(msg);
|
|
break;
|
|
case MAVLINK_MSG_ID_V2_EXTENSION:
|
|
sysid = mavlink_msg_v2_extension_get_target_system(msg);
|
|
compid = mavlink_msg_v2_extension_get_target_component(msg);
|
|
break;
|
|
case MAVLINK_MSG_ID_GIMBAL_REPORT:
|
|
sysid = mavlink_msg_gimbal_report_get_target_system(msg);
|
|
compid = mavlink_msg_gimbal_report_get_target_component(msg);
|
|
break;
|
|
case MAVLINK_MSG_ID_GIMBAL_CONTROL:
|
|
sysid = mavlink_msg_gimbal_control_get_target_system(msg);
|
|
compid = mavlink_msg_gimbal_control_get_target_component(msg);
|
|
break;
|
|
}
|
|
}
|
|
|