Added initial COT Sensor payloads to support UAV Tools integration for Arma Drones

.hemtt/project.toml

@@ -38,31 +38,28 @@ preset = "Hemtt"
 [hemtt.launch.default]
 workshop = [
   "450814997", # CBA_A3
-  "463939057", # ace
+  "463939057", # ACE
   "751965892", # ACRE2
-  "2522638637", # ACE3 Arsenal Extended - Core
+  "2522638637", # ACE Extended Arsenal
   "333310405", # Enhanced Movement
   "2034363662", # Enhanced Movement Rework
+  "2941986336", # Hatchet Interaction Framework - Stable Version
+  "1745501605", # Hatchet H-60 pack - Stable Version
   "843577117", # RHSUSAF
-  "3147473073", # TOTT Core
+  "843425103", # RHSAFRF
+  "843632231", # RHSSAF
+  "843593391", # RHSGREF
+  "1673456286", # 3CB Factions
   "623475643", # 3den Enhanced
-  "520618345", # Jbad
-  "1779063631", # Zeus Enhanced
-  "2397360831", # USAF Mod - Main
-  "2397376046", # USAF Mod - Utility
-  "3147476552", # TOTT Optics
-  "583496184", # CUP Terrains - Core
-  "2560276469", # Restrict Markers
-  "1858075458", # LAMBS_Danger.fsm
-  "3407948300", # JSRS SOUNDMOD 2025
-  "2834576684", # ITN - Illuminate The Night
-  "3375788189", # Immersion Cigs - Rewrite
-  "2095827925", # Brighter Flares
   "2257686620", # Blastcore Murr Edition
-  "2260572637", # BettIR NVG
+  "583496184", # CUP Terrains - Core
-  "3493557838", # Broad Spectrum Warfare
+  "3078351739", # Kunduz River
-  "1291778160", # Hellanmaa
+  "1858075458", # LAMBS_Danger.fsm
-  "3533734689", # FPV
+  "1808238502", # LAMBS_Suppression
+  "3425368881", # M4A1_URGI
+  "2268351256", # Tier One Weapons
+  "2560276469", # Restrict Markers
+  "3493557838" # Ballad of the Green Berets
 ]
 
 parameters = [

addons/client/dialog.hpp

@@ -10,79 +10,44 @@ class armatak_udp_socket_start_dialog {
     class armatak_gui_module_udp_socket_dialog_main_frame: RscBackground {
       idc = 16960;
       x = "0.386562 * safezoneW + safezoneX";
-      y = "0.357 * safezoneH + safezoneY";
+      y = "0.401 * safezoneH + safezoneY";
       w = "0.216563 * safezoneW";
-      h = "0.418 * safezoneH";
+      h = "0.242 * safezoneH";
       colorBackground[]={0,0,0,0.45};
     };
   };
   class Controls {
     class armatak_gui_module_udp_socket_dialog_address_edit: RscEdit {
       idc = 16961;
-      text = "192.168.15.121";
+      text = "168.15.0.3";
-      x = "0.391719 * safezoneW + safezoneX";
-      y = "0.401 * safezoneH + safezoneY";
-      w = "0.20625 * safezoneW";
-      h = "0.044 * safezoneH";
-      colorBackground[]={0,0,0,0.5};
-    };
-    class armatak_gui_module_udp_socket_dialog_gnss_port_edit: RscEdit {
-      idc = 16962;
-      text = "4349";
-      x = "0.391719 * safezoneW + safezoneX";
-      y = "0.478 * safezoneH + safezoneY";
-      w = "0.20625 * safezoneW";
-      h = "0.044 * safezoneH";
-      colorBackground[]={0,0,0,0.5};
-    };
-    class armatak_gui_module_udp_socket_dialog_mavlink_port_edit: RscEdit {
-      idc = 16967;
-      text = "14550";
-      x = "0.391719 * safezoneW + safezoneX";
-      y = "0.555 * safezoneH + safezoneY";
-      w = "0.20625 * safezoneW";
-      h = "0.044 * safezoneH";
-      colorBackground[]={0,0,0,0.5};
-    };
-    class armatak_gui_module_udp_socket_dialog_video_feed_url_edit: RscEdit {
-      idc = 16969;
-      text = "";
-      x = "0.391719 * safezoneW + safezoneX";
-      y = "0.632 * safezoneH + safezoneY";
-      w = "0.20625 * safezoneW";
-      h = "0.044 * safezoneH";
-      colorBackground[]={0,0,0,0.5};
-      tooltip = "Optional shared feed URL. If empty, the UAV 3DEN URL is used first, then a local RTP fallback.";
-    };
-    class armatak_gui_module_udp_socket_dialog_address_text: RscText {
-      idc = 16963;
-      text = "EUD's Address";
-      x = "0.391719 * safezoneW + safezoneX";
-      y = "0.368 * safezoneH + safezoneY";
-      w = "0.20625 * safezoneW";
-      h = "0.033 * safezoneH";
-    };
-    class armatak_gui_module_udp_socket_dialog_gnss_port_text: RscText {
-      idc = 16964;
-      text = "Network GNSS Port";
       x = "0.391719 * safezoneW + safezoneX";
       y = "0.445 * safezoneH + safezoneY";
       w = "0.20625 * safezoneW";
-      h = "0.033 * safezoneH";
+      h = "0.044 * safezoneH";
+      colorBackground[]={0,0,0,0.5};
     };
-    class armatak_gui_module_udp_socket_dialog_mavlink_port_text: RscText {
+    class armatak_gui_module_udp_socket_dialog_address_port_edit: RscEdit {
-      idc = 16968;
+      idc = 16962;
-      text = "Mavlink Port";
+      text = "4349";
       x = "0.391719 * safezoneW + safezoneX";
       y = "0.522 * safezoneH + safezoneY";
       w = "0.20625 * safezoneW";
+      h = "0.044 * safezoneH";
+      colorBackground[]={0,0,0,0.5};
+    };
+    class armatak_gui_module_udp_socket_dialog_address_text: RscText {
+      idc = 16963;
+      text = "Phone's Socket Local Address";
+      x = "0.391719 * safezoneW + safezoneX";
+      y = "0.412 * safezoneH + safezoneY";
+      w = "0.20625 * safezoneW";
       h = "0.033 * safezoneH";
     };
-    class armatak_gui_module_udp_socket_dialog_video_feed_url_text: RscText {
+    class armatak_gui_module_udp_socket_dialog_address_port_text: RscText {
-      idc = 16970;
+      idc = 16964;
-      text = "Video Feed URL (Optional)";
+      text = "Phone's Socket Local Port";
       x = "0.391719 * safezoneW + safezoneX";
-      y = "0.599 * safezoneH + safezoneY";
+      y = "0.489 * safezoneH + safezoneY";
       w = "0.20625 * safezoneW";
       h = "0.033 * safezoneH";
     };
@@ -91,7 +56,7 @@ class armatak_udp_socket_start_dialog {
       text = "Cancel";
       action = "closeDialog 2;";
       x = "0.551563 * safezoneW + safezoneX";
-      y = "0.709 * safezoneH + safezoneY";
+      y = "0.577 * safezoneH + safezoneY";
       w = "0.0464063 * safezoneW";
       h = "0.055 * safezoneH";
     };
@@ -100,7 +65,7 @@ class armatak_udp_socket_start_dialog {
       text = "Ok";
       action = QUOTE(call FUNC(startUDPSocket));
       x = "0.5 * safezoneW + safezoneX";
-      y = "0.709 * safezoneH + safezoneY";
+      y = "0.577 * safezoneH + safezoneY";
       w = "0.0464063 * safezoneW";
       h = "0.055 * safezoneH";
     };

addons/client/functions/fnc_startUDPSocket.sqf

@@ -2,7 +2,7 @@
 
 params ["_logic"];
 
-private _socket_is_running = player getVariable [QGVAR(eudConnected), false];
+_socket_is_running = player getVariable [QGVAR(eudConnected), false];
 
 if (_socket_is_running) exitWith {
 	["Socket is already running", "error", "UDP Socket"] call EFUNC(main,notify);
@@ -11,34 +11,20 @@ if (_socket_is_running) exitWith {
 
 disableSerialization;
 
-private _eud_address = ctrlText 16961;
+_udp_socket_instance_address = ctrlText 16961;
-private _gnss_port = ctrlText 16962;
+_udp_socket_instance_port = ctrlText 16962;
-private _mavlink_port = ctrlText 16967;
-private _video_feed_url = ctrlText 16969;
 
-private _udp_socket_fulladdress = _eud_address + ":" + _gnss_port;
+_udp_socket_fulladdress = ((_udp_socket_instance_address) + ":" + (_udp_socket_instance_port));
-private _mavlink_address = _eud_address + ":" + _mavlink_port;
 
 player setVariable [QGVAR(udp_socket_address), _udp_socket_fulladdress];
-player setVariable [QGVAR(mavlink_address), _mavlink_address];
-player setVariable [QGVAR(video_feed_url), trim _video_feed_url];
 player setVariable [QGVAR(eudConnected), true];
 
-private _advertised_video_uri = [objNull] call EFUNC(uav,resolveVideoUri);
-
 "armatak" callExtension ["udp_socket:start", [_udp_socket_fulladdress]];
-"armatak" callExtension ["uas:start_endpoint", [parseNumber _mavlink_port]];
-
-private _mdnsInstanceName = format ["ArmaTAK-%1", name player];
-"armatak" callExtension ["mdns:start_uas_advertisement", [_mdnsInstanceName, parseNumber _mavlink_port, _advertised_video_uri]];
-"armatak" callExtension ["log", [["info", format ["Client UDP socket started for %1, MAVLink target set to %2 and advertised video URI set to %3", _udp_socket_fulladdress, _mavlink_address, _advertised_video_uri]]]];
-
-call EFUNC(uav,startMavlinkBroadcast);
 
 [{
-	if !(player getVariable [QGVAR(eudConnected), false]) exitWith {};
+	if (player getVariable [QGVAR(eudConnected), false]) then {
-
 		"armatak" callExtension ["udp_socket:send_gps_cot", [player call FUNC(extractClientPosition)]];
+	};
 }, 0.5, []] call CBA_fnc_addPerFrameHandler;
 
 deleteVehicle _logic;

addons/main/Cfg3den.hpp

@@ -78,12 +78,12 @@ class Cfg3den {
             condition = "objectVehicle";
             typeName = "STRING";
           };
-          class armatak_attribute_marker_video_url {
+          class armatak_attribute_video_url {
-            displayName = "Video Feed URL";
+            displayName = "Video URL (RTSP)";
-            tooltip = "Shared UAV video URL. This per-vehicle value overrides the optional session video URL from Connect to EUD.";
+            tooltip = "RTSP stream URL for UAS Tool integration. When set, the drone will appear in the ATAK UAS Tool with FOV cone and video feed. Format: rtsp://address:port/path  (e.g. rtsp://192.168.1.10:8554/live/drone1). Leave empty to disable UAS Tool integration for this entity.";
-            property = "armatak_attribute_marker_video_url";
+            property = "armatak_attribute_video_url";
             control = "Edit";
-            expression = "_this setVariable ['armatak_attribute_marker_video_url',_value]";
+            expression = "_this setVariable ['armatak_attribute_video_url',_value]";
             defaultValue = "''";
             condition = "objectVehicle";
             typeName = "STRING";

addons/main/CfgFunctions.hpp

@@ -19,18 +19,12 @@ class CfgFunctions {
 			class send_marker_cot {
 				file = "\armatak\armatak\addons\main\functions\api\fn_send_marker_cot.sqf";
 			};
-			class send_uas_platform_cot {
-				file = "\armatak\armatak\addons\main\functions\api\fn_send_uas_platform_cot.sqf";
-			};
 			class send_uas_video_cot {
 				file = "\armatak\armatak\addons\main\functions\api\fn_send_uas_video_cot.sqf";
 			};
 			class send_uas_sensor_cot {
 				file = "\armatak\armatak\addons\main\functions\api\fn_send_uas_sensor_cot.sqf";
 			};
-			class set_uas_camera_override {
-				file = "\armatak\armatak\addons\main\functions\api\fn_set_uas_camera_override.sqf";
-			};
 			class stop_tcp_socket {
 				file = "\armatak\armatak\addons\main\functions\api\fn_stop_tcp_socket.sqf";
 			};
@@ -43,18 +37,12 @@ class CfgFunctions {
 			class extract_marker_callsign {
 				file = "\armatak\armatak\addons\main\functions\extract_data\fn_extract_marker_callsign.sqf";
 			};
-			class extract_marker_video_url {
-				file = "\armatak\armatak\addons\main\functions\extract_data\fn_extract_marker_video_url.sqf";
-			};
 			class extract_role {
 				file = "\armatak\armatak\addons\main\functions\extract_data\fn_extract_role.sqf";
 			};
 			class extract_sensor_data {
 				file = "\armatak\armatak\addons\main\functions\extract_data\fn_extract_sensor_data.sqf";
 			};
-			class extract_uas_camera_data {
-				file = "\armatak\armatak\addons\main\functions\extract_data\fn_extract_uas_camera_data.sqf";
-			};
 			class extract_unit_callsign {
 				file = "\armatak\armatak\addons\main\functions\extract_data\fn_extract_unit_callsign.sqf";
 			};
@@ -140,10 +128,6 @@ class CfgFunctions {
 			class convert_to_rut_mandol {
 				file = "\armatak\armatak\addons\main\functions\map\fn_convert_to_rut_mandol.sqf";
 			};
-			class convert_to_hellanmaa {
-				file = "\armatak\armatak\addons\main\functions\map\fn_convert_to_hellanmaa.sqf";
 		};
 	};
 };
-};
-

addons/main/XEH_postInit.sqf

@@ -13,9 +13,6 @@ addMissionEventHandler ["ExtensionCallback", {
 				};
 				case "EUD Disconnected": {
 					SETVAR(player,EGVAR(client,eudConnected),false);
-					call EFUNC(uav,stopMavlinkBroadcast);
-					"armatak" callExtension ["uas:stop_endpoint", []];
-					"armatak" callExtension ["mdns:stop", []];
 				};
 				default {};
 			};
@@ -28,52 +25,10 @@ addMissionEventHandler ["ExtensionCallback", {
 			
 			if (_function == "UDP Socket is not running") then {
 				SETVAR(player,EGVAR(client,eudConnected),false);
-				call EFUNC(uav,stopMavlinkBroadcast);
-				"armatak" callExtension ["uas:stop_endpoint", []];
-				"armatak" callExtension ["mdns:stop", []];
 			};
 
 			if (_function == "failed to bind UDP socket") then {
 				SETVAR(player,EGVAR(client,eudConnected),false);
-				call EFUNC(uav,stopMavlinkBroadcast);
-				"armatak" callExtension ["uas:stop_endpoint", []];
-				"armatak" callExtension ["mdns:stop", []];
-			};
-		};
-		case "MAVLINK UDP ERROR": {
-			_message = _function;
-			if (_data isNotEqualTo "") then {
-				_message = format ["%1: %2", _function, _data];
-			};
-
-			[_message, "warning", _name] call FUNC(notify);
-		};
-		case "MAVLINK UDP": {
-			private _history = missionNamespace getVariable ["armatak_uav_mavlink_callback_history", []];
-			_history pushBack [diag_tickTime, _function, _data];
-			if ((count _history) > 50) then {
-				_history deleteRange [0, (count _history) - 50];
-			};
-			missionNamespace setVariable ["armatak_uav_mavlink_callback_history", _history];
-			missionNamespace setVariable ["armatak_uav_last_mavlink_callback", [diag_tickTime, _function, _data]];
-
-			switch (_function) do {
-				case "COMMAND_LONG";
-				case "COMMAND_INT";
-				case "COMMAND_ACK";
-				case "MISSION_COUNT";
-				case "MISSION_ITEM";
-				case "MISSION_ITEM_INT";
-				case "MISSION_CLEAR_ALL";
-				case "MISSION_SET_CURRENT";
-				case "SET_HOME_POSITION";
-				case "SET_MODE";
-				case "SET_POSITION_TARGET_GLOBAL_INT";
-				case "MANUAL_CONTROL": {
-					"armatak" callExtension ["log", [["info", format ["MAVLINK UDP CALLBACK %1 %2", _function, _data]]]];
-					[_function, _data] call EFUNC(uav,handleMavlinkCallback);
-				};
-				default {};
 			};
 		};
 		case "TCP SOCKET": {
@@ -90,12 +45,6 @@ addMissionEventHandler ["ExtensionCallback", {
 		case "VIDEO": {
 			[_function, "success", _name] call FUNC(notify);
 		};
-		case "MDNS": {
-			[_function, "success", _name] call FUNC(notify);
-		};
-		case "MDNS ERROR": {
-			[_function, "warning", _name] call FUNC(notify);
-		};
 		case "VIDEO ERROR": {
 			[_function, "error", _name] call FUNC(notify);
 

addons/main/functions/api/fn_send_drone_cot.sqf

@@ -4,4 +4,34 @@
 
 params["_drone"];
 
-[_drone] call armatak_fnc_send_uas_platform_cot;
+private _atak_role = "a-f-A";
+private _atak_callsign = [_drone] call armatak_fnc_extract_marker_callsign;
+
+switch (side _drone) do {
+	case "WEST": {
+		_atak_role = "a-f-A-M-F-Q"
+	};
+	case "EAST": {
+		_atak_role = "a-h-A-M-F-Q"
+	};
+	case "INDEPENDENT": {
+		_atak_role = "a-n-A-M-F-Q"
+	};
+	case "CIVILIAN": {
+		_atak_role = "a-f-A-C"
+	};
+	default {
+		_atak_role = "a-f-A-M-F-Q"
+	};
+};
+
+_pre_defined_role = _drone getVariable "_atak_group_role";
+
+if (!isNil "_pre_defined_role") then {
+	_callsign = _pre_defined_role;
+};
+
+_cot = [_drone, _atak_role, _atak_callsign] call armatak_fnc_send_marker_cot;
+
+[_drone] call armatak_fnc_send_uas_video_cot;
+[_drone] call armatak_fnc_send_uas_sensor_cot;

addons/main/functions/api/fn_send_uas_platform_cot.sqf

@@ -1,77 +0,0 @@
-params ["_drone"];
-
-private _uuid = _drone call armatak_fnc_extract_uuid;
-private _uavControl = UAVControl _drone;
-private _controller = _uavControl param [0, objNull];
-private _controller_uid = if (!isNull _controller) then { [_controller] call armatak_fnc_extract_uuid } else { _drone getVariable ["armatak_uas_controller_uid", _uuid] };
-private _callsign = [_drone] call armatak_fnc_extract_marker_callsign;
-private _video_url = [_drone] call armatak_fnc_extract_marker_video_url;
-
-private _atak_role = "a-f-A-M-H-Q";
-switch (side _drone) do {
-    case west: {
-        _atak_role = "a-f-A-M-H-Q";
-    };
-    case east: {
-        _atak_role = "a-h-A-M-H-Q";
-    };
-    case independent: {
-        _atak_role = "a-n-A-M-H-Q";
-    };
-    case civilian: {
-        _atak_role = "a-f-A-C";
-    };
-    default {
-        _atak_role = "a-f-A-M-H-Q";
-    };
-};
-
-private _position = _drone call armatak_client_fnc_extractClientPosition;
-private _lat = _position select 1;
-private _lon = _position select 2;
-private _hae = _position select 3;
-private _course = _position select 5;
-private _speed = _position select 6;
-
-private _cameraData = [_drone] call armatak_fnc_extract_uas_camera_data;
-private _azimuth = _cameraData select 0;
-private _elevation = _cameraData select 1;
-private _fov = _cameraData select 2;
-private _range = _cameraData select 3;
-private _vfov = _drone getVariable ["armatak_uas_vfov", _fov];
-
-private _yaw = round (getDir _drone);
-private _pitch = (vectorDir _drone) select 2;
-private _roll = (vectorUp _drone) select 0;
-private _isFlying = parseNumber (isEngineOn _drone);
-private _hal = ((getPosATL _drone) select 2) max 0;
-private _vehicleType = if (_video_url == "") then {
-    typeOf _drone
-} else {
-    format ["%1|armatak_video_url=%2", typeOf _drone, _video_url]
-};
-
-private _payload = [
-    _uuid,
-    _atak_role,
-    _callsign,
-    _lat,
-    _lon,
-    _hae,
-    _course,
-    _speed,
-    _azimuth,
-    _elevation,
-    _fov,
-    _vfov,
-    _range,
-    _yaw,
-    _pitch,
-    _roll,
-    _hal,
-    _vehicleType,
-    _isFlying,
-    _controller_uid
-];
-
-"armatak" callExtension ["tcp_socket:cot:uas_platform", [_payload]];

addons/main/functions/api/fn_send_uas_sensor_cot.sqf

@@ -1,22 +1,55 @@
+// function name: armatak_fnc_send_uas_sensor_cot
+// function author: Valmo / ArmaTAK contributors
+// function description:
+//   Sends a b-m-p-s-p-loc CoT event every router tick (1 s) for a drone.
+//   This is the "sensor position" event consumed by the ATAK UAS Tool to:
+//     - Draw the FOV cone on the moving map.
+//     - Compute four-corners for AR marker overlay on the video feed.
+//     - Show the SPoI (Sensor Point of Interest) crosshair.
+//
+//   The event references the drone's b-i-v video endpoint via the drone UUID,
+//   so armatak_fnc_send_uas_video_cot must also be called for the same drone.
+//
+//   Exits silently when "armatak_attribute_video_url" is not set, which keeps
+//   the behavior identical to the old fn_send_drone_cot for drones without a
+//   configured video stream.
+//
+// Arguments:
+//   0: _drone <OBJECT>  The drone object.
+//
+// Return value: none
+
 params ["_drone"];
 
-private _video_url = [_drone] call armatak_fnc_extract_marker_video_url;
+private _video_url = _drone getVariable ["armatak_attribute_video_url", ""];
 if (_video_url == "") exitWith {};
 
 private _uuid       = _drone call armatak_fnc_extract_uuid;
-private _video_uid = _uuid + "-video";
 private _sensor_uid = _uuid + "-sensor";
 private _callsign   = [_drone] call armatak_fnc_extract_marker_callsign;
 
-private _position = _drone call armatak_client_fnc_extractClientPosition;
+private _pos = (getPos _drone) call armatak_client_fnc_convertClientLocation;
-private _lat = _position select 1;
+private _lat = _pos select 0;
-private _lon = _position select 2;
+private _lon = _pos select 1;
-private _hae = _position select 3;
+private _hae = _pos select 2;
 
-private _cameraData = [_drone] call armatak_fnc_extract_uas_camera_data;
+private _azimuth = parseNumber ((getDir _drone) toFixed 0);
-private _azimuth = _cameraData select 0;
-private _fov = _cameraData select 2;
-private _range = _cameraData select 3;
 
-private _payload = [_sensor_uid, _video_uid, _callsign, _lat, _lon, _hae, _azimuth, _fov, _range];
+private _allTurrets = [_drone, false] call BIS_fnc_allTurrets;
+if (count _allTurrets > 0) then {
+    private _firstTurretPath = _allTurrets select 0;
+    private _turretWeapons   = _drone weaponsTurret _firstTurretPath;
+    if (_turretWeapons isNotEqualTo []) then {
+        private _tDir = _drone weaponDirection (_turretWeapons select 0);
+        if (!((_tDir select 0) == 0 && (_tDir select 1) == 0)) then {
+            _azimuth = round (((_tDir select 0) atan2 (_tDir select 1) + 360) mod 360);
+        };
+    };
+};
+
+private _fov = _drone getVariable ["armatak_uas_fov", 60];
+
+private _range = round (((getPosATL _drone) select 2) max 1);
+
+private _payload = [_sensor_uid, _uuid, _callsign, _lat, _lon, _hae, _azimuth, _fov, _range];
 "armatak" callExtension ["tcp_socket:cot:uas_sensor", [_payload]];

addons/main/functions/api/fn_send_uas_video_cot.sqf

@@ -1,20 +1,30 @@
+// function name: armatak_fnc_send_uas_video_cot
+// function author: Valmo / ArmaTAK contributors
+// function description:
+//   Sends a b-i-v CoT event that declares the RTSP video endpoint for a drone.
+//   The ATAK UAS Tool picks this up and shows the drone in its UAS list with
+//   the associated video feed available for playback.
+//
+//   The drone entity MUST have the variable "armatak_attribute_video_url" set
+//   to a valid RTSP URL, e.g.:
+//       _drone setVariable ["armatak_attribute_video_url", "rtsp://192.168.1.10:8554/live/drone1"];
+//   or via the 3DEN attribute "Video URL (RTSP)" in the ARMA Team Awareness Kit
+//   attribute category.
+//
+//   If the variable is absent or empty the function exits silently.
+//
+// Arguments:
+//   0: _drone <OBJECT>  The drone object.
+//
+// Return value: none
+
 params ["_drone"];
 
-private _video_url = [_drone] call armatak_fnc_extract_marker_video_url;
+private _video_url = _drone getVariable ["armatak_attribute_video_url", ""];
 if (_video_url == "") exitWith {};
 
 private _uuid     = _drone call armatak_fnc_extract_uuid;
-private _video_uid = _uuid + "-video";
 private _callsign = [_drone] call armatak_fnc_extract_marker_callsign;
 
-private _signature = format ["%1|%2|%3", _video_uid, _callsign, _video_url];
+private _payload = [_uuid, _callsign, _video_url];
-private _nextRefreshAt = _drone getVariable ["armatak_next_uas_video_refresh_at", 0];
-private _lastSignature = _drone getVariable ["armatak_last_uas_video_signature", ""];
-
-if (_signature == _lastSignature && {diag_tickTime < _nextRefreshAt}) exitWith {};
-
-_drone setVariable ["armatak_last_uas_video_signature", _signature, false];
-_drone setVariable ["armatak_next_uas_video_refresh_at", diag_tickTime + 300, false];
-
-private _payload = [_video_uid, _callsign, _video_url];
 "armatak" callExtension ["tcp_socket:cot:uas_video", [_payload]];

addons/main/functions/api/fn_set_uas_camera_override.sqf

@@ -1,9 +0,0 @@
-params ["_drone", ["_cameraData", []]];
-
-if (isNull _drone) exitWith {};
-
-if ((_cameraData isEqualType []) && {(count _cameraData) >= 6}) then {
-    _drone setVariable ["armatak_uas_camera_data_override", _cameraData + [serverTime], false];
-} else {
-    _drone setVariable ["armatak_uas_camera_data_override", nil, false];
-};

addons/main/functions/extract_data/fn_extract_marker_callsign.sqf

@@ -5,45 +5,29 @@
 params["_unit"];
 
 private _callsign = "";
-private _displayName = localize (getText (configOf _unit >> "displayName"));
-private _markerCallsignOverride = _unit getVariable ["armatak_attribute_marker_callsign", ""];
-
-if (_markerCallsignOverride isNotEqualTo "") exitWith {
-	_markerCallsignOverride
-};
-
-if (_displayName isEqualTo "") then {
-	_displayName = typeOf _unit;
-};
-
-private _vehicleName = vehicleVarName _unit;
 
 if ((([_unit] call BIS_fnc_objectType) select 0) == "Vehicle") then {
-	_callsign = [_displayName, _vehicleName] select (_vehicleName isNotEqualTo "");
+	_callsign = getText (configOf _unit >> "displayName");
 
 	if (!isNull driver _unit) then {
-		_callsign = _displayName + " | " + ([name (driver _unit)] call armatak_fnc_shorten_name);
+		_callsign = getText (configOf _unit >> "displayName") + " | " + ([name (driver _unit)] call armatak_fnc_shorten_name);
 	};
 };
 
 if (unitIsUAV _unit) then {
-	_callsign = [_displayName, _vehicleName] select (_vehicleName isNotEqualTo "");
+	_callsign = getText (configOf _unit >> "displayName");
-
-	private _uavControl = UAVControl _unit;
-	private _controller = _uavControl param [0, objNull];
-	if (!isNull _controller) then {
-		_callsign = _callsign + " | " + ([name _controller] call armatak_fnc_shorten_name);
-	};
 
 	if (isUAVConnected _unit) then {
-		_callsign = _callsign + " [ON]";
+		_callsign = (_callsign) + "[ON]";
 	} else {
-		_callsign = _callsign + " [OFF]";
+		_callsign = (_callsign) + "[OFF]";
 	}
 };
 
-if (_callsign isEqualTo "") then {
+armatak_attribute_marker_callsign = _unit getVariable "armatak_attribute_marker_callsign";
-	_callsign = _displayName;
+
+if (!isNil "armatak_attribute_marker_callsign" or armatak_attribute_marker_callsign != '') then {
+	_callsign = armatak_attribute_marker_callsign;
 };
 
 _callsign

addons/main/functions/extract_data/fn_extract_role.sqf

@@ -7,7 +7,13 @@ params["_unit"];
 private _affiliation = "f";
 private _type = "G";
 private _role = "a-f-G-U-C-I";
-private _side = _unit getVariable ["armatak_current_side", side _unit];
+private _side = side _unit;
+
+if (isNil {
+	_unit getVariable "armatak_current_side"
+}) then {
+	_side = _unit getVariable "armatak_current_side";
+};
 
 switch (str _side) do {
 	case "WEST": {

addons/main/functions/extract_data/fn_extract_sensor_data.sqf

@@ -3,28 +3,25 @@ params["_unit"];
 _target = getSensorTargets (_unit);
 
 {
-	private _targetUnit = _x select 0;
+	_unit = _x select 0;
 	_position = _x select 1;
 	_status = _x select 2;
-	private _targetType = toLower (typeOf _targetUnit);
 
-	if ((_targetType find "lasertarget") < 0) then {
 	if (isNil {
-			_targetUnit getVariable "armatak_current_side"
+		_unit getVariable "armatak_current_side"
 	}) then {
-			_targetUnit setVariable ["armatak_current_side", side _targetUnit];
+		_unit setVariable ["armatak_current_side", side _unit];
 	};
 
-		if (_status != "destroyed" && !(_targetUnit in armatak_server_syncedUnits)) then {
+	if (_status != "destroyed" && !(_unit in armatak_server_syncedUnits)) then {
-			_unit_position = _targetUnit call armatak_client_fnc_extractClientPosition;
+		_unit_position = _unit call armatak_client_fnc_extractClientPosition;
 
-			_uuid = _targetUnit call armatak_fnc_extract_uuid;
+		_uuid = _unit call armatak_fnc_extract_uuid;
-			_type = _targetUnit call armatak_fnc_extract_role;
+		_type = _unit call armatak_fnc_extract_role;
-			_callsign = getText (configOf _targetUnit >> "displayName");
+		_callsign = getText (configOf _unit >> "displayName");
 
 		_marker_cot = [_uuid, _type, _unit_position select 1, _unit_position select 2, _unit_position select 3, _callsign, _unit_position select 5, _unit_position select 6];
 
 		"armatak" callExtension ["tcp_socket:cot:marker", [_marker_cot]];
 	};
-	};
 } forEach _target;

addons/main/functions/extract_data/fn_extract_uas_camera_data.sqf

@@ -1,143 +0,0 @@
-params ["_drone", ["_cameraMode", "turret"]];
-
-private _override = _drone getVariable ["armatak_uas_camera_data_override", []];
-private _isLocalController = hasInterface && {!isNull player} && {(getConnectedUAV player) isEqualTo _drone};
-
-if (!_isLocalController && {_override isEqualType []} && {(count _override) >= 7}) then {
-    private _updatedAt = _override param [6, -1000];
-    if ((time - _updatedAt) <= 5) exitWith {
-        private _overrideSpiAsl = _override param [4, []];
-        private _overrideSpiGeo = _override param [5, []];
-        _drone setVariable ["armatak_uas_spi_asl", _overrideSpiAsl, false];
-        _drone setVariable ["armatak_uas_spi_geo", _overrideSpiGeo, false];
-        _override select [0, 6]
-    };
-};
-
-private _defaultFov = _drone getVariable ["armatak_uas_fov", 60];
-private _maxRange = _drone getVariable ["armatak_uas_max_range", 15000];
-private _originASL = getPosASL _drone;
-private _originAGL = ASLToAGL _originASL;
-private _cameraDir = [];
-private _spiASL = [];
-private _slantRange = 0;
-
-if (_cameraMode isNotEqualTo "fpv") then {
-    private _laserTarget = laserTarget _drone;
-    if (!isNull _laserTarget) then {
-        private _laserTargetWorld = getPosWorld _laserTarget;
-        private _laserTargetAslZ = (getPosASL _laserTarget) select 2;
-        _spiASL = [_laserTargetWorld select 0, _laserTargetWorld select 1, _laserTargetAslZ];
-        _cameraDir = _spiASL vectorDiff _originASL;
-        _slantRange = _originASL vectorDistance _spiASL;
-    };
-};
-
-if (_cameraDir isEqualTo [] && {_cameraMode isNotEqualTo "fpv"}) then {
-    private _uavControl = UAVControl _drone;
-    private _controlledTurretPath = _uavControl param [1, []];
-    private _candidateTurrets = [];
-
-    if ((_controlledTurretPath isEqualType []) && {_controlledTurretPath isNotEqualTo []}) then {
-        _candidateTurrets pushBack _controlledTurretPath;
-    };
-
-    {
-        if !(_x in _candidateTurrets) then {
-            _candidateTurrets pushBack _x;
-        };
-    } forEach (allTurrets _drone);
-
-    {
-        private _turretWeapons = _drone weaponsTurret _x;
-        if (_turretWeapons isNotEqualTo []) exitWith {
-            private _weapon = _turretWeapons select 0;
-            private _weaponDirection = _drone weaponDirection _weapon;
-            if (_weaponDirection isNotEqualTo [0, 0, 0]) then {
-                _cameraDir = _weaponDirection;
-            };
-        };
-    } forEach _candidateTurrets;
-};
-
-if (_cameraDir isEqualTo []) then {
-    _cameraDir = vectorDirVisual _drone;
-};
-
-private _dirMagnitude = vectorMagnitude _cameraDir;
-if (_dirMagnitude <= 0) then {
-    private _fallbackAzimuth = getDir _drone;
-    _cameraDir = [sin _fallbackAzimuth, cos _fallbackAzimuth, -1];
-    _dirMagnitude = vectorMagnitude _cameraDir;
-};
-
-_cameraDir = _cameraDir vectorMultiply (1 / _dirMagnitude);
-
-private _dirX = _cameraDir select 0;
-private _dirY = _cameraDir select 1;
-private _dirZ = _cameraDir select 2;
-private _horizontalMagnitude = sqrt ((_dirX * _dirX) + (_dirY * _dirY));
-
-private _azimuth = (((_dirX atan2 _dirY) + 360) mod 360);
-private _elevation = (_dirZ atan2 (_horizontalMagnitude max 0.001));
-
-if (_spiASL isEqualTo []) then {
-    private _altitudeAGL = (_originAGL select 2) max 0.1;
-    private _probeASL = _originASL vectorAdd (_cameraDir vectorMultiply _maxRange);
-
-    if (_dirZ < -0.01 && {terrainIntersectASL [_originASL, _probeASL]}) then {
-        private _near = _originASL;
-        private _far = _probeASL;
-
-        for "_i" from 0 to 24 do {
-            private _mid = [
-                ((_near select 0) + (_far select 0)) / 2,
-                ((_near select 1) + (_far select 1)) / 2,
-                ((_near select 2) + (_far select 2)) / 2
-            ];
-
-            if (terrainIntersectASL [_originASL, _mid]) then {
-                _far = _mid;
-            } else {
-                _near = _mid;
-            };
-        };
-
-        _spiASL = _far;
-        _slantRange = _originASL vectorDistance _spiASL;
-    } else {
-        private _verticalComponent = abs _dirZ;
-
-        if (_verticalComponent > 0.01) then {
-            _slantRange = (_altitudeAGL / _verticalComponent) min _maxRange;
-        } else {
-            _slantRange = _maxRange;
-        };
-
-        _slantRange = _slantRange max 1;
-        _spiASL = _originASL vectorAdd (_cameraDir vectorMultiply _slantRange);
-        _spiASL set [2, getTerrainHeightASL [_spiASL select 0, _spiASL select 1]];
-    };
-};
-
-if (_slantRange <= 0) then {
-    _slantRange = (_originASL vectorDistance _spiASL) max 1;
-};
-
-private _spiAgl = ASLToAGL _spiASL;
-private _spiWorld = [_spiAgl select 0, _spiAgl select 1, (_spiAgl select 2) max 0];
-private _spiGeo = _spiWorld call armatak_client_fnc_convertClientLocation;
-
-_drone setVariable ["armatak_uas_spi_asl", _spiASL, false];
-_drone setVariable ["armatak_uas_spi_geo", _spiGeo, false];
-
-[
-    round _azimuth,
-    round _elevation,
-    round _defaultFov,
-    round (_slantRange max 1),
-    _spiASL,
-    _spiGeo
-]
-
-

addons/main/functions/extract_data/fn_extract_unit_callsign.sqf

@@ -20,10 +20,10 @@ if (side _unit == east) then {
 	_callsign = getText (configOf _unit >> "displayName");
 };
 
-private _unitCallsignOverride = _unit getVariable ["armatak_attribute_unit_callsign", ""];
+armatak_attribute_unit_callsign = _unit getVariable "armatak_attribute_unit_callsign";
 
-if (_unitCallsignOverride isNotEqualTo "") then {
+if (!isNil "armatak_attribute_unit_callsign" or armatak_attribute_unit_callsign != '') then {
-	_callsign = _unitCallsignOverride;
+	_callsign = armatak_attribute_unit_callsign;
 };
 
 _callsign

addons/server/functions/fnc_startCotRouter.sqf

@@ -25,16 +25,6 @@ GVAR(syncedUnits) = missionNamespace getVariable "armatak_server_syncedUnits";
 				[_x, _callsign, _group_name, _group_role] call armatak_fnc_send_eud_cot;
 				[_x] call armatak_fnc_send_digital_pointer_cot;
 			};
-			case (unitIsUAV _x): {
-				if !(_x getVariable ["armatak_uav_mavlink_broadcasting", false]) then {
-					_atak_type = [_x] call armatak_fnc_extract_role;
-					_callsign = [_x] call armatak_fnc_extract_marker_callsign;
-
-					[_x, _atak_type, _callsign] call armatak_fnc_send_drone_cot;
-					[_x] call armatak_fnc_send_digital_pointer_cot;
-					_x call armatak_fnc_extract_sensor_data;
-				};
-			};
 			case ((_objectType select 0) == "Vehicle"): {
 				_atak_type = [_x] call armatak_fnc_extract_role;
 				_callsign = [_x] call armatak_fnc_extract_marker_callsign;
@@ -43,7 +33,6 @@ GVAR(syncedUnits) = missionNamespace getVariable "armatak_server_syncedUnits";
 				_x call armatak_fnc_extract_sensor_data;
 			};
 			case ((_objectType select 0) == "VehicleAutonomous"): {
-				if !(_x getVariable ["armatak_uav_mavlink_broadcasting", false]) then {
 				_atak_type = [_x] call armatak_fnc_extract_role;
 				_callsign = [_x] call armatak_fnc_extract_marker_callsign;
 
@@ -52,7 +41,6 @@ GVAR(syncedUnits) = missionNamespace getVariable "armatak_server_syncedUnits";
 				_x call armatak_fnc_extract_sensor_data;
 			};
 		};
-		};
 	} forEach GVAR(syncedUnits);
 }, 1, []] call CBA_fnc_addPerFrameHandler;
 

addons/uav/$PBOPREFIX$

@@ -1 +0,0 @@
-armatak\armatak\addons\uav

addons/uav/CfgEventHandlers.hpp

@@ -1,17 +0,0 @@
-class Extended_PreStart_EventHandlers {
-    class ADDON {
-        init = QUOTE(call COMPILE_SCRIPT(XEH_preStart));
-    };
-};
-
-class Extended_PreInit_EventHandlers {
-    class ADDON {
-        init = QUOTE(call COMPILE_SCRIPT(XEH_preInit));
-    };
-};
-
-class Extended_PostInit_EventHandlers {
-    class ADDON {
-        init = QUOTE(call COMPILE_SCRIPT(XEH_postInit));
-    };
-};

addons/uav/XEH_PREP.hpp

@@ -1,6 +0,0 @@
-PREP(startMavlinkBroadcast);
-PREP(stopMavlinkBroadcast);
-PREP(updateMavlinkBroadcast);
-PREP(resolveVideoUri);
-PREP(handleMavlinkCallback);
-PREP(parseMavlinkCallbackData);

addons/uav/XEH_postInit.sqf

@@ -1,5 +0,0 @@
-#include "script_component.hpp"
-
-if (!hasInterface) exitWith {};
-
-SETVAR(player,GVAR(mavlinkPFH),-1);

addons/uav/XEH_preInit.sqf

@@ -1,9 +0,0 @@
-#include "script_component.hpp"
-
-ADDON = false;
-
-PREP_RECOMPILE_START;
-#include "XEH_PREP.hpp"
-PREP_RECOMPILE_END;
-
-ADDON = true;

addons/uav/XEH_preStart.sqf

@@ -1,3 +0,0 @@
-#include "script_component.hpp"
-
-#include "XEH_PREP.hpp"

addons/uav/config.cpp

@@ -1,20 +0,0 @@
-#include "script_component.hpp"
-
-class CfgPatches {
-  class ADDON {
-    name = COMPONENT_NAME;
-    units[] = {};
-    weapons[] = {};
-    requiredAddons[] = {
-        "cba_main",
-        "ace_main",
-        "armatak_main",
-        "armatak_client"
-      };
-    requiredVersion = REQUIRED_VERSION;
-    author = PROJECT_AUTHOR;
-    url = "https://github.com/valmojr/armatak";
-  };
-};
-
-#include "CfgEventHandlers.hpp"

addons/uav/functions/fnc_handleMavlinkCallback.sqf

@@ -1,382 +0,0 @@
-#include "..\script_component.hpp"
-
-params ["_function", ["_data", "", [""]]];
-
-if (!hasInterface) exitWith {};
-
-private _payload = [_data] call FUNC(parseMavlinkCallbackData);
-private _uav = getConnectedUAV player;
-if (isNull _uav) then {
-	_uav = player getVariable [QGVAR(broadcastingUav), objNull];
-};
-
-if (isNull _uav) exitWith {
-	"armatak" callExtension ["log", [["warn", format ["Ignoring MAVLINK UDP callback %1 because no UAV is connected: %2", _function, _data]]]];
-};
-
-private _number = {
-	params ["_key", ["_default", 0]];
-	private _raw = _payload getOrDefault [_key, str _default];
-	private _value = parseNumber _raw;
-	if (!finite _value) exitWith {_default};
-	_value
-};
-
-private _uavGroup = {
-	params ["_vehicle"];
-	private _crew = crew _vehicle;
-	if (_crew isEqualTo []) exitWith {grpNull};
-	group (_crew select 0)
-};
-
-private _clearWaypoints = {
-	params ["_group"];
-	if (isNull _group) exitWith {};
-	for "_i" from ((count waypoints _group) - 1) to 0 step -1 do {
-		deleteWaypoint [_group, _i];
-	};
-};
-
-private _clearUavRoute = {
-	private _group = [_uav] call _uavGroup;
-	if (isNull _group) exitWith {false};
-	[_group] call _clearWaypoints;
-	_uav setVariable ["armatak_uas_mission_items", [], true];
-	true
-};
-
-private _geoToAtl = {
-	params ["_vehicle", "_lat", "_lon", ["_alt", -1]];
-
-	private _current = [_vehicle] call EFUNC(client,extractClientPosition);
-	private _currentLat = _current select 1;
-	private _currentLon = _current select 2;
-	private _currentAtl = getPosATL _vehicle;
-
-	private _northM = (_lat - _currentLat) * 111320;
-	private _eastM = (_lon - _currentLon) * (111320 * (cos _currentLat));
-
-	[
-		(_currentAtl select 0) + _eastM,
-		(_currentAtl select 1) + _northM,
-		if (_alt >= 0) then {_alt} else {_currentAtl select 2}
-	]
-};
-
-private _commandMove = {
-	params ["_vehicle", "_positionAtl", ["_type", "MOVE"], ["_radius", 80], ["_completion", 50]];
-
-	private _group = [_vehicle] call _uavGroup;
-	if (isNull _group) exitWith {false};
-
-	[_group] call _clearWaypoints;
-
-	_vehicle engineOn true;
-	_vehicle setVariable ["armatak_uas_armed", true, true];
-	_vehicle setFuel ((fuel _vehicle) max 0.1);
-	_vehicle flyInHeight ((_positionAtl select 2) max 10);
-	_vehicle doMove _positionAtl;
-
-	private _wp = _group addWaypoint [_positionAtl, 0];
-	_wp setWaypointType _type;
-	_wp setWaypointBehaviour "CARELESS";
-	_wp setWaypointCombatMode "BLUE";
-	_wp setWaypointSpeed "NORMAL";
-	_wp setWaypointCompletionRadius _completion;
-
-	if (_type == "LOITER") then {
-		_wp setWaypointLoiterRadius (_radius max 25);
-		_wp setWaypointLoiterType "CIRCLE_L";
-	};
-
-	true
-};
-
-private _appendMissionWaypoint = {
-	params ["_vehicle", "_positionAtl", "_command", "_seq", ["_radius", 80]];
-
-	private _group = [_vehicle] call _uavGroup;
-	if (isNull _group) exitWith {false};
-
-	private _type = switch (_command) do {
-		case 17;
-		case 18;
-		case 19;
-		case 31: {"LOITER"};
-		case 21: {"MOVE"};
-		default {"MOVE"};
-	};
-
-	private _wp = _group addWaypoint [_positionAtl, 0];
-	_wp setWaypointType _type;
-	_wp setWaypointBehaviour "CARELESS";
-	_wp setWaypointCombatMode "BLUE";
-	_wp setWaypointSpeed "NORMAL";
-	_wp setWaypointCompletionRadius 35;
-
-	if (_type == "LOITER") then {
-		_wp setWaypointLoiterRadius (_radius max 25);
-		_wp setWaypointLoiterType "CIRCLE_L";
-	};
-	if (_command == 21) then {
-		_wp setWaypointStatements ["true", "(vehicle this) land 'LAND'"];
-	};
-
-	private _items = _vehicle getVariable ["armatak_uas_mission_items", []];
-	_items pushBack [_seq, _command, _positionAtl];
-	_vehicle setVariable ["armatak_uas_mission_items", _items, true];
-
-	true
-};
-
-private _commandName = _payload getOrDefault ["command_name", "UNKNOWN"];
-private _command = [_payload getOrDefault ["command", "-1"]] call BIS_fnc_parseNumber;
-private _callsign = [_uav] call armatak_fnc_extract_marker_callsign;
-
-private _applySpeed = {
-	params ["_speed"];
-	if (_speed <= 0) exitWith {false};
-	_uav limitSpeed _speed;
-	systemChat format ["ATAK SPEED %1m/s %2", round _speed, _callsign];
-	true
-};
-
-private _applyMode = {
-	params ["_mode"];
-
-	switch (_mode) do {
-		case 4: {
-			_uav engineOn true;
-			_uav setVariable ["armatak_uas_armed", true, true];
-			_uav setFuel ((fuel _uav) max 0.1);
-			systemChat format ["ATAK GUIDED %1", _callsign];
-		};
-		case 5: {
-			private _pos = getPosATL _uav;
-			[_uav, _pos, "LOITER", 80, 25] call _commandMove;
-			systemChat format ["ATAK LOITER %1", _callsign];
-		};
-		case 6;
-		case 21;
-		case 27: {
-			private _home = _uav getVariable ["armatak_uas_home_atl", getPosATL _uav];
-			_home set [2, ((_home select 2) max 60)];
-			[_uav, _home, "MOVE", 80, 60] call _commandMove;
-			systemChat format ["ATAK RTL %1", _callsign];
-		};
-		case 9: {
-			private _pos = getPosATL _uav;
-			_pos set [2, 0];
-			[_uav, _pos, "MOVE", 30, 20] call _commandMove;
-			_uav flyInHeight 0;
-			systemChat format ["ATAK LAND %1", _callsign];
-		};
-		default {
-			"armatak" callExtension ["log", [["info", format ["Unhandled MAVLINK mode %1 for UAV %2", _mode, _uav]]]];
-		};
-	};
-};
-
-private _setHomeFromGeo = {
-	params ["_lat", "_lon", "_alt"];
-	if (_lat == 0 && {_lon == 0}) exitWith {false};
-	private _homeAtl = [_uav, _lat, _lon, _alt] call _geoToAtl;
-	_uav setVariable ["armatak_uas_home_atl", _homeAtl, true];
-	_uav setVariable ["armatak_uas_home_geo", [_lat, _lon, _alt], true];
-	systemChat format ["ATAK HOME %1", _callsign];
-	true
-};
-
-switch (_function) do {
-	case "COMMAND_LONG": {
-		switch (_command) do {
-			case 176: {
-				private _mode = ["param2", -1] call _number;
-				if (_mode < 0) then {
-					_mode = ["param1", -1] call _number;
-				};
-				[_mode] call _applyMode;
-			};
-			case 178: {
-				private _speed = ["param2", -1] call _number;
-				if (_speed <= 0) then {
-					_speed = ["param1", -1] call _number;
-				};
-				[_speed] call _applySpeed;
-			};
-			case 179: {
-				private _useCurrent = (["param1", 0] call _number) >= 1;
-				if (_useCurrent) then {
-					private _pos = [_uav] call EFUNC(client,extractClientPosition);
-					private _relAlt = ((getPosATL _uav) select 2) max 0;
-					private _homeAtl = getPosATL _uav;
-					_uav setVariable ["armatak_uas_home_atl", _homeAtl, true];
-					_uav setVariable ["armatak_uas_home_geo", [_pos select 1, _pos select 2, (_pos select 3) - _relAlt], true];
-					systemChat format ["ATAK HOME %1", _callsign];
-				} else {
-					[["param5", 0] call _number, ["param6", 0] call _number, ["param7", 0] call _number] call _setHomeFromGeo;
-				};
-			};
-			case 400: {
-				private _doArm = (["param1", 0] call _number) >= 1;
-				_uav engineOn _doArm;
-				_uav setVariable ["armatak_uas_armed", _doArm, true];
-				if (_doArm) then {
-					_uav setFuel ((fuel _uav) max 0.1);
-				};
-				systemChat format ["ATAK %1 %2", ["DISARM", "ARM"] select _doArm, _callsign];
-				"armatak" callExtension ["log", [["info", format ["Applied MAVLINK ARM=%1 to UAV %2", _doArm, _uav]]]];
-			};
-			case 22: {
-				private _alt = (["param7", 75] call _number) max 10;
-				private _pos = getPosATL _uav;
-				_pos set [2, _alt];
-				[_uav, _pos, "MOVE", 80, 25] call _commandMove;
-				_uav setVelocityModelSpace [0, 15, 8];
-				systemChat format ["ATAK TAKEOFF %1m %2", round _alt, _callsign];
-			};
-			case 21: {
-				[9] call _applyMode;
-			};
-			case 20: {
-				[6] call _applyMode;
-			};
-			case 16: {
-				private _lat = ["param5", 0] call _number;
-				private _lon = ["param6", 0] call _number;
-				private _alt = ["param7", -1] call _number;
-				private _pos = [_uav, _lat, _lon, _alt] call _geoToAtl;
-				[_uav, _pos, "MOVE", 80, 50] call _commandMove;
-				systemChat format ["ATAK MOVE %1", _callsign];
-			};
-			case 17: {
-				private _lat = ["param5", 0] call _number;
-				private _lon = ["param6", 0] call _number;
-				private _alt = ["param7", -1] call _number;
-				private _radius = abs (["param3", 80] call _number);
-				private _pos = [_uav, _lat, _lon, _alt] call _geoToAtl;
-				[_uav, _pos, "LOITER", _radius, 30] call _commandMove;
-				systemChat format ["ATAK LOITER %1", _callsign];
-			};
-			case 43000: {
-				private _speed = ["param2", -1] call _number;
-				if (_speed <= 0) then {
-					_speed = ["param1", -1] call _number;
-				};
-				[_speed] call _applySpeed;
-			};
-			case 43001: {
-				private _alt = ["param1", -1] call _number;
-				if (_alt < 0) then {
-					_alt = ["param7", -1] call _number;
-				};
-				private _pos = getPosATL _uav;
-				_pos set [2, _alt max 10];
-				[_uav, _pos, "MOVE", 80, 25] call _commandMove;
-				systemChat format ["ATAK ALT %1m %2", round (_pos select 2), _callsign];
-			};
-			case 43002: {
-				private _heading = ["param1", -1] call _number;
-				if (_heading >= 0) then {
-					_uav setDir _heading;
-					systemChat format ["ATAK HDG %1 %2", round _heading, _callsign];
-				};
-			};
-			default {
-				"armatak" callExtension ["log", [["info", format ["Unhandled MAVLINK COMMAND_LONG %1 (%2): %3", _command, _commandName, _data]]]];
-			};
-		};
-	};
-	case "COMMAND_INT": {
-		private _lat = (["x", 0] call _number) / 1e7;
-		private _lon = (["y", 0] call _number) / 1e7;
-		private _alt = ["z", -1] call _number;
-
-		switch (_command) do {
-			case 16: {
-				private _pos = [_uav, _lat, _lon, _alt] call _geoToAtl;
-				[_uav, _pos, "MOVE", 80, 50] call _commandMove;
-				systemChat format ["ATAK MOVE %1", _callsign];
-			};
-			case 17;
-			case 192: {
-				private _radius = abs (["param3", 80] call _number);
-				private _direction = ["CIRCLE_L", "CIRCLE_R"] select ((["param4", 0] call _number) < 0);
-				private _pos = [_uav, _lat, _lon, _alt] call _geoToAtl;
-				private _type = ["MOVE", "LOITER"] select (_radius > 1);
-				[_uav, _pos, _type, _radius, 30] call _commandMove;
-				if (_type == "LOITER") then {
-					private _group = [_uav] call _uavGroup;
-					private _waypoints = waypoints _group;
-					if (_waypoints isNotEqualTo []) then {
-						(_waypoints select -1) setWaypointLoiterType _direction;
-					};
-				};
-				systemChat format ["ATAK %1 %2", _type, _callsign];
-			};
-			default {
-				"armatak" callExtension ["log", [["info", format ["Unhandled MAVLINK COMMAND_INT %1 (%2): %3", _command, _commandName, _data]]]];
-			};
-		};
-	};
-	case "MISSION_COUNT": {
-		private _count = ["count", 0] call _number;
-		[] call _clearUavRoute;
-		systemChat format ["ATAK ROUTE %1 pts %2", round _count, _callsign];
-		"armatak" callExtension ["log", [["info", format ["Receiving MAVLINK mission count=%1 for UAV %2", _count, _uav]]]];
-	};
-	case "MISSION_CLEAR_ALL": {
-		[] call _clearUavRoute;
-		systemChat format ["ATAK ROUTE CLEAR %1", _callsign];
-	};
-	case "MISSION_SET_CURRENT": {
-		private _seq = ["seq", 0] call _number;
-		"armatak" callExtension ["log", [["info", format ["MAVLINK mission set current seq=%1 for UAV %2", _seq, _uav]]]];
-	};
-	case "MISSION_ITEM";
-	case "MISSION_ITEM_INT": {
-		private _seq = ["seq", 0] call _number;
-		private _missionCommand = ["command", -1] call _number;
-		private _lat = ["lat", 0] call _number;
-		private _lon = ["lon", 0] call _number;
-		private _alt = ["alt", -1] call _number;
-
-		if (_lat == 0 && {_lon == 0}) exitWith {
-			"armatak" callExtension ["log", [["warn", format ["Ignoring MAVLINK mission item at zero coordinate: %1", _data]]]];
-		};
-
-		private _pos = [_uav, _lat, _lon, _alt] call _geoToAtl;
-		private _radius = abs (["param3", 80] call _number);
-		[_uav, _pos, _missionCommand, _seq, _radius] call _appendMissionWaypoint;
-		_uav engineOn true;
-		_uav setVariable ["armatak_uas_armed", true, true];
-		_uav setFuel ((fuel _uav) max 0.1);
-		_uav flyInHeight ((_pos select 2) max 10);
-		systemChat format ["ATAK ROUTE WP %1 %2", round _seq, _callsign];
-		"armatak" callExtension ["log", [["info", format ["Added MAVLINK mission item seq=%1 command=%2 posATL=%3 for UAV %4", _seq, _missionCommand, _pos, _uav]]]];
-	};
-	case "SET_HOME_POSITION": {
-		[["lat", 0] call _number, ["lon", 0] call _number, ["alt", 0] call _number] call _setHomeFromGeo;
-	};
-	case "SET_POSITION_TARGET_GLOBAL_INT": {
-		private _lat = ["lat", 0] call _number;
-		private _lon = ["lon", 0] call _number;
-		private _alt = ["alt", -1] call _number;
-		private _pos = [_uav, _lat, _lon, _alt] call _geoToAtl;
-		[_uav, _pos, "MOVE", 80, 40] call _commandMove;
-		systemChat format ["ATAK GUIDED MOVE %1", _callsign];
-	};
-	case "SET_MODE": {
-		private _mode = ["custom_mode", -1] call _number;
-		[_mode] call _applyMode;
-	};
-	case "COMMAND_ACK": {
-		"armatak" callExtension ["log", [["info", format ["Received MAVLINK COMMAND_ACK %1 (%2): %3", _command, _commandName, _data]]]];
-	};
-	case "MANUAL_CONTROL": {
-		"armatak" callExtension ["log", [["info", format ["Received MAVLINK MANUAL_CONTROL: %1", _data]]]];
-	};
-	default {
-		"armatak" callExtension ["log", [["info", format ["Unhandled MAVLINK UDP callback %1: %2", _function, _data]]]];
-	};
-};

addons/uav/functions/fnc_parseMavlinkCallbackData.sqf

@@ -1,17 +0,0 @@
-#include "..\script_component.hpp"
-
-params [["_raw", "", [""]]];
-
-private _pairs = createHashMap;
-
-{
-	private _entry = _x;
-	private _separatorIndex = _entry find "=";
-	if (_separatorIndex > 0) then {
-		private _key = _entry select [0, _separatorIndex];
-		private _value = _entry select [_separatorIndex + 1];
-		_pairs set [_key, _value];
-	};
-} forEach (_raw splitString ";");
-
-_pairs

addons/uav/functions/fnc_resolveVideoUri.sqf

@@ -1,45 +0,0 @@
-#include "..\script_component.hpp"
-
-params [["_uav", objNull, [objNull]]];
-
-private _defaultVideoUri = "rtsp://undefined:554/fpv";
-private _activelyControlledUav = if (!isNull player) then {getConnectedUAV player} else {objNull};
-
-private _normalize = {
-	params ["_rawUrl"];
-
-	private _url = trim _rawUrl;
-	if (_url isEqualTo "") exitWith {""};
-
-	if (_url find "://" >= 0) exitWith {_url};
-
-	if (_url find "/" >= 0) exitWith {
-		format ["rtsp://%1", _url]
-	};
-
-	format ["rtp://%1", _url]
-};
-
-if (!isNull _uav) then {
-	private _objectVideoUrl = [_uav] call armatak_fnc_extract_marker_video_url;
-	private _normalizedObjectVideoUrl = [_objectVideoUrl] call _normalize;
-	if (_normalizedObjectVideoUrl isNotEqualTo "") exitWith {
-		_normalizedObjectVideoUrl
-	};
-
-	private _activeSessionVideoUrl = player getVariable [QEGVAR(client,video_feed_url), ""];
-	private _normalizedActiveSessionVideoUrl = [_activeSessionVideoUrl] call _normalize;
-	if (_normalizedActiveSessionVideoUrl isNotEqualTo "") exitWith {
-		_normalizedActiveSessionVideoUrl
-	};
-
-	_defaultVideoUri
-};
-
-private _sessionVideoUrl = player getVariable [QEGVAR(client,video_feed_url), ""];
-private _normalizedSessionVideoUrl = [_sessionVideoUrl] call _normalize;
-if (_normalizedSessionVideoUrl isNotEqualTo "") exitWith {
-	_normalizedSessionVideoUrl
-};
-
-_defaultVideoUri

addons/uav/functions/fnc_startMavlinkBroadcast.sqf

@@ -1,16 +0,0 @@
-#include "..\script_component.hpp"
-
-if (!hasInterface) exitWith {};
-
-private _existingPfh = player getVariable [QGVAR(mavlinkPFH), -1];
-if (_existingPfh >= 0) then {
-	[_existingPfh] call CBA_fnc_removePerFrameHandler;
-};
-
-player setVariable [QGVAR(broadcastingUav), objNull];
-
-private _pfh = [{
-	call FUNC(updateMavlinkBroadcast);
-}, 0.5, []] call CBA_fnc_addPerFrameHandler;
-
-player setVariable [QGVAR(mavlinkPFH), _pfh];

addons/uav/functions/fnc_stopMavlinkBroadcast.sqf

@@ -1,17 +0,0 @@
-#include "..\script_component.hpp"
-
-if (!hasInterface) exitWith {};
-
-private _existingPfh = player getVariable [QGVAR(mavlinkPFH), -1];
-if (_existingPfh >= 0) then {
-	[_existingPfh] call CBA_fnc_removePerFrameHandler;
-	player setVariable [QGVAR(mavlinkPFH), -1];
-};
-
-private _broadcastingUav = player getVariable [QGVAR(broadcastingUav), objNull];
-if (!isNull _broadcastingUav) then {
-	_broadcastingUav setVariable ["armatak_uav_mavlink_broadcasting", false, true];
-	systemChat "UAV broadcasting stopped";
-};
-
-player setVariable [QGVAR(broadcastingUav), objNull];

addons/uav/functions/fnc_updateMavlinkBroadcast.sqf

@@ -1,122 +0,0 @@
-#include "..\script_component.hpp"
-
-private _broadcastingUav = player getVariable [QGVAR(broadcastingUav), objNull];
-
-if !(player getVariable [QEGVAR(client,eudConnected), false]) exitWith {
-	if (!isNull _broadcastingUav) then {
-		_broadcastingUav setVariable ["armatak_uav_mavlink_broadcasting", false, true];
-		player setVariable [QGVAR(broadcastingUav), objNull];
-	};
-};
-
-private _uav = getConnectedUAV player;
-if (isNull _uav) then {
-	_uav = _broadcastingUav;
-};
-
-if (isNull _uav || {!alive _uav}) exitWith {
-	if (!isNull _broadcastingUav) then {
-		_broadcastingUav setVariable ["armatak_uav_mavlink_broadcasting", false, true];
-		player setVariable [QGVAR(broadcastingUav), objNull];
-		systemChat "UAV broadcasting stopped";
-		"armatak" callExtension ["log", [["info", "UAV broadcasting stopped because the UAV is no longer available"]]];
-	};
-};
-
-if (_broadcastingUav isNotEqualTo _uav) then {
-	if (!isNull _broadcastingUav) then {
-		_broadcastingUav setVariable ["armatak_uav_mavlink_broadcasting", false, true];
-	};
-	player setVariable [QGVAR(broadcastingUav), _uav];
-	_uav setVariable ["armatak_uav_mavlink_broadcasting", true, true];
-	private _callsign = [_uav] call armatak_fnc_extract_marker_callsign;
-	systemChat format ["Broadcasting UAV %1", _callsign];
-	"armatak" callExtension ["log", [["info", format ["Broadcasting UAV %1 via MAVLink mock to %2", _callsign, player getVariable [QEGVAR(client,mavlink_address), ""]]]]];
-};
-
-_uav setVariable ["armatak_uav_mavlink_broadcasting", true, true];
-
-private _mavlinkAddress = player getVariable [QEGVAR(client,mavlink_address), ""];
-if (_mavlinkAddress isEqualTo "") exitWith {};
-
-private _pos = [_uav] call EFUNC(client,extractClientPosition);
-private _relAlt = ((getPosATL _uav) select 2) max 0;
-if (isNil {_uav getVariable "armatak_uas_home_atl"}) then {
-	_uav setVariable ["armatak_uas_home_atl", getPosATL _uav, true];
-	_uav setVariable ["armatak_uas_home_geo", [_pos select 1, _pos select 2, (_pos select 3) - _relAlt], true];
-};
-private _uuid = [_uav] call armatak_fnc_extract_uuid;
-private _callsign = [_uav] call armatak_fnc_extract_marker_callsign;
-private _videoUri = [_uav] call FUNC(resolveVideoUri);
-private _dir = vectorDir _uav;
-private _up = vectorUp _uav;
-private _yaw = getDir _uav;
-private _pitch = asin (((_dir select 2) max -1) min 1);
-private _roll = asin (((_up select 0) max -1) min 1);
-private _uavType = if (_uav isKindOf "Plane") then {1} else {[2, 3] select (_uav isKindOf "Helicopter")};
-private _armed = _uav getVariable ["armatak_uas_armed", isEngineOn _uav];
-if !(isEngineOn _uav) then {
-	_armed = false;
-	_uav setVariable ["armatak_uas_armed", false, true];
-};
-private _groundSpeed = abs (_pos select 6);
-private _landed = (_relAlt <= 1.5) && {_groundSpeed <= 0.5};
-private _batteryRemaining = round ((((fuel _uav) max 0) min 1) * 100);
-
-private _gimbalRoll = 0;
-private _gimbalPitch = _pitch;
-private _gimbalYaw = _yaw;
-private _hfov = _uav getVariable ["armatak_uas_fov", 60];
-private _vfov = _uav getVariable ["armatak_uas_vfov", (_hfov * 0.5625)];
-private _imageLat = _pos select 1;
-private _imageLon = _pos select 2;
-private _imageAlt = _pos select 3;
-private _cameraData = [_uav, "turret"] call armatak_fnc_extract_uas_camera_data;
-private _uavControl = UAVControl _uav;
-private _controlledTurretPath = _uavControl param [1, []];
-private _hasTurretCamera = ((_controlledTurretPath isEqualType []) && {_controlledTurretPath isNotEqualTo []}) || {(allTurrets _uav) isNotEqualTo []};
-
-if (_cameraData isEqualType [] && {(count _cameraData) >= 6}) then {
-	_gimbalYaw = _cameraData param [0, _yaw];
-	_gimbalPitch = _cameraData param [1, _pitch];
-	_hfov = _cameraData param [2, _hfov];
-	_vfov = _uav getVariable ["armatak_uas_vfov", (_hfov * 0.5625)];
-
-	private _spiGeo = _cameraData param [5, []];
-	if (_spiGeo isEqualType [] && {(count _spiGeo) >= 3}) then {
-		_imageLat = _spiGeo select 0;
-		_imageLon = _spiGeo select 1;
-		_imageAlt = _spiGeo select 2;
-	};
-};
-
-private _systemPayload = [
-	_mavlinkAddress,
-	_uuid,
-	_callsign,
-	_uavType,
-	_pos select 1,
-	_pos select 2,
-	_pos select 3,
-	_relAlt,
-	_pos select 5,
-	_pos select 6,
-	_roll,
-	_pitch,
-	_yaw,
-	parseNumber _armed,
-	parseNumber _landed,
-	_gimbalRoll,
-	_gimbalPitch,
-	_gimbalYaw,
-	_videoUri,
-	_hfov,
-	_vfov,
-	_imageLat,
-	_imageLon,
-	_imageAlt,
-	parseNumber _hasTurretCamera,
-	_batteryRemaining
-];
-
-"armatak" callExtension ["uas:send_uas_system", [_systemPayload]];

addons/uav/script_component.hpp

@@ -1,17 +0,0 @@
-#define COMPONENT uav
-#define COMPONENT_BEAUTIFIED UAV
-#include "\armatak\armatak\addons\main\script_mod.hpp"
-
-// #define DEBUG_MODE_FULL
-// #define DISABLE_COMPILE_CACHE
-// #define ENABLE_PERFORMANCE_COUNTERS
-
-#ifdef DEBUG_ENABLED_UAV
-    #define DEBUG_MODE_FULL
-#endif
-
-#ifdef DEBUG_SETTINGS_UAV
-    #define DEBUG_SETTINGS DEBUG_SETTINGS_UAV
-#endif
-
-#include "\z\ace\addons\main\script_macros.hpp"

src/cot/cot.rs

@@ -1,4 +1,3 @@
-use super::video::video_detail_xml;
 use chrono::{Duration, SecondsFormat, Utc};
 use uuid::Uuid;
 
@@ -21,6 +20,14 @@ pub struct CursorOverTime {
 }
 
 impl CursorOverTime {
+    fn escape_xml_attribute(value: &str) -> String {
+        value
+            .replace('&', "&")
+            .replace('"', """)
+            .replace('<', "&lt;")
+            .replace('>', "&gt;")
+    }
+
     pub fn convert_to_xml(&self) -> String {
         let uuid = match &self.uuid {
             Some(uuid) => uuid,
@@ -111,7 +118,13 @@ impl CursorOverTime {
 
         if let Some(video_url) = &self.video_url {
             if !video_url.trim().is_empty() {
-                xml.push_str(&video_detail_xml(video_url, uuid, &self.contact_callsign));
+                xml.push_str(
+                    format!(
+                        "<__video url=\"{}\" />",
+                        Self::escape_xml_attribute(video_url.trim())
+                    )
+                    .as_str(),
+                );
             }
         }
 

src/cot/mod.rs

@@ -6,4 +6,3 @@ pub mod gps;
 pub mod message;
 pub mod nato;
 pub mod uas;
-pub mod video;

src/cot/uas.rs

@@ -1,206 +1,59 @@
-use super::video::video_detail_xml;
+// src/cot/uas.rs
+//
+// CoT types required for ATAK UAS Tool integration.
+//
+// Two event types are needed so that the UAS Tool plugin recognises a drone:
+//
+//   b-i-v              — Video endpoint declaration. Tells the UAS Tool where
+//                        to pull the RTSP stream for this drone.
+//
+//   b-m-p-s-p-loc      — Sensor position event. Carries the camera azimuth,
+//                        field-of-view, and slant-range that the UAS Tool uses
+//                        to draw the FOV cone on the map and to project AR
+//                        markers onto the video feed.
+//
+// The two events are linked: the b-m-p-s-p-loc detail contains
+//   <__video uid="<drone-uuid>"/>
+// which references the uid of the b-i-v event, so the UAS Tool knows which
+// video stream belongs to this sensor.
+
 use arma_rs::{FromArma, FromArmaError};
 use chrono::{Duration, SecondsFormat, Utc};
 
-fn escape_xml(value: &str) -> String {
+// ---------------------------------------------------------------------------
-    value
+// Helpers
-        .replace('&', "&amp;")
+// ---------------------------------------------------------------------------
-        .replace('"', "&quot;")
-        .replace('<', "&lt;")
-        .replace('>', "&gt;")
-        .replace('\'', "&apos;")
-}
 
+/// Parse an RTSP URL of the form  rtsp://address:port/path
+/// into its three components.
 fn parse_rtsp_url(url: &str) -> Option<(String, String, String)> {
     let without_proto = url.strip_prefix("rtsp://")?;
     let slash_pos = without_proto.find('/')?;
     let host_port = &without_proto[..slash_pos];
-    let path = &without_proto[slash_pos..];
+    let path = &without_proto[slash_pos..]; // includes the leading '/'
     let colon_pos = host_port.rfind(':')?;
     let address = host_port[..colon_pos].to_string();
     let port = host_port[colon_pos + 1..].to_string();
     Some((address, port, path.to_string()))
 }
 
-pub struct UasPlatformCoTPayload {
+// ---------------------------------------------------------------------------
-    pub uid: String,
+// b-i-v  –  Video endpoint declaration
-    pub cot_type: String,
+// ---------------------------------------------------------------------------
-    pub callsign: String,
-    pub point_lat: f64,
-    pub point_lon: f64,
-    pub point_hae: f32,
-    pub track_course: i32,
-    pub track_speed: f32,
-    pub sensor_azimuth: i32,
-    pub sensor_elevation: i32,
-    pub sensor_fov: i32,
-    pub sensor_vfov: i32,
-    pub sensor_range: i32,
-    pub attitude_yaw: i32,
-    pub attitude_pitch: f32,
-    pub attitude_roll: f32,
-    pub hal: f32,
-    pub vehicle_type_tag: String,
-    pub is_flying: i32,
-    pub link_uid: String,
-}
-
-impl FromArma for UasPlatformCoTPayload {
-    fn from_arma(data: String) -> Result<UasPlatformCoTPayload, FromArmaError> {
-        let (
-            uid,
-            cot_type,
-            callsign,
-            point_lat,
-            point_lon,
-            point_hae,
-            track_course,
-            track_speed,
-            sensor_azimuth,
-            sensor_elevation,
-            sensor_fov,
-            sensor_vfov,
-            sensor_range,
-            attitude_yaw,
-            attitude_pitch,
-            attitude_roll,
-            hal,
-            vehicle_type_tag,
-            is_flying,
-            link_uid,
-        ) = <(
-            String,
-            String,
-            String,
-            f64,
-            f64,
-            f32,
-            i32,
-            f32,
-            i32,
-            i32,
-            i32,
-            i32,
-            i32,
-            i32,
-            f32,
-            f32,
-            f32,
-            String,
-            i32,
-            String,
-        )>::from_arma(data)?;
-
-        Ok(Self {
-            uid,
-            cot_type,
-            callsign,
-            point_lat,
-            point_lon,
-            point_hae,
-            track_course,
-            track_speed,
-            sensor_azimuth,
-            sensor_elevation,
-            sensor_fov,
-            sensor_vfov,
-            sensor_range,
-            attitude_yaw,
-            attitude_pitch,
-            attitude_roll,
-            hal,
-            vehicle_type_tag,
-            is_flying,
-            link_uid,
-        })
-    }
-}
-
-impl UasPlatformCoTPayload {
-    pub fn to_xml(&self) -> String {
-        let uid = escape_xml(&self.uid);
-        let cot_type = escape_xml(&self.cot_type);
-        let callsign = escape_xml(&self.callsign);
-        let link_uid = escape_xml(&self.link_uid);
-        let (vehicle_type_tag, video_url) =
-            match self.vehicle_type_tag.split_once("|armatak_video_url=") {
-                Some((vehicle_type_tag, video_url)) => (
-                    escape_xml(vehicle_type_tag),
-                    Some(escape_xml(video_url.trim())).filter(|value| !value.is_empty()),
-                ),
-                None => (escape_xml(&self.vehicle_type_tag), None),
-            };
-        let now = Utc::now().to_rfc3339_opts(SecondsFormat::Millis, true);
-        let stale =
-            (Utc::now() + Duration::milliseconds(3500)).to_rfc3339_opts(SecondsFormat::Millis, true);
-
-        let mut xml = String::new();
-        xml.push_str("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>");
-        xml.push_str(&format!(
-            "<event version=\"2.0\" uid=\"{uid}\" type=\"{cot_type}\" time=\"{now}\" start=\"{now}\" stale=\"{stale}\" how=\"m-g\" access=\"Undefined\">",
-            cot_type = cot_type,
-            uid = uid,
-            now = now,
-            stale = stale,
-        ));
-        xml.push_str(&format!(
-            "<point lat=\"{lat}\" lon=\"{lon}\" hae=\"{hae}\" ce=\"9999999.0\" le=\"9999999.0\"/>",
-            lat = self.point_lat,
-            lon = self.point_lon,
-            hae = self.point_hae,
-        ));
-        xml.push_str("<detail>");
-        xml.push_str("<_uastool extendedCot=\"true\" activeRoute=\"false\"/>");
-        xml.push_str(&format!(
-            "<track course=\"{}\" slope=\"0.0\" speed=\"{}\"/>",
-            self.track_course,
-            self.track_speed,
-        ));
-        xml.push_str(&format!(
-            "<sensor elevation=\"{}\" vfov=\"{}\" north=\"0.0\" roll=\"0.0\" range=\"{}\" azimuth=\"{}\" fov=\"{}\" type=\"r-e\" version=\"0.6\"/>",
-            self.sensor_elevation,
-            self.sensor_vfov,
-            self.sensor_range,
-            self.sensor_azimuth,
-            self.sensor_fov,
-        ));
-        xml.push_str(&format!(
-            "<spatial><attitude roll=\"{}\" pitch=\"{}\" yaw=\"{}\"/><spin roll=\"0.0\" pitch=\"0.0\" yaw=\"0.0\"/></spatial>",
-            self.attitude_roll,
-            self.attitude_pitch,
-            self.attitude_yaw,
-        ));
-        xml.push_str(&format!(
-            "<vehicle goHomeBatteryPercent=\"-2147483648\" hal=\"{}\" flightTimeRemaining=\"-2147483648\" typeTag=\"{}\" batteryRemainingCapacity=\"-2147483648\" isFlying=\"{}\" flightTime=\"-2147483648\" type=\"Generic\" batteryMaxCapacity=\"-2147483648\"/>",
-            self.hal,
-            vehicle_type_tag,
-            if self.is_flying != 0 { "true" } else { "false" },
-        ));
-        xml.push_str("<_radio rssi=\"-2147483648\" gps=\"false\"/>");
-        xml.push_str(&format!("<contact callsign=\"{}\"/>", callsign));
-        xml.push_str("<waypointCollection></waypointCollection>");
-        xml.push_str(&format!("<_route sender=\"{}\"/>", link_uid));
-        xml.push_str("<commandedData climbRate=\"0.0\"/>");
-        if let Some(video_url) = video_url {
-            xml.push_str(&video_detail_xml(&video_url, &self.uid, &self.callsign));
-        } else {
-            xml.push_str("<__video></__video>");
-        }
-        xml.push_str(&format!("<link uid=\"{}\" type=\"a-f-G-U-C\" relation=\"p-p\" />", link_uid));
-        xml.push_str("</detail></event>");
-        xml
-    }
-}
 
 pub struct UasVideoCoTPayload {
+    /// The drone's persistent ATAK UUID (same uid used for PPLI / marker CoT).
     pub uid: String,
+    /// Human-readable label shown in the UAS Tool video list.
     pub callsign: String,
+    /// Full RTSP URL, e.g. "rtsp://192.168.1.10:8554/live/drone1".
     pub video_url: String,
 }
 
 impl FromArma for UasVideoCoTPayload {
     fn from_arma(data: String) -> Result<UasVideoCoTPayload, FromArmaError> {
-        let (uid, callsign, video_url) = <(String, String, String)>::from_arma(data)?;
+        let (uid, callsign, video_url) =
+            <(String, String, String)>::from_arma(data)?;
         Ok(Self {
             uid,
             callsign,
@@ -210,6 +63,8 @@ impl FromArma for UasVideoCoTPayload {
 }
 
 impl UasVideoCoTPayload {
+    /// Build the complete XML string for the b-i-v CoT event.
+    /// Returns an empty string if the RTSP URL cannot be parsed.
     pub fn to_xml(&self) -> String {
         let (address, port, path) = match parse_rtsp_url(&self.video_url) {
             Some(parts) => parts,
@@ -221,60 +76,103 @@ impl UasVideoCoTPayload {
                 return String::new();
             }
         };
-        let callsign = escape_xml(&self.callsign);
-        let uid = escape_xml(&self.uid);
-        let address = escape_xml(&address);
-        let path = escape_xml(&path);
 
-        let now = Utc::now().to_rfc3339_opts(SecondsFormat::Millis, true);
+        let now =
-        let stale =
+            Utc::now().to_rfc3339_opts(SecondsFormat::Millis, true);
-            (Utc::now() + Duration::seconds(3600)).to_rfc3339_opts(SecondsFormat::Millis, true);
+        // Long stale time: the video endpoint is considered valid for 1 hour.
+        // The CoT is re-sent every router tick so it stays fresh even if the
+        // TAK server restarts.
+        let stale = (Utc::now() + Duration::seconds(3600))
+            .to_rfc3339_opts(SecondsFormat::Millis, true);
 
         let mut xml = String::new();
         xml.push_str("<?xml version=\"1.0\" encoding=\"UTF-8\" ?>");
         xml.push_str(&format!(
-            "<event type=\"b-i-v\" version=\"2.0\" how=\"m-g\" uid=\"{uid}\" time=\"{now}\" start=\"{now}\" stale=\"{stale}\">",
+            "<event type=\"b-i-v\" version=\"2.0\" how=\"m-g\" \
-            uid = uid,
+             uid=\"{uid}\" time=\"{now}\" start=\"{now}\" stale=\"{stale}\">",
+            uid = self.uid,
             now = now,
             stale = stale
         ));
+        // b-i-v events carry no real geographic position.
         xml.push_str(
-            "<point lat=\"0\" lon=\"0\" hae=\"9999999.0\" ce=\"9999999.0\" le=\"9999999.0\"/>",
+            "<point lat=\"0\" lon=\"0\" hae=\"9999999.0\" \
+             ce=\"9999999.0\" le=\"9999999.0\"/>",
         );
         xml.push_str("<detail>");
         xml.push_str("<__video>");
         xml.push_str(&format!(
-            "<ConnectionEntry protocol=\"rtsp\" path=\"{path}\" address=\"{address}\" port=\"{port}\" uid=\"{uid}\" alias=\"{callsign}\" roverPort=\"-1\" rtspReliable=\"0\" ignoreEmbeddedKLV=\"False\" networkTimeout=\"0\" bufferTime=\"-1\"/>",
+            "<ConnectionEntry \
+             protocol=\"rtsp\" \
+             path=\"{path}\" \
+             address=\"{address}\" \
+             port=\"{port}\" \
+             uid=\"{uid}\" \
+             alias=\"{callsign}\" \
+             roverPort=\"-1\" \
+             rtspReliable=\"0\" \
+             ignoreEmbeddedKLV=\"False\" \
+             networkTimeout=\"0\" \
+             bufferTime=\"-1\"/>",
             path = path,
             address = address,
             port = port,
-            uid = uid,
+            uid = self.uid,
-            callsign = callsign,
+            callsign = self.callsign,
         ));
         xml.push_str("</__video>");
-        xml.push_str(&format!("<contact callsign=\"{}\"/>", callsign));
+        xml.push_str(&format!(
+            "<contact callsign=\"{}\"/>",
+            self.callsign
+        ));
         xml.push_str("</detail>");
         xml.push_str("</event>");
         xml
     }
 }
 
+// ---------------------------------------------------------------------------
+// b-m-p-s-p-loc  –  Sensor position (FOV cone + video link)
+// ---------------------------------------------------------------------------
+
 pub struct UasSensorCoTPayload {
+    /// UID for this sensor event — conventionally "<drone-uuid>-sensor".
     pub uid: String,
+    /// The drone's ATAK UUID; must match the uid used in the b-i-v event so
+    /// the UAS Tool can link sensor data to the correct video stream.
     pub video_uid: String,
+    /// Callsign shown in the UAS Tool sensor list.
     pub callsign: String,
+    /// Drone latitude in decimal degrees (WGS-84).
     pub point_lat: f64,
+    /// Drone longitude in decimal degrees (WGS-84).
     pub point_lon: f64,
+    /// Drone height above ellipsoid in metres (WGS-84).
     pub point_hae: f32,
+    /// Camera azimuth in degrees, clockwise from true North (0–359).
     pub azimuth: i32,
+    /// Camera horizontal field of view in degrees.
     pub fov: i32,
+    /// Estimated slant range from drone to ground point in metres.
+    /// A good approximation is the drone's AGL altitude.
     pub range: i32,
 }
 
 impl FromArma for UasSensorCoTPayload {
     fn from_arma(data: String) -> Result<UasSensorCoTPayload, FromArmaError> {
-        let (uid, video_uid, callsign, point_lat, point_lon, point_hae, azimuth, fov, range) =
+        let (
-            <(String, String, String, f64, f64, f32, i32, i32, i32)>::from_arma(data)?;
+            uid,
+            video_uid,
+            callsign,
+            point_lat,
+            point_lon,
+            point_hae,
+            azimuth,
+            fov,
+            range,
+        ) = <(String, String, String, f64, f64, f32, i32, i32, i32)>::from_arma(
+            data,
+        )?;
         Ok(Self {
             uid,
             video_uid,
@@ -290,41 +188,56 @@ impl FromArma for UasSensorCoTPayload {
 }
 
 impl UasSensorCoTPayload {
+    /// Build the complete XML string for the b-m-p-s-p-loc CoT event.
     pub fn to_xml(&self) -> String {
-        let uid = escape_xml(&self.uid);
+        let now =
-        let video_uid = escape_xml(&self.video_uid);
+            Utc::now().to_rfc3339_opts(SecondsFormat::Millis, true);
-        let callsign = escape_xml(&self.callsign);
+        // 60-second stale: must be refreshed every router tick (1 s) to keep
-        let now = Utc::now().to_rfc3339_opts(SecondsFormat::Millis, true);
+        // the FOV cone visible on the map.
-        let stale =
+        let stale = (Utc::now() + Duration::seconds(60))
-            (Utc::now() + Duration::seconds(60)).to_rfc3339_opts(SecondsFormat::Millis, true);
+            .to_rfc3339_opts(SecondsFormat::Millis, true);
 
         let mut xml = String::new();
         xml.push_str("<?xml version=\"1.0\" encoding=\"UTF-8\" ?>");
         xml.push_str(&format!(
-            "<event type=\"b-m-p-s-p-loc\" version=\"2.0\" how=\"h-g-i-g-o\" uid=\"{uid}\" time=\"{now}\" start=\"{now}\" stale=\"{stale}\">",
+            "<event type=\"b-m-p-s-p-loc\" version=\"2.0\" how=\"h-g-i-g-o\" \
-            uid = uid,
+             uid=\"{uid}\" time=\"{now}\" start=\"{now}\" stale=\"{stale}\">",
+            uid = self.uid,
             now = now,
             stale = stale,
         ));
         xml.push_str(&format!(
-            "<point lat=\"{lat}\" lon=\"{lon}\" hae=\"{hae}\" ce=\"9999999.0\" le=\"9999999.0\"/>",
+            "<point lat=\"{lat}\" lon=\"{lon}\" hae=\"{hae}\" \
+             ce=\"9999999.0\" le=\"9999999.0\"/>",
             lat = self.point_lat,
             lon = self.point_lon,
             hae = self.point_hae,
         ));
         xml.push_str("<detail>");
+        // fovAlpha controls the transparency of the FOV cone fill (0–1).
+        // 0.537 ≈ 137/255, the value used by the real UAS Tool.
         xml.push_str(&format!(
-            "<sensor fov=\"{fov}\" fovRed=\"1\" fovGreen=\"1\" fovBlue=\"1\" fovAlpha=\"0.5372549\" displayMagneticReference=\"0\" range=\"{range}\" azimuth=\"{az}\"/>",
+            "<sensor \
+             fov=\"{fov}\" \
+             fovRed=\"1\" \
+             fovGreen=\"1\" \
+             fovBlue=\"1\" \
+             fovAlpha=\"0.5372549\" \
+             displayMagneticReference=\"0\" \
+             range=\"{range}\" \
+             azimuth=\"{az}\"/>",
             fov = self.fov,
             range = self.range,
             az = self.azimuth,
         ));
-        xml.push_str(&format!("<__video uid=\"{}\"/>", video_uid));
+        // Link this sensor event to the b-i-v video endpoint.
-        xml.push_str(&format!("<contact callsign=\"{}\"/>", callsign));
+        xml.push_str(&format!("<__video uid=\"{}\"/>", self.video_uid));
+        xml.push_str(&format!(
+            "<contact callsign=\"{}\"/>",
+            self.callsign
+        ));
         xml.push_str("</detail>");
         xml.push_str("</event>");
         xml
     }
 }
-
-

src/cot/video.rs

@@ -1,53 +0,0 @@
-fn escape_xml_attribute(value: &str) -> String {
-    value
-        .replace('&', "&")
-        .replace('"', """)
-        .replace('<', "&lt;")
-        .replace('>', "&gt;")
-        .replace('\'', "&apos;")
-}
-
-fn parse_video_url(url: &str) -> Option<(String, String, String, String)> {
-    let (protocol, rest) = url.trim().split_once("://")?;
-    let (authority, path) = match rest.split_once('/') {
-        Some((authority, path)) => (authority, format!("/{}", path)),
-        None => (rest, String::new()),
-    };
-    let host_port = authority.rsplit_once('@').map_or(authority, |(_, host_port)| host_port);
-    let (address, port) = host_port.rsplit_once(':')?;
-
-    if protocol.is_empty() || address.is_empty() || port.is_empty() {
-        return None;
-    }
-
-    Some((
-        protocol.to_ascii_lowercase(),
-        address.to_string(),
-        port.to_string(),
-        path,
-    ))
-}
-
-pub fn video_detail_xml(video_url: &str, uid: &str, callsign: &str) -> String {
-    let trimmed_url = video_url.trim();
-    if trimmed_url.is_empty() {
-        return "<__video></__video>".to_string();
-    }
-
-    let Some((protocol, address, port, path)) = parse_video_url(trimmed_url) else {
-        return format!(
-            "<__video url=\"{}\"/>",
-            escape_xml_attribute(trimmed_url)
-        );
-    };
-
-    format!(
-        "<__video><ConnectionEntry protocol=\"{}\" path=\"{}\" address=\"{}\" port=\"{}\" uid=\"{}\" alias=\"{}\" roverPort=\"-1\" rtspReliable=\"0\" ignoreEmbeddedKLV=\"False\" networkTimeout=\"0\" bufferTime=\"-1\"/></__video>",
-        escape_xml_attribute(&protocol),
-        escape_xml_attribute(&path),
-        escape_xml_attribute(&address),
-        escape_xml_attribute(&port),
-        escape_xml_attribute(uid),
-        escape_xml_attribute(callsign),
-    )
-}

src/lib.rs

@@ -1,7 +1,5 @@
 use arma_rs::{arma, Extension, Group};
 use rustls::crypto::aws_lc_rs;
-mod uas;
-mod mdns;
 mod structs;
 mod tcp;
 mod tests;
@@ -41,20 +39,6 @@ pub fn init() -> Extension {
         .command("local_ip", utils::address::get_local_address)
         .command("uuid", utils::uuid::get_uuid)
         .command("log", utils::log::log_info)
-        .group(
-            "uas",
-            Group::new()
-                .command("start_endpoint", uas::start_endpoint)
-                .command("stop_endpoint", uas::stop_endpoint)
-                .command("send_uas_telemetry", uas::send_uas_telemetry)
-                .command("send_uas_system", uas::send_uas_system),
-        )
-        .group(
-            "mdns",
-            Group::new()
-                .command("start_uas_advertisement", mdns::start_uas_advertisement)
-                .command("stop", mdns::stop),
-        )
         .group(
             "udp_socket",
             Group::new()
@@ -78,7 +62,7 @@ pub fn init() -> Extension {
                         .command("marker", tcp::cot::send_marker_cot)
                         .command("digital_pointer", tcp::cot::send_digital_pointer_cot)
                         .command("chat", tcp::cot::send_message_cot)
-                        .command("uas_platform", tcp::cot::send_uas_platform_cot)
+                        // UAS Tool integration
                         .command("uas_video", tcp::cot::send_uas_video_cot)
                         .command("uas_sensor", tcp::cot::send_uas_sensor_cot),
                 )

src/mdns.rs

@@ -1,207 +0,0 @@
-use arma_rs::Context;
-use lazy_static::lazy_static;
-use log::info;
-use std::net::{Ipv4Addr, SocketAddrV4, UdpSocket};
-use std::sync::mpsc::{self, Receiver, Sender};
-use std::sync::Mutex;
-use std::thread;
-use std::time::Duration;
-
-lazy_static! {
-    static ref MDNS_CTRL: Mutex<Option<Sender<()>>> = Mutex::new(None);
-}
-
-fn detect_local_ipv4() -> Result<Ipv4Addr, String> {
-    let socket = UdpSocket::bind("0.0.0.0:0").map_err(|e| e.to_string())?;
-    socket.connect("8.8.8.8:80").map_err(|e| e.to_string())?;
-    match socket.local_addr().map_err(|e| e.to_string())? {
-        std::net::SocketAddr::V4(addr) => Ok(*addr.ip()),
-        std::net::SocketAddr::V6(_) => Err("Local address is not IPv4".to_string()),
-    }
-}
-
-fn sanitize_label(value: &str, fallback: &str) -> String {
-    let mut sanitized = value
-        .chars()
-        .map(|c| if c.is_ascii_alphanumeric() || c == '-' { c } else { '-' })
-        .collect::<String>()
-        .trim_matches('-')
-        .to_string();
-
-    if sanitized.is_empty() {
-        sanitized = fallback.to_string();
-    }
-
-    if sanitized.len() > 63 {
-        sanitized.truncate(63);
-    }
-
-    sanitized
-}
-
-fn encode_name(name: &str) -> Vec<u8> {
-    let mut encoded = Vec::new();
-    for label in name.split('.') {
-        let bytes = label.as_bytes();
-        encoded.push(bytes.len() as u8);
-        encoded.extend_from_slice(bytes);
-    }
-    encoded.push(0);
-    encoded
-}
-
-fn push_u16(buf: &mut Vec<u8>, value: u16) {
-    buf.extend_from_slice(&value.to_be_bytes());
-}
-
-fn push_u32(buf: &mut Vec<u8>, value: u32) {
-    buf.extend_from_slice(&value.to_be_bytes());
-}
-
-fn push_record(buf: &mut Vec<u8>, name: &str, rr_type: u16, rr_class: u16, ttl: u32, rdata: &[u8]) {
-    buf.extend_from_slice(&encode_name(name));
-    push_u16(buf, rr_type);
-    push_u16(buf, rr_class);
-    push_u32(buf, ttl);
-    push_u16(buf, rdata.len() as u16);
-    buf.extend_from_slice(rdata);
-}
-
-fn build_mdns_packet(instance_name: &str, host_name: &str, ip: Ipv4Addr, port: u16, video_uri: &str) -> Vec<u8> {
-    let service_type = "_mavlink._udp.local";
-    let instance_fqdn = format!("{}.{}", instance_name, service_type);
-    let host_fqdn = format!("{}.local", host_name);
-
-    let mut packet = Vec::new();
-    push_u16(&mut packet, 0);
-    push_u16(&mut packet, 0x8400);
-    push_u16(&mut packet, 0);
-    push_u16(&mut packet, 4);
-    push_u16(&mut packet, 0);
-    push_u16(&mut packet, 0);
-
-    let ptr_rdata = encode_name(&instance_fqdn);
-    push_record(&mut packet, service_type, 12, 0x0001, 120, &ptr_rdata);
-
-    let mut srv_rdata = Vec::new();
-    push_u16(&mut srv_rdata, 0);
-    push_u16(&mut srv_rdata, 0);
-    push_u16(&mut srv_rdata, port);
-    srv_rdata.extend_from_slice(&encode_name(&host_fqdn));
-    push_record(&mut packet, &instance_fqdn, 33, 0x8001, 120, &srv_rdata);
-
-    let txt_value = format!("uri={}", video_uri);
-    let txt_bytes = txt_value.as_bytes();
-    let mut txt_rdata = Vec::new();
-    txt_rdata.push(txt_bytes.len() as u8);
-    txt_rdata.extend_from_slice(txt_bytes);
-    push_record(&mut packet, &instance_fqdn, 16, 0x8001, 120, &txt_rdata);
-
-    let a_rdata = ip.octets();
-    push_record(&mut packet, &host_fqdn, 1, 0x8001, 120, &a_rdata);
-
-    packet
-}
-
-fn stop_existing() {
-    if let Ok(mut lock) = MDNS_CTRL.lock() {
-        if let Some(tx) = lock.take() {
-            let _ = tx.send(());
-        }
-    }
-}
-
-pub fn start_uas_advertisement(
-    ctx: Context,
-    instance_name: String,
-    mavlink_port: i32,
-    video_uri: String,
-) -> &'static str {
-    stop_existing();
-
-    let local_ip = match detect_local_ipv4() {
-        Ok(ip) => ip,
-        Err(error) => {
-            let _ = ctx.callback_data("MDNS ERROR", "Failed to determine local IPv4", error.clone());
-            return "mdns local IPv4 error";
-        }
-    };
-
-    let port = mavlink_port.clamp(1, 65535) as u16;
-    let safe_instance = sanitize_label(&instance_name, "ArmaTAK-UAS");
-    let host_label = sanitize_label(
-        &format!("armatak-{}", safe_instance.to_lowercase()),
-        "armatak-uas-host",
-    );
-    let packet = build_mdns_packet(&safe_instance, &host_label, local_ip, port, &video_uri);
-    let callback_video_uri = video_uri.clone();
-    let multicast_addr = SocketAddrV4::new(Ipv4Addr::new(224, 0, 0, 251), 5353);
-
-    let (stop_tx, stop_rx): (Sender<()>, Receiver<()>) = mpsc::channel();
-    if let Ok(mut lock) = MDNS_CTRL.lock() {
-        *lock = Some(stop_tx);
-    }
-
-    thread::spawn(move || {
-        let socket = match UdpSocket::bind("0.0.0.0:0") {
-            Ok(socket) => socket,
-            Err(error) => {
-                info!("mDNS failed to bind UDP socket: {}", error);
-                return;
-            }
-        };
-
-        let _ = socket.set_multicast_ttl_v4(255);
-        let _ = socket.set_multicast_loop_v4(true);
-
-        info!(
-            "Starting mDNS UAS advertisement instance={} host={} ip={} port={} video_uri={}",
-            safe_instance, host_label, local_ip, port, video_uri
-        );
-
-        loop {
-            match socket.send_to(&packet, multicast_addr) {
-                Ok(size) => info!("Sent mDNS UAS advertisement ({} bytes) to {}", size, multicast_addr),
-                Err(error) => info!("Failed sending mDNS UAS advertisement: {}", error),
-            }
-
-            match stop_rx.recv_timeout(Duration::from_secs(5)) {
-                Ok(_) => break,
-                Err(mpsc::RecvTimeoutError::Timeout) => {}
-                Err(_) => break,
-            }
-        }
-
-        info!("Stopped mDNS UAS advertisement for instance={}", safe_instance);
-    });
-
-    let _ = ctx.callback_data(
-        "MDNS",
-        "UAS advertisement started",
-        format!("{}:{} | {}", local_ip, port, callback_video_uri),
-    );
-
-    "starting mdns uas advertisement"
-}
-
-pub fn stop(ctx: Context) -> &'static str {
-    let had_running = match MDNS_CTRL.lock() {
-        Ok(mut lock) => {
-            if let Some(tx) = lock.take() {
-                let _ = tx.send(());
-                true
-            } else {
-                false
-            }
-        }
-        Err(_) => false,
-    };
-
-    if had_running {
-        let _ = ctx.callback_null("MDNS", "UAS advertisement stopped");
-        "stopping mdns advertisement"
-    } else {
-        let _ = ctx.callback_null("MDNS ERROR", "No mDNS advertisement is running");
-        "no mdns advertisement running"
-    }
-}

src/tcp/cot.rs

@@ -40,16 +40,10 @@ pub fn send_message_cot(
     "Sending Message CoT to TCP server"
 }
 
-pub fn send_uas_platform_cot(
+/// Send a b-i-v CoT that declares the RTSP video endpoint for a drone.
-    ctx: Context,
+/// Called by SQF via:  "armatak" callExtension ["tcp_socket:cot:uas_video", [payload]]
-    payload: cot::uas::UasPlatformCoTPayload,
+///
-) -> &'static str {
+/// Returns early without sending if the RTSP URL in the payload cannot be parsed.
-    let xml = payload.to_xml();
-    send_payload(ctx, xml);
-
-    "Sending UAS Platform main CoT to TCP server"
-}
-
 pub fn send_uas_video_cot(
     ctx: Context,
     payload: cot::uas::UasVideoCoTPayload,
@@ -62,6 +56,9 @@ pub fn send_uas_video_cot(
     "Sending UAS Video (b-i-v) CoT to TCP server"
 }
 
+/// Send a b-m-p-s-p-loc CoT carrying the drone camera's azimuth, FOV, and
+/// slant-range so the UAS Tool can draw the FOV cone on the map.
+/// Called by SQF via:  "armatak" callExtension ["tcp_socket:cot:uas_sensor", [payload]]
 pub fn send_uas_sensor_cot(
     ctx: Context,
     payload: cot::uas::UasSensorCoTPayload,

src/uas/constants.rs

@@ -1,43 +0,0 @@
-pub const AUTOPILOT_COMPONENT_ID: u8 = 1;
-pub const CAMERA_COMPONENT_ID: u8 = 100;
-pub const TURRET_CAMERA_COMPONENT_ID: u8 = 101;
-pub const GIMBAL_COMPONENT_ID: u8 = 154;
-
-pub const MAV_TYPE_FIXED_WING: u8 = 1;
-pub const MAV_TYPE_QUADROTOR: u8 = 2;
-pub const MAV_TYPE_HELICOPTER: u8 = 4;
-pub const MAV_TYPE_GIMBAL: u8 = 26;
-pub const MAV_TYPE_CAMERA: u8 = 30;
-
-pub const MAV_AUTOPILOT_ARDUPILOTMEGA: u8 = 3;
-pub const MAV_AUTOPILOT_INVALID: u8 = 8;
-
-pub const MAV_STATE_STANDBY: u8 = 3;
-pub const MAV_STATE_ACTIVE: u8 = 4;
-
-pub const MAV_MODE_FLAG_CUSTOM_MODE_ENABLED: u8 = 1;
-pub const MAV_MODE_FLAG_SAFETY_ARMED: u8 = 128;
-pub const MAV_LANDED_STATE_UNDEFINED: u8 = 0;
-pub const MAV_LANDED_STATE_ON_GROUND: u8 = 1;
-pub const MAV_LANDED_STATE_IN_AIR: u8 = 2;
-
-pub const MAV_PROTOCOL_CAPABILITY_MISSION_INT: u64 = 4;
-pub const MAV_PROTOCOL_CAPABILITY_COMMAND_INT: u64 = 8;
-pub const MAV_PROTOCOL_CAPABILITY_FTP: u64 = 32;
-pub const MAV_PROTOCOL_CAPABILITY_SET_POSITION_TARGET_GLOBAL_INT: u64 = 256;
-pub const MAV_PROTOCOL_CAPABILITY_MAVLINK2: u64 = 8192;
-pub const MAV_PROTOCOL_CAPABILITY_COMPONENT_IMPLEMENTS_GIMBAL_MANAGER: u64 = 262_144;
-
-pub const CAMERA_CAP_FLAGS_CAPTURE_VIDEO: u32 = 1;
-pub const CAMERA_CAP_FLAGS_CAPTURE_IMAGE: u32 = 2;
-pub const CAMERA_CAP_FLAGS_HAS_MODES: u32 = 4;
-pub const CAMERA_CAP_FLAGS_HAS_BASIC_ZOOM: u32 = 64;
-pub const CAMERA_CAP_FLAGS_HAS_VIDEO_STREAM: u32 = 256;
-pub const VIDEO_STREAM_STATUS_FLAGS_RUNNING: u16 = 1;
-pub const VIDEO_STREAM_TYPE_RTSP: u8 = 0;
-pub const VIDEO_STREAM_TYPE_RTPUDP: u8 = 1;
-pub const VIDEO_STREAM_TYPE_TCP_MPEG: u8 = 2;
-pub const VIDEO_STREAM_TYPE_MPEG_TS: u8 = 3;
-pub const VIDEO_STREAM_ENCODING_H264: u8 = 1;
-
-pub const GIMBAL_MANAGER_CAP_FLAGS_BASIC_PITCH_YAW: u32 = 32 | 128 | 256 | 1024 | 4096 | 131_072;

src/uas/crc.rs

@@ -1,102 +0,0 @@
-use std::sync::atomic::{AtomicU8, Ordering};
-
-static MAVLINK_SEQUENCE: AtomicU8 = AtomicU8::new(0);
-
-#[derive(Clone, Copy)]
-pub(crate) struct FieldSpec {
-    pub ty: &'static str,
-    pub name: &'static str,
-    pub array_len: usize,
-}
-
-fn crc_accumulate(byte: u8, crc: &mut u16) {
-    let mut tmp = byte ^ (*crc as u8);
-    tmp ^= tmp << 4;
-    *crc = (*crc >> 8) ^ ((tmp as u16) << 8) ^ ((tmp as u16) << 3) ^ ((tmp as u16) >> 4);
-}
-
-fn mavlink_crc(bytes: &[u8], crc_extra: u8) -> u16 {
-    let mut crc = 0xFFFFu16;
-    for byte in bytes {
-        crc_accumulate(*byte, &mut crc);
-    }
-    crc_accumulate(crc_extra, &mut crc);
-    crc
-}
-
-pub(crate) fn calculate_crc_extra(message_name: &str, base_fields: &[FieldSpec]) -> u8 {
-    let mut crc = 0xFFFFu16;
-
-    for byte in message_name.as_bytes() {
-        crc_accumulate(*byte, &mut crc);
-    }
-    crc_accumulate(b' ', &mut crc);
-
-    for field in base_fields {
-        for byte in field.ty.as_bytes() {
-            crc_accumulate(*byte, &mut crc);
-        }
-        crc_accumulate(b' ', &mut crc);
-
-        for byte in field.name.as_bytes() {
-            crc_accumulate(*byte, &mut crc);
-        }
-        crc_accumulate(b' ', &mut crc);
-
-        if field.array_len > 0 {
-            crc_accumulate(field.array_len as u8, &mut crc);
-        }
-    }
-
-    ((crc & 0xFF) ^ (crc >> 8)) as u8
-}
-
-pub(crate) fn build_v1_packet(
-    system_id: u8,
-    component_id: u8,
-    msg_id: u8,
-    payload: &[u8],
-    crc_extra: u8,
-) -> Vec<u8> {
-    let seq = MAVLINK_SEQUENCE.fetch_add(1, Ordering::Relaxed);
-    let mut packet = Vec::with_capacity(payload.len() + 8);
-    packet.push(0xFE);
-    packet.push(payload.len() as u8);
-    packet.push(seq);
-    packet.push(system_id);
-    packet.push(component_id);
-    packet.push(msg_id);
-    packet.extend_from_slice(payload);
-
-    let crc = mavlink_crc(&packet[1..], crc_extra);
-    packet.push((crc & 0xFF) as u8);
-    packet.push((crc >> 8) as u8);
-    packet
-}
-
-pub(crate) fn build_v2_packet(
-    system_id: u8,
-    component_id: u8,
-    msg_id: u32,
-    payload: &[u8],
-    crc_extra: u8,
-) -> Vec<u8> {
-    let seq = MAVLINK_SEQUENCE.fetch_add(1, Ordering::Relaxed);
-    let mut packet = Vec::with_capacity(payload.len() + 12);
-    packet.push(0xFD);
-    packet.push(payload.len() as u8);
-    packet.push(0);
-    packet.push(0);
-    packet.push(seq);
-    packet.push(system_id);
-    packet.push(component_id);
-    packet.push((msg_id & 0xFF) as u8);
-    packet.push(((msg_id >> 8) & 0xFF) as u8);
-    packet.push(((msg_id >> 16) & 0xFF) as u8);
-    packet.extend_from_slice(payload);
-
-    let crc = mavlink_crc(&packet[1..], crc_extra);
-    packet.push((crc & 0xFF) as u8);
-    packet.push((crc >> 8) as u8);
-    packet
-}

src/uas/endpoint.rs

@@ -1,160 +0,0 @@
-use arma_rs::Context;
-use log::info;
-use std::net::UdpSocket;
-use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::{Arc, Mutex};
-use std::thread::{self, JoinHandle};
-use std::time::Duration;
-
-use super::callbacks::{mavlink_callback_event, mavlink_packet_summary, mavlink_response_packets};
-
-pub(crate) struct MavlinkEndpoint {
-    pub socket: UdpSocket,
-    pub running: Arc<AtomicBool>,
-    pub listener: Option<JoinHandle<()>>,
-    pub bind_port: u16,
-}
-
-static MAVLINK_ENDPOINT: Mutex<Option<MavlinkEndpoint>> = Mutex::new(None);
-
-pub(crate) fn socket_for_send() -> Option<UdpSocket> {
-    MAVLINK_ENDPOINT.lock().ok().and_then(|endpoint| {
-        endpoint
-            .as_ref()
-            .and_then(|entry| entry.socket.try_clone().ok())
-    })
-}
-
-fn stop_endpoint_internal() {
-    let endpoint = MAVLINK_ENDPOINT.lock().unwrap().take();
-
-    if let Some(mut endpoint) = endpoint {
-        endpoint.running.store(false, Ordering::Relaxed);
-        info!(
-            "Stopping MAVLink UDP endpoint on 0.0.0.0:{}",
-            endpoint.bind_port
-        );
-
-        if let Some(listener) = endpoint.listener.take() {
-            let _ = listener.join();
-        }
-    }
-}
-
-pub fn start_endpoint(ctx: Context, bind_port: i32) -> &'static str {
-    let bind_port = bind_port.clamp(1, 65535) as u16;
-
-    stop_endpoint_internal();
-
-    let socket = match UdpSocket::bind(format!("0.0.0.0:{bind_port}")) {
-        Ok(socket) => socket,
-        Err(error) => {
-            let _ = ctx.callback_data(
-                "MAVLINK UDP ERROR",
-                "failed to bind MAVLink UDP endpoint",
-                error.to_string(),
-            );
-            info!(
-                "Failed to bind MAVLink UDP endpoint on 0.0.0.0:{}: {}",
-                bind_port, error
-            );
-            return "Failed to bind MAVLink UDP endpoint";
-        }
-    };
-
-    if let Err(error) = socket.set_read_timeout(Some(Duration::from_millis(500))) {
-        info!(
-            "Failed to set MAVLink UDP endpoint read timeout on 0.0.0.0:{}: {}",
-            bind_port, error
-        );
-    }
-
-    let listener_socket = match socket.try_clone() {
-        Ok(listener_socket) => listener_socket,
-        Err(error) => {
-            let _ = ctx.callback_data(
-                "MAVLINK UDP ERROR",
-                "failed to clone MAVLink UDP endpoint socket",
-                error.to_string(),
-            );
-            info!(
-                "Failed to clone MAVLink UDP endpoint socket on 0.0.0.0:{}: {}",
-                bind_port, error
-            );
-            return "Failed to clone MAVLink UDP endpoint socket";
-        }
-    };
-
-    let running = Arc::new(AtomicBool::new(true));
-    let listener_running = Arc::clone(&running);
-
-    let listener_ctx = ctx;
-    let listener = thread::spawn(move || {
-        let mut buffer = [0u8; 2048];
-        info!("MAVLink UDP endpoint listening on 0.0.0.0:{}", bind_port);
-
-        while listener_running.load(Ordering::Relaxed) {
-            match listener_socket.recv_from(&mut buffer) {
-                Ok((received, source)) => {
-                    let source_string = source.to_string();
-                    info!(
-                        "MAVLink UDP endpoint received {} bytes from {}: {}",
-                        received,
-                        source,
-                        mavlink_packet_summary(&buffer[..received])
-                    );
-                    if let Some(event) = mavlink_callback_event(&buffer[..received], &source_string)
-                    {
-                        let _ =
-                            listener_ctx.callback_data("MAVLINK UDP", event.function, event.data);
-                    }
-                    for packet in mavlink_response_packets(&buffer[..received]) {
-                        if let Err(error) = listener_socket.send_to(&packet, source) {
-                            info!(
-                                "MAVLink UDP endpoint failed sending response to {}: {}",
-                                source, error
-                            );
-                            break;
-                        }
-                    }
-                }
-                Err(error)
-                    if matches!(
-                        error.kind(),
-                        std::io::ErrorKind::WouldBlock
-                            | std::io::ErrorKind::TimedOut
-                            | std::io::ErrorKind::ConnectionReset
-                    ) => {}
-                Err(error) => {
-                    if listener_running.load(Ordering::Relaxed) {
-                        info!(
-                            "MAVLink UDP endpoint listener error on 0.0.0.0:{}: {}",
-                            bind_port, error
-                        );
-                    }
-                    break;
-                }
-            }
-        }
-
-        info!(
-            "MAVLink UDP endpoint listener stopped on 0.0.0.0:{}",
-            bind_port
-        );
-    });
-
-    *MAVLINK_ENDPOINT.lock().unwrap() = Some(MavlinkEndpoint {
-        socket,
-        running,
-        listener: Some(listener),
-        bind_port,
-    });
-
-    info!("Started MAVLink UDP endpoint on 0.0.0.0:{}", bind_port);
-    "Started MAVLink UDP endpoint"
-}
-
-pub fn stop_endpoint(_ctx: Context) -> &'static str {
-    stop_endpoint_internal();
-    "Stopped MAVLink UDP endpoint"
-}

src/uas/identity.rs

@@ -1,95 +0,0 @@
-use super::constants::{MAV_TYPE_FIXED_WING, MAV_TYPE_HELICOPTER, MAV_TYPE_QUADROTOR};
-
-pub(crate) fn map_vehicle_type(vehicle_type: u8) -> u8 {
-    match vehicle_type {
-        1 => MAV_TYPE_FIXED_WING,
-        3 => MAV_TYPE_HELICOPTER,
-        2 => MAV_TYPE_QUADROTOR,
-        value => value,
-    }
-}
-
-pub(crate) fn normalize_heading_deg(value: f32) -> f32 {
-    ((value % 360.0) + 360.0) % 360.0
-}
-
-pub(crate) fn stable_system_id(entity_uuid: &str) -> u8 {
-    let mut hash: u32 = 0x811C9DC5;
-    for byte in entity_uuid.as_bytes() {
-        hash ^= *byte as u32;
-        hash = hash.wrapping_mul(0x01000193);
-    }
-
-    ((hash % 250) as u8) + 1
-}
-
-pub(crate) fn stable_mavlink_identity(callsign: &str, entity_uuid: &str) -> String {
-    let mut identity = callsign.trim().to_string();
-
-    for suffix in [" [ON]", " [OFF]"] {
-        if identity.ends_with(suffix) {
-            identity.truncate(identity.len() - suffix.len());
-            break;
-        }
-    }
-
-    if identity.is_empty() {
-        entity_uuid.trim().to_string()
-    } else {
-        identity
-    }
-}
-
-fn uuid16(entity_uuid: &str) -> [u8; 16] {
-    let hex = entity_uuid.replace('-', "");
-    let mut bytes = [0u8; 16];
-
-    for index in 0..16 {
-        let start = index * 2;
-        if start + 2 <= hex.len() {
-            if let Ok(value) = u8::from_str_radix(&hex[start..start + 2], 16) {
-                bytes[index] = value;
-            }
-        }
-    }
-
-    bytes
-}
-
-pub(crate) fn uid64_from_uuid(entity_uuid: &str) -> u64 {
-    let uuid = uuid16(entity_uuid);
-    let mut bytes = [0u8; 8];
-    bytes.copy_from_slice(&uuid[..8]);
-    u64::from_le_bytes(bytes)
-}
-
-pub(crate) fn uid2_from_uuid(entity_uuid: &str) -> [u8; 18] {
-    let uuid = uuid16(entity_uuid);
-    let mut uid2 = [0u8; 18];
-    uid2[..16].copy_from_slice(&uuid);
-
-    let checksum = entity_uuid
-        .as_bytes()
-        .iter()
-        .fold(0u16, |acc, value| acc.wrapping_add(*value as u16));
-    uid2[16] = (checksum & 0xFF) as u8;
-    uid2[17] = (checksum >> 8) as u8;
-    uid2
-}
-
-pub(crate) fn fixed_string<const N: usize>(value: &str) -> [u8; N] {
-    let mut bytes = [0u8; N];
-    let raw = value.as_bytes();
-    let len = raw.len().min(N.saturating_sub(1));
-    bytes[..len].copy_from_slice(&raw[..len]);
-    bytes
-}
-
-pub(crate) fn should_send_video_stream_information(video_uri: &str) -> bool {
-    let trimmed = video_uri.trim().to_ascii_lowercase();
-    trimmed.starts_with("rtsp://")
-        || trimmed.starts_with("rtp://")
-        || trimmed.starts_with("udp://")
-        || trimmed.starts_with("mpegts://")
-        || trimmed.starts_with("tcp://")
-}

src/uas/mod.rs

@@ -1,14 +0,0 @@
-mod callbacks;
-mod constants;
-mod crc;
-mod endpoint;
-mod identity;
-mod packets;
-mod payload;
-mod send;
-mod state;
-
-pub use endpoint::{start_endpoint, stop_endpoint};
-#[allow(unused_imports)]
-pub use payload::{UasSystemPayload, UasTelemetryPayload};
-pub use send::{send_uas_system, send_uas_telemetry};

src/uas/packets.rs

@@ -1,644 +0,0 @@
-use chrono::Utc;
-
-use super::constants::{
-    AUTOPILOT_COMPONENT_ID, CAMERA_CAP_FLAGS_CAPTURE_IMAGE, CAMERA_CAP_FLAGS_CAPTURE_VIDEO,
-    CAMERA_CAP_FLAGS_HAS_BASIC_ZOOM, CAMERA_CAP_FLAGS_HAS_MODES, CAMERA_CAP_FLAGS_HAS_VIDEO_STREAM,
-    GIMBAL_COMPONENT_ID, GIMBAL_MANAGER_CAP_FLAGS_BASIC_PITCH_YAW, MAV_AUTOPILOT_ARDUPILOTMEGA,
-    MAV_AUTOPILOT_INVALID, MAV_LANDED_STATE_IN_AIR, MAV_LANDED_STATE_ON_GROUND,
-    MAV_LANDED_STATE_UNDEFINED, MAV_MODE_FLAG_CUSTOM_MODE_ENABLED, MAV_MODE_FLAG_SAFETY_ARMED,
-    MAV_PROTOCOL_CAPABILITY_COMMAND_INT,
-    MAV_PROTOCOL_CAPABILITY_COMPONENT_IMPLEMENTS_GIMBAL_MANAGER, MAV_PROTOCOL_CAPABILITY_FTP,
-    MAV_PROTOCOL_CAPABILITY_MAVLINK2, MAV_PROTOCOL_CAPABILITY_MISSION_INT,
-    MAV_PROTOCOL_CAPABILITY_SET_POSITION_TARGET_GLOBAL_INT, MAV_STATE_ACTIVE, MAV_STATE_STANDBY,
-    VIDEO_STREAM_ENCODING_H264, VIDEO_STREAM_STATUS_FLAGS_RUNNING, VIDEO_STREAM_TYPE_MPEG_TS,
-    VIDEO_STREAM_TYPE_RTPUDP, VIDEO_STREAM_TYPE_RTSP, VIDEO_STREAM_TYPE_TCP_MPEG,
-};
-use super::crc::{build_v1_packet, build_v2_packet, calculate_crc_extra, FieldSpec};
-use super::identity::{fixed_string, normalize_heading_deg, uid2_from_uuid, uid64_from_uuid};
-use super::payload::UasTelemetryPayload;
-
-pub(crate) fn heartbeat_packet(payload: &UasTelemetryPayload) -> Vec<u8> {
-    let mut msg = Vec::with_capacity(9);
-    let custom_mode = if payload.flying { 5u32 } else { 0u32 };
-    msg.extend_from_slice(&custom_mode.to_le_bytes());
-    msg.push(payload.vehicle_type);
-    msg.push(MAV_AUTOPILOT_ARDUPILOTMEGA);
-    msg.push(if payload.flying {
-        MAV_MODE_FLAG_CUSTOM_MODE_ENABLED | MAV_MODE_FLAG_SAFETY_ARMED
-    } else {
-        MAV_MODE_FLAG_CUSTOM_MODE_ENABLED
-    });
-    msg.push(if payload.flying {
-        MAV_STATE_ACTIVE
-    } else {
-        MAV_STATE_STANDBY
-    });
-    msg.push(3);
-    build_v1_packet(payload.system_id, payload.component_id, 0, &msg, 50)
-}
-
-pub(crate) fn command_ack_packet(
-    system_id: u8,
-    component_id: u8,
-    command: u16,
-    result: u8,
-) -> Vec<u8> {
-    let mut msg = Vec::with_capacity(3);
-    msg.extend_from_slice(&command.to_le_bytes());
-    msg.push(result);
-    build_v2_packet(system_id, component_id, 77, &msg, 143)
-}
-
-pub(crate) fn mission_request_int_packet(
-    system_id: u8,
-    component_id: u8,
-    target_system: u8,
-    target_component: u8,
-    seq: u16,
-    mission_type: u8,
-) -> Vec<u8> {
-    let mut msg = Vec::with_capacity(5);
-    msg.extend_from_slice(&seq.to_le_bytes());
-    msg.push(target_system);
-    msg.push(target_component);
-    msg.push(mission_type);
-    build_v2_packet(system_id, component_id, 51, &msg, 196)
-}
-
-pub(crate) fn mission_ack_packet(
-    system_id: u8,
-    component_id: u8,
-    target_system: u8,
-    target_component: u8,
-    mission_type: u8,
-) -> Vec<u8> {
-    let mut msg = Vec::with_capacity(4);
-    msg.push(target_system);
-    msg.push(target_component);
-    msg.push(0);
-    msg.push(mission_type);
-    build_v2_packet(system_id, component_id, 47, &msg, 153)
-}
-
-pub(crate) fn gps_raw_int_packet(payload: &UasTelemetryPayload) -> Vec<u8> {
-    let time_usec = (Utc::now().timestamp_millis().max(0) as u64) * 1_000;
-    let fix_type = if payload.flying { 3u8 } else { 2u8 };
-
-    let mut msg = Vec::with_capacity(30);
-    msg.extend_from_slice(&time_usec.to_le_bytes());
-    msg.extend_from_slice(&((payload.lat_deg * 1e7).round() as i32).to_le_bytes());
-    msg.extend_from_slice(&((payload.lon_deg * 1e7).round() as i32).to_le_bytes());
-    msg.extend_from_slice(&((payload.alt_msl_m * 1000.0).round() as i32).to_le_bytes());
-    msg.extend_from_slice(&u16::MAX.to_le_bytes());
-    msg.extend_from_slice(&u16::MAX.to_le_bytes());
-    msg.extend_from_slice(&u16::MAX.to_le_bytes());
-    msg.extend_from_slice(&u16::MAX.to_le_bytes());
-    msg.push(fix_type);
-    msg.push(10);
-    build_v1_packet(payload.system_id, payload.component_id, 24, &msg, 24)
-}
-
-pub(crate) fn global_position_int_packet(payload: &UasTelemetryPayload) -> Vec<u8> {
-    let time_boot_ms = Utc::now().timestamp_millis().max(0) as u32;
-    let vx =
-        (payload.groundspeed_mps * payload.heading_deg.to_radians().sin() * 100.0).round() as i16;
-    let vy =
-        (payload.groundspeed_mps * payload.heading_deg.to_radians().cos() * 100.0).round() as i16;
-    let heading = (normalize_heading_deg(payload.heading_deg) * 100.0).round() as u16;
-
-    let mut msg = Vec::with_capacity(28);
-    msg.extend_from_slice(&time_boot_ms.to_le_bytes());
-    msg.extend_from_slice(&((payload.lat_deg * 1e7).round() as i32).to_le_bytes());
-    msg.extend_from_slice(&((payload.lon_deg * 1e7).round() as i32).to_le_bytes());
-    msg.extend_from_slice(&((payload.alt_msl_m * 1000.0).round() as i32).to_le_bytes());
-    msg.extend_from_slice(&((payload.rel_alt_m * 1000.0).round() as i32).to_le_bytes());
-    msg.extend_from_slice(&vx.to_le_bytes());
-    msg.extend_from_slice(&vy.to_le_bytes());
-    msg.extend_from_slice(&0i16.to_le_bytes());
-    msg.extend_from_slice(&heading.to_le_bytes());
-    build_v1_packet(payload.system_id, payload.component_id, 33, &msg, 104)
-}
-
-pub(crate) fn attitude_packet(payload: &UasTelemetryPayload) -> Vec<u8> {
-    let now_ms = Utc::now().timestamp_millis().max(0) as u32;
-    let roll = payload.roll_deg.to_radians();
-    let pitch = payload.pitch_deg.to_radians();
-    let yaw = payload.yaw_deg.to_radians();
-
-    let mut msg = Vec::with_capacity(28);
-    msg.extend_from_slice(&now_ms.to_le_bytes());
-    msg.extend_from_slice(&roll.to_le_bytes());
-    msg.extend_from_slice(&pitch.to_le_bytes());
-    msg.extend_from_slice(&yaw.to_le_bytes());
-    msg.extend_from_slice(&0f32.to_le_bytes());
-    msg.extend_from_slice(&0f32.to_le_bytes());
-    msg.extend_from_slice(&0f32.to_le_bytes());
-    build_v1_packet(payload.system_id, payload.component_id, 30, &msg, 39)
-}
-
-pub(crate) fn vfr_hud_packet(payload: &UasTelemetryPayload) -> Vec<u8> {
-    let heading = normalize_heading_deg(payload.heading_deg).round() as i16;
-    let throttle = if payload.flying { 50u16 } else { 0u16 };
-
-    let mut msg = Vec::with_capacity(20);
-    msg.extend_from_slice(&payload.groundspeed_mps.to_le_bytes());
-    msg.extend_from_slice(&payload.groundspeed_mps.to_le_bytes());
-    msg.extend_from_slice(&payload.alt_msl_m.to_le_bytes());
-    msg.extend_from_slice(&0f32.to_le_bytes());
-    msg.extend_from_slice(&heading.to_le_bytes());
-    msg.extend_from_slice(&throttle.to_le_bytes());
-    build_v1_packet(payload.system_id, payload.component_id, 74, &msg, 20)
-}
-
-pub(crate) fn system_status_packet(system_id: u8, battery_remaining_pct: i8) -> Vec<u8> {
-    let fields = [
-        FieldSpec {
-            ty: "uint32_t",
-            name: "onboard_control_sensors_present",
-            array_len: 0,
-        },
-        FieldSpec {
-            ty: "uint32_t",
-            name: "onboard_control_sensors_enabled",
-            array_len: 0,
-        },
-        FieldSpec {
-            ty: "uint32_t",
-            name: "onboard_control_sensors_health",
-            array_len: 0,
-        },
-        FieldSpec {
-            ty: "uint16_t",
-            name: "load",
-            array_len: 0,
-        },
-        FieldSpec {
-            ty: "uint16_t",
-            name: "voltage_battery",
-            array_len: 0,
-        },
-        FieldSpec {
-            ty: "int16_t",
-            name: "current_battery",
-            array_len: 0,
-        },
-        FieldSpec {
-            ty: "uint16_t",
-            name: "drop_rate_comm",
-            array_len: 0,
-        },
-        FieldSpec {
-            ty: "uint16_t",
-            name: "errors_comm",
-            array_len: 0,
-        },
-        FieldSpec {
-            ty: "uint16_t",
-            name: "errors_count1",
-            array_len: 0,
-        },
-        FieldSpec {
-            ty: "uint16_t",
-            name: "errors_count2",
-            array_len: 0,
-        },
-        FieldSpec {
-            ty: "uint16_t",
-            name: "errors_count3",
-            array_len: 0,
-        },
-        FieldSpec {
-            ty: "uint16_t",
-            name: "errors_count4",
-            array_len: 0,
-        },
-        FieldSpec {
-            ty: "int8_t",
-            name: "battery_remaining",
-            array_len: 0,
-        },
-    ];
-    let crc_extra = calculate_crc_extra("SYS_STATUS", &fields);
-
-    let sensors = 0x2000u32 | 0x4000u32 | 0x8000u32 | 0x20u32;
-    let mut msg = Vec::with_capacity(31);
-    msg.extend_from_slice(&sensors.to_le_bytes());
-    msg.extend_from_slice(&sensors.to_le_bytes());
-    msg.extend_from_slice(&sensors.to_le_bytes());
-    msg.extend_from_slice(&500u16.to_le_bytes());
-    msg.extend_from_slice(&12000u16.to_le_bytes());
-    msg.extend_from_slice(&(-1i16).to_le_bytes());
-    msg.extend_from_slice(&0u16.to_le_bytes());
-    msg.extend_from_slice(&0u16.to_le_bytes());
-    msg.extend_from_slice(&0u16.to_le_bytes());
-    msg.extend_from_slice(&0u16.to_le_bytes());
-    msg.extend_from_slice(&0u16.to_le_bytes());
-    msg.extend_from_slice(&0u16.to_le_bytes());
-    msg.push(battery_remaining_pct.clamp(0, 100) as u8);
-
-    build_v2_packet(system_id, AUTOPILOT_COMPONENT_ID, 1, &msg, crc_extra)
-}
-
-pub(crate) fn extended_sys_state_packet(system_id: u8, landed: bool) -> Vec<u8> {
-    let fields = [
-        FieldSpec {
-            ty: "uint8_t",
-            name: "vtol_state",
-            array_len: 0,
-        },
-        FieldSpec {
-            ty: "uint8_t",
-            name: "landed_state",
-            array_len: 0,
-        },
-    ];
-    let crc_extra = calculate_crc_extra("EXTENDED_SYS_STATE", &fields);
-
-    let mut msg = Vec::with_capacity(2);
-    msg.push(MAV_LANDED_STATE_UNDEFINED);
-    msg.push(if landed {
-        MAV_LANDED_STATE_ON_GROUND
-    } else {
-        MAV_LANDED_STATE_IN_AIR
-    });
-
-    build_v2_packet(system_id, AUTOPILOT_COMPONENT_ID, 245, &msg, crc_extra)
-}
-
-pub(crate) fn autopilot_version_packet(system_id: u8, entity_uuid: &str) -> Vec<u8> {
-    let fields = [
-        FieldSpec {
-            ty: "uint64_t",
-            name: "capabilities",
-            array_len: 0,
-        },
-        FieldSpec {
-            ty: "uint32_t",
-            name: "flight_sw_version",
-            array_len: 0,
-        },
-        FieldSpec {
-            ty: "uint32_t",
-            name: "middleware_sw_version",
-            array_len: 0,
-        },
-        FieldSpec {
-            ty: "uint32_t",
-            name: "os_sw_version",
-            array_len: 0,
-        },
-        FieldSpec {
-            ty: "uint32_t",
-            name: "board_version",
-            array_len: 0,
-        },
-        FieldSpec {
-            ty: "uint8_t",
-            name: "flight_custom_version",
-            array_len: 8,
-        },
-        FieldSpec {
-            ty: "uint8_t",
-            name: "middleware_custom_version",
-            array_len: 8,
-        },
-        FieldSpec {
-            ty: "uint8_t",
-            name: "os_custom_version",
-            array_len: 8,
-        },
-        FieldSpec {
-            ty: "uint16_t",
-            name: "vendor_id",
-            array_len: 0,
-        },
-        FieldSpec {
-            ty: "uint16_t",
-            name: "product_id",
-            array_len: 0,
-        },
-        FieldSpec {
-            ty: "uint64_t",
-            name: "uid",
-            array_len: 0,
-        },
-    ];
-    let crc_extra = calculate_crc_extra("AUTOPILOT_VERSION", &fields);
-
-    let capabilities = MAV_PROTOCOL_CAPABILITY_MISSION_INT
-        | MAV_PROTOCOL_CAPABILITY_COMMAND_INT
-        | MAV_PROTOCOL_CAPABILITY_FTP
-        | MAV_PROTOCOL_CAPABILITY_SET_POSITION_TARGET_GLOBAL_INT
-        | MAV_PROTOCOL_CAPABILITY_MAVLINK2
-        | MAV_PROTOCOL_CAPABILITY_COMPONENT_IMPLEMENTS_GIMBAL_MANAGER;
-    let uid = uid64_from_uuid(entity_uuid);
-    let uid2 = uid2_from_uuid(entity_uuid);
-
-    let mut msg = Vec::with_capacity(78);
-    msg.extend_from_slice(&capabilities.to_le_bytes());
-    msg.extend_from_slice(&0x010100FFu32.to_le_bytes());
-    msg.extend_from_slice(&0u32.to_le_bytes());
-    msg.extend_from_slice(&0u32.to_le_bytes());
-    msg.extend_from_slice(&0u32.to_le_bytes());
-    msg.extend_from_slice(&[0u8; 8]);
-    msg.extend_from_slice(&[0u8; 8]);
-    msg.extend_from_slice(&[0u8; 8]);
-    msg.extend_from_slice(&0x5441u16.to_le_bytes());
-    msg.extend_from_slice(&0x5541u16.to_le_bytes());
-    msg.extend_from_slice(&uid.to_le_bytes());
-    msg.extend_from_slice(&uid2);
-
-    build_v2_packet(system_id, AUTOPILOT_COMPONENT_ID, 148, &msg, crc_extra)
-}
-
-pub(crate) fn home_position_packet(
-    system_id: u8,
-    lat_deg: f64,
-    lon_deg: f64,
-    alt_msl_m: f32,
-    heading_deg: f32,
-) -> Vec<u8> {
-    let yaw = normalize_heading_deg(heading_deg).to_radians();
-    let q = [(yaw * 0.5).cos(), 0.0f32, 0.0f32, (yaw * 0.5).sin()];
-
-    let mut msg = Vec::with_capacity(52);
-    msg.extend_from_slice(&((lat_deg * 1e7).round() as i32).to_le_bytes());
-    msg.extend_from_slice(&((lon_deg * 1e7).round() as i32).to_le_bytes());
-    msg.extend_from_slice(&((alt_msl_m * 1000.0).round() as i32).to_le_bytes());
-    msg.extend_from_slice(&0f32.to_le_bytes());
-    msg.extend_from_slice(&0f32.to_le_bytes());
-    msg.extend_from_slice(&0f32.to_le_bytes());
-    for value in q {
-        msg.extend_from_slice(&value.to_le_bytes());
-    }
-    msg.extend_from_slice(&0f32.to_le_bytes());
-    msg.extend_from_slice(&0f32.to_le_bytes());
-    msg.extend_from_slice(&0f32.to_le_bytes());
-
-    build_v2_packet(system_id, AUTOPILOT_COMPONENT_ID, 242, &msg, 85)
-}
-
-pub(crate) fn component_heartbeat_packet(
-    system_id: u8,
-    component_id: u8,
-    component_type: u8,
-) -> Vec<u8> {
-    let mut msg = Vec::with_capacity(9);
-    msg.extend_from_slice(&0u32.to_le_bytes());
-    msg.push(component_type);
-    msg.push(MAV_AUTOPILOT_INVALID);
-    msg.push(0);
-    msg.push(MAV_STATE_ACTIVE);
-    msg.push(3);
-    build_v2_packet(system_id, component_id, 0, &msg, 50)
-}
-
-pub(crate) fn camera_information_packet_for_component(
-    system_id: u8,
-    component_id: u8,
-    callsign: &str,
-    gimbal_device_id: u8,
-) -> Vec<u8> {
-    let vendor = fixed_string::<32>("ArmaTAK");
-    let model = fixed_string::<32>(callsign);
-    let cam_definition_uri = fixed_string::<140>("");
-    let flags = CAMERA_CAP_FLAGS_CAPTURE_VIDEO
-        | CAMERA_CAP_FLAGS_CAPTURE_IMAGE
-        | CAMERA_CAP_FLAGS_HAS_MODES
-        | CAMERA_CAP_FLAGS_HAS_BASIC_ZOOM
-        | CAMERA_CAP_FLAGS_HAS_VIDEO_STREAM;
-
-    let mut msg = Vec::with_capacity(235);
-    msg.extend_from_slice(&(Utc::now().timestamp_millis().max(0) as u32).to_le_bytes());
-    msg.extend_from_slice(&0x010100FFu32.to_le_bytes());
-    msg.extend_from_slice(&2.8f32.to_le_bytes());
-    msg.extend_from_slice(&6.4f32.to_le_bytes());
-    msg.extend_from_slice(&4.8f32.to_le_bytes());
-    msg.extend_from_slice(&flags.to_le_bytes());
-    msg.extend_from_slice(&1280u16.to_le_bytes());
-    msg.extend_from_slice(&720u16.to_le_bytes());
-    msg.extend_from_slice(&0u16.to_le_bytes());
-    msg.extend_from_slice(&vendor);
-    msg.extend_from_slice(&model);
-    msg.push(0);
-    msg.extend_from_slice(&cam_definition_uri);
-    msg.push(gimbal_device_id);
-    msg.push(0);
-
-    build_v2_packet(system_id, component_id, 259, &msg, 92)
-}
-
-pub(crate) fn video_stream_information_packet_for_component(
-    system_id: u8,
-    component_id: u8,
-    callsign: &str,
-    video_uri: &str,
-    hfov_deg: f32,
-    stream_id: u8,
-    stream_count: u8,
-    thermal: bool,
-) -> Vec<u8> {
-    let stream_type = if video_uri.starts_with("rtsp://") {
-        VIDEO_STREAM_TYPE_RTSP
-    } else if video_uri.starts_with("rtp://") {
-        VIDEO_STREAM_TYPE_RTPUDP
-    } else if video_uri.starts_with("tcp://") {
-        VIDEO_STREAM_TYPE_TCP_MPEG
-    } else if video_uri.starts_with("mpegts://") || video_uri.starts_with("udp://") {
-        VIDEO_STREAM_TYPE_MPEG_TS
-    } else {
-        VIDEO_STREAM_TYPE_RTSP
-    };
-
-    let name = fixed_string::<32>(callsign);
-    let uri = fixed_string::<160>(video_uri);
-    let flags = VIDEO_STREAM_STATUS_FLAGS_RUNNING | if thermal { 2 } else { 0 };
-
-    let mut msg = Vec::with_capacity(208);
-    msg.extend_from_slice(&30f32.to_le_bytes());
-    msg.extend_from_slice(&4_000_000u32.to_le_bytes());
-    msg.extend_from_slice(&flags.to_le_bytes());
-    msg.extend_from_slice(&1280u16.to_le_bytes());
-    msg.extend_from_slice(&720u16.to_le_bytes());
-    msg.extend_from_slice(&0u16.to_le_bytes());
-    msg.extend_from_slice(&(hfov_deg.clamp(1.0, 360.0).round() as u16).to_le_bytes());
-    msg.push(stream_id);
-    msg.push(stream_count);
-    msg.push(stream_type);
-    msg.extend_from_slice(&name);
-    msg.extend_from_slice(&uri);
-    msg.push(VIDEO_STREAM_ENCODING_H264);
-    msg.push(0);
-
-    build_v2_packet(system_id, component_id, 269, &msg, 109)
-}
-
-pub(crate) fn video_stream_status_packet_for_component(
-    system_id: u8,
-    component_id: u8,
-    hfov_deg: f32,
-    stream_id: u8,
-    thermal: bool,
-) -> Vec<u8> {
-    let flags = VIDEO_STREAM_STATUS_FLAGS_RUNNING | if thermal { 2 } else { 0 };
-    let mut msg = Vec::with_capacity(19);
-    msg.extend_from_slice(&30f32.to_le_bytes());
-    msg.extend_from_slice(&4_000_000u32.to_le_bytes());
-    msg.extend_from_slice(&flags.to_le_bytes());
-    msg.extend_from_slice(&1280u16.to_le_bytes());
-    msg.extend_from_slice(&720u16.to_le_bytes());
-    msg.extend_from_slice(&0u16.to_le_bytes());
-    msg.extend_from_slice(&(hfov_deg.clamp(1.0, 360.0).round() as u16).to_le_bytes());
-    msg.push(stream_id);
-    msg.push(0);
-
-    build_v2_packet(system_id, component_id, 270, &msg, 59)
-}
-
-pub(crate) fn mount_orientation_packet_for_component(
-    system_id: u8,
-    component_id: u8,
-    pitch_deg: f32,
-    yaw_deg: f32,
-) -> Vec<u8> {
-    let mut msg = Vec::with_capacity(16);
-    msg.extend_from_slice(&(Utc::now().timestamp_millis().max(0) as u32).to_le_bytes());
-    msg.extend_from_slice(&pitch_deg.to_le_bytes());
-    msg.extend_from_slice(&0f32.to_le_bytes());
-    msg.extend_from_slice(&normalize_heading_deg(yaw_deg).to_le_bytes());
-
-    build_v2_packet(system_id, component_id, 265, &msg, 26)
-}
-
-pub(crate) fn camera_fov_status_packet_for_component(
-    system_id: u8,
-    component_id: u8,
-    lat_camera_deg: f64,
-    lon_camera_deg: f64,
-    alt_camera_msl_m: f32,
-    lat_image_deg: f64,
-    lon_image_deg: f64,
-    alt_image_msl_m: f32,
-    roll_deg: f32,
-    pitch_deg: f32,
-    yaw_deg: f32,
-    hfov_deg: f32,
-    vfov_deg: f32,
-) -> Vec<u8> {
-    let q = attitude_quaternion(roll_deg, pitch_deg, yaw_deg);
-    let mut msg = Vec::with_capacity(53);
-    msg.extend_from_slice(&(Utc::now().timestamp_millis().max(0) as u32).to_le_bytes());
-    msg.extend_from_slice(&((lat_camera_deg * 1e7).round() as i32).to_le_bytes());
-    msg.extend_from_slice(&((lon_camera_deg * 1e7).round() as i32).to_le_bytes());
-    msg.extend_from_slice(&((alt_camera_msl_m * 1000.0).round() as i32).to_le_bytes());
-    msg.extend_from_slice(&((lat_image_deg * 1e7).round() as i32).to_le_bytes());
-    msg.extend_from_slice(&((lon_image_deg * 1e7).round() as i32).to_le_bytes());
-    msg.extend_from_slice(&((alt_image_msl_m * 1000.0).round() as i32).to_le_bytes());
-    for value in q {
-        msg.extend_from_slice(&value.to_le_bytes());
-    }
-    msg.extend_from_slice(&hfov_deg.to_le_bytes());
-    msg.extend_from_slice(&vfov_deg.to_le_bytes());
-    msg.push(0);
-
-    build_v2_packet(system_id, component_id, 271, &msg, 22)
-}
-
-pub(crate) fn mount_status_packet(
-    system_id: u8,
-    pitch_deg: f32,
-    roll_deg: f32,
-    relative_yaw_deg: f32,
-) -> Vec<u8> {
-    let mut msg = Vec::with_capacity(15);
-    msg.extend_from_slice(&((pitch_deg * 100.0).round() as i32).to_le_bytes());
-    msg.extend_from_slice(&((roll_deg * 100.0).round() as i32).to_le_bytes());
-    msg.extend_from_slice(&((relative_yaw_deg * 100.0).round() as i32).to_le_bytes());
-    msg.push(system_id);
-    msg.push(GIMBAL_COMPONENT_ID);
-    msg.push(2);
-
-    build_v2_packet(system_id, AUTOPILOT_COMPONENT_ID, 158, &msg, 134)
-}
-
-pub(crate) fn gimbal_manager_information_packet(system_id: u8) -> Vec<u8> {
-    let fields = [
-        FieldSpec {
-            ty: "uint32_t",
-            name: "time_boot_ms",
-            array_len: 0,
-        },
-        FieldSpec {
-            ty: "uint32_t",
-            name: "cap_flags",
-            array_len: 0,
-        },
-        FieldSpec {
-            ty: "float",
-            name: "roll_min",
-            array_len: 0,
-        },
-        FieldSpec {
-            ty: "float",
-            name: "roll_max",
-            array_len: 0,
-        },
-        FieldSpec {
-            ty: "float",
-            name: "pitch_min",
-            array_len: 0,
-        },
-        FieldSpec {
-            ty: "float",
-            name: "pitch_max",
-            array_len: 0,
-        },
-        FieldSpec {
-            ty: "float",
-            name: "yaw_min",
-            array_len: 0,
-        },
-        FieldSpec {
-            ty: "float",
-            name: "yaw_max",
-            array_len: 0,
-        },
-        FieldSpec {
-            ty: "uint8_t",
-            name: "gimbal_device_id",
-            array_len: 0,
-        },
-    ];
-    let crc_extra = calculate_crc_extra("GIMBAL_MANAGER_INFORMATION", &fields);
-
-    let mut msg = Vec::with_capacity(33);
-    msg.extend_from_slice(&(Utc::now().timestamp_millis().max(0) as u32).to_le_bytes());
-    msg.extend_from_slice(&GIMBAL_MANAGER_CAP_FLAGS_BASIC_PITCH_YAW.to_le_bytes());
-    msg.extend_from_slice(&0f32.to_le_bytes());
-    msg.extend_from_slice(&0f32.to_le_bytes());
-    msg.extend_from_slice(&(-90f32).to_radians().to_le_bytes());
-    msg.extend_from_slice(&30f32.to_radians().to_le_bytes());
-    msg.extend_from_slice(&(-180f32).to_radians().to_le_bytes());
-    msg.extend_from_slice(&180f32.to_radians().to_le_bytes());
-    msg.push(GIMBAL_COMPONENT_ID);
-
-    build_v2_packet(system_id, GIMBAL_COMPONENT_ID, 280, &msg, crc_extra)
-}
-
-fn attitude_quaternion(roll_deg: f32, pitch_deg: f32, yaw_deg: f32) -> [f32; 4] {
-    let (roll, pitch, yaw) = (
-        roll_deg.to_radians(),
-        pitch_deg.to_radians(),
-        normalize_heading_deg(yaw_deg).to_radians(),
-    );
-    let (sr, cr) = (roll * 0.5).sin_cos();
-    let (sp, cp) = (pitch * 0.5).sin_cos();
-    let (sy, cy) = (yaw * 0.5).sin_cos();
-
-    [
-        cr * cp * cy + sr * sp * sy,
-        sr * cp * cy - cr * sp * sy,
-        cr * sp * cy + sr * cp * sy,
-        cr * cp * sy - sr * sp * cy,
-    ]
-}

src/uas/payload.rs

@@ -1,190 +0,0 @@
-use arma_rs::{FromArma, FromArmaError};
-
-pub struct UasTelemetryPayload {
-    pub address: String,
-    pub system_id: u8,
-    pub component_id: u8,
-    pub vehicle_type: u8,
-    pub lat_deg: f64,
-    pub lon_deg: f64,
-    pub alt_msl_m: f32,
-    pub rel_alt_m: f32,
-    pub heading_deg: f32,
-    pub groundspeed_mps: f32,
-    pub roll_deg: f32,
-    pub pitch_deg: f32,
-    pub yaw_deg: f32,
-    pub flying: bool,
-}
-
-#[allow(dead_code)]
-pub struct UasSystemPayload {
-    pub address: String,
-    pub entity_uuid: String,
-    pub callsign: String,
-    pub vehicle_type: u8,
-    pub lat_deg: f64,
-    pub lon_deg: f64,
-    pub alt_msl_m: f32,
-    pub rel_alt_m: f32,
-    pub heading_deg: f32,
-    pub groundspeed_mps: f32,
-    pub roll_deg: f32,
-    pub pitch_deg: f32,
-    pub yaw_deg: f32,
-    pub flying: bool,
-    pub landed: bool,
-    pub gimbal_roll_deg: f32,
-    pub gimbal_pitch_deg: f32,
-    pub gimbal_yaw_deg: f32,
-    pub video_uri: String,
-    pub hfov_deg: f32,
-    pub vfov_deg: f32,
-    pub image_lat_deg: f64,
-    pub image_lon_deg: f64,
-    pub image_alt_msl_m: f32,
-    pub has_turret_camera: bool,
-    pub battery_remaining_pct: i8,
-}
-
-impl FromArma for UasTelemetryPayload {
-    fn from_arma(data: String) -> Result<Self, FromArmaError> {
-        let (
-            address,
-            system_id,
-            component_id,
-            vehicle_type,
-            lat_deg,
-            lon_deg,
-            alt_msl_m,
-            rel_alt_m,
-            heading_deg,
-            groundspeed_mps,
-            roll_deg,
-            pitch_deg,
-            yaw_deg,
-            flying,
-        ) = <(
-            String,
-            i32,
-            i32,
-            i32,
-            f64,
-            f64,
-            f32,
-            f32,
-            f32,
-            f32,
-            f32,
-            f32,
-            f32,
-            i32,
-        )>::from_arma(data)?;
-
-        Ok(Self {
-            address,
-            system_id: system_id.clamp(1, 255) as u8,
-            component_id: component_id.clamp(1, 255) as u8,
-            vehicle_type: vehicle_type.clamp(0, 255) as u8,
-            lat_deg,
-            lon_deg,
-            alt_msl_m,
-            rel_alt_m,
-            heading_deg,
-            groundspeed_mps,
-            roll_deg,
-            pitch_deg,
-            yaw_deg,
-            flying: flying != 0,
-        })
-    }
-}
-
-impl FromArma for UasSystemPayload {
-    fn from_arma(data: String) -> Result<Self, FromArmaError> {
-        let (
-            address,
-            entity_uuid,
-            callsign,
-            vehicle_type,
-            lat_deg,
-            lon_deg,
-            alt_msl_m,
-            rel_alt_m,
-            heading_deg,
-            groundspeed_mps,
-            roll_deg,
-            pitch_deg,
-            yaw_deg,
-            flying,
-            landed,
-            gimbal_roll_deg,
-            gimbal_pitch_deg,
-            gimbal_yaw_deg,
-            video_uri,
-            hfov_deg,
-            vfov_deg,
-            image_lat_deg,
-            image_lon_deg,
-            image_alt_msl_m,
-            has_turret_camera,
-            battery_remaining_pct,
-        ) = <(
-            String,
-            String,
-            String,
-            i32,
-            f64,
-            f64,
-            f32,
-            f32,
-            f32,
-            f32,
-            f32,
-            f32,
-            f32,
-            i32,
-            i32,
-            f32,
-            f32,
-            f32,
-            String,
-            f32,
-            f32,
-            f64,
-            f64,
-            f32,
-            i32,
-            i32,
-        )>::from_arma(data)?;
-
-        Ok(Self {
-            address,
-            entity_uuid,
-            callsign,
-            vehicle_type: vehicle_type.clamp(0, 255) as u8,
-            lat_deg,
-            lon_deg,
-            alt_msl_m,
-            rel_alt_m,
-            heading_deg,
-            groundspeed_mps,
-            roll_deg,
-            pitch_deg,
-            yaw_deg,
-            flying: flying != 0,
-            landed: landed != 0,
-            gimbal_roll_deg,
-            gimbal_pitch_deg,
-            gimbal_yaw_deg,
-            video_uri,
-            hfov_deg,
-            vfov_deg,
-            image_lat_deg,
-            image_lon_deg,
-            image_alt_msl_m,
-            has_turret_camera: has_turret_camera != 0,
-            battery_remaining_pct: battery_remaining_pct.clamp(0, 100) as i8,
-        })
-    }
-}

src/uas/send.rs

@@ -1,403 +0,0 @@
-use arma_rs::Context;
-use log::info;
-use std::net::UdpSocket;
-
-use super::constants::{
-    AUTOPILOT_COMPONENT_ID, CAMERA_COMPONENT_ID, GIMBAL_COMPONENT_ID, MAV_TYPE_CAMERA,
-    MAV_TYPE_GIMBAL, TURRET_CAMERA_COMPONENT_ID,
-};
-use super::endpoint::socket_for_send;
-use super::identity::{
-    map_vehicle_type, should_send_video_stream_information, stable_mavlink_identity,
-    stable_system_id,
-};
-use super::packets::{
-    attitude_packet, autopilot_version_packet, camera_fov_status_packet_for_component,
-    camera_information_packet_for_component, component_heartbeat_packet, extended_sys_state_packet,
-    gimbal_manager_information_packet, global_position_int_packet, gps_raw_int_packet,
-    heartbeat_packet, home_position_packet, mount_orientation_packet_for_component,
-    mount_status_packet, system_status_packet, vfr_hud_packet,
-    video_stream_information_packet_for_component, video_stream_status_packet_for_component,
-};
-use super::payload::{UasSystemPayload, UasTelemetryPayload};
-use super::state::{latest_system, record_system};
-
-fn sending_socket(ctx: &Context, error_prefix: &str) -> Result<UdpSocket, &'static str> {
-    if let Some(socket) = socket_for_send() {
-        return Ok(socket);
-    }
-
-    match UdpSocket::bind("0.0.0.0:0") {
-        Ok(socket) => Ok(socket),
-        Err(error) => {
-            let _ = ctx.callback_data(
-                "MAVLINK MOCK ERROR",
-                "Failed to bind UDP socket",
-                error.to_string(),
-            );
-            info!("{} failed to bind UDP socket: {}", error_prefix, error);
-            Err("Failed to bind MAVLink mock socket")
-        }
-    }
-}
-
-pub fn send_uas_telemetry(ctx: Context, payload: UasTelemetryPayload) -> &'static str {
-    info!(
-        "MAVLink mock send requested to {} sysid={} compid={} lat={} lon={} alt_msl={} rel_alt={} heading={} speed={} flying={}",
-        payload.address,
-        payload.system_id,
-        payload.component_id,
-        payload.lat_deg,
-        payload.lon_deg,
-        payload.alt_msl_m,
-        payload.rel_alt_m,
-        payload.heading_deg,
-        payload.groundspeed_mps,
-        payload.flying
-    );
-
-    let socket = match sending_socket(&ctx, "MAVLink mock") {
-        Ok(socket) => socket,
-        Err(message) => return message,
-    };
-
-    let packets = [
-        heartbeat_packet(&payload),
-        gps_raw_int_packet(&payload),
-        global_position_int_packet(&payload),
-        attitude_packet(&payload),
-        vfr_hud_packet(&payload),
-    ];
-
-    for (index, packet) in packets.iter().enumerate() {
-        if let Err(error) = socket.send_to(packet, &payload.address) {
-            let _ = ctx.callback_data(
-                "MAVLINK MOCK ERROR",
-                "Failed to send MAVLink packet",
-                error.to_string(),
-            );
-            info!(
-                "MAVLink mock failed sending packet {} to {}: {}",
-                index, payload.address, error
-            );
-            return "Failed to send MAVLink mock telemetry";
-        }
-    }
-
-    info!(
-        "MAVLink mock sent {} packets to {}",
-        packets.len(),
-        payload.address
-    );
-    "Sent MAVLink mock telemetry"
-}
-
-pub fn send_uas_system(ctx: Context, payload: UasSystemPayload) -> &'static str {
-    let mavlink_identity = stable_mavlink_identity(&payload.callsign, &payload.entity_uuid);
-    let system_id = stable_system_id(&mavlink_identity);
-    let vehicle_type = map_vehicle_type(payload.vehicle_type);
-    record_system(system_id, &mavlink_identity, &payload);
-    let active_camera_component = latest_system(system_id)
-        .map(|system| system.active_camera_component)
-        .unwrap_or(CAMERA_COMPONENT_ID);
-    let (home_lat_deg, home_lon_deg, home_alt_msl_m) = latest_system(system_id)
-        .map(|system| {
-            (
-                system.home_lat_deg,
-                system.home_lon_deg,
-                system.home_alt_msl_m,
-            )
-        })
-        .unwrap_or((
-            payload.lat_deg,
-            payload.lon_deg,
-            payload.alt_msl_m - payload.rel_alt_m,
-        ));
-
-    info!(
-        "MAVLink system send requested to {} entity_uuid={} mavlink_identity={} sysid={} callsign={} lat={} lon={} alt_msl={} rel_alt={} heading={} gimbal_pitch={} gimbal_yaw={} video_uri={}",
-        payload.address,
-        payload.entity_uuid,
-        mavlink_identity,
-        system_id,
-        payload.callsign,
-        payload.lat_deg,
-        payload.lon_deg,
-        payload.alt_msl_m,
-        payload.rel_alt_m,
-        payload.heading_deg,
-        payload.gimbal_pitch_deg,
-        payload.gimbal_yaw_deg,
-        payload.video_uri
-    );
-
-    let socket = match sending_socket(&ctx, "MAVLink system") {
-        Ok(socket) => socket,
-        Err(message) => return message,
-    };
-    let (fpv_image_lat, fpv_image_lon, fpv_image_alt) = fpv_image_point(
-        payload.lat_deg,
-        payload.lon_deg,
-        payload.alt_msl_m,
-        payload.rel_alt_m,
-        payload.pitch_deg,
-        payload.yaw_deg,
-    );
-    let active_is_turret =
-        payload.has_turret_camera && active_camera_component == TURRET_CAMERA_COMPONENT_ID;
-    info!(
-        "MAVLink active camera sysid={} active_component={} has_turret={} active_is_turret={}",
-        system_id, active_camera_component, payload.has_turret_camera, active_is_turret
-    );
-    let (
-        primary_pitch,
-        primary_roll,
-        primary_yaw,
-        primary_image_lat,
-        primary_image_lon,
-        primary_image_alt,
-    ) = if active_is_turret {
-        (
-            payload.gimbal_pitch_deg,
-            payload.gimbal_roll_deg,
-            payload.gimbal_yaw_deg,
-            payload.image_lat_deg,
-            payload.image_lon_deg,
-            payload.image_alt_msl_m,
-        )
-    } else {
-        (
-            payload.pitch_deg,
-            payload.roll_deg,
-            payload.yaw_deg,
-            fpv_image_lat,
-            fpv_image_lon,
-            fpv_image_alt,
-        )
-    };
-
-    let autopilot_payload = UasTelemetryPayload {
-        address: payload.address.clone(),
-        system_id,
-        component_id: AUTOPILOT_COMPONENT_ID,
-        vehicle_type,
-        lat_deg: payload.lat_deg,
-        lon_deg: payload.lon_deg,
-        alt_msl_m: payload.alt_msl_m,
-        rel_alt_m: payload.rel_alt_m,
-        heading_deg: payload.heading_deg,
-        groundspeed_mps: payload.groundspeed_mps,
-        roll_deg: payload.roll_deg,
-        pitch_deg: payload.pitch_deg,
-        yaw_deg: payload.yaw_deg,
-        flying: payload.flying,
-    };
-
-    let mut packets = vec![
-        heartbeat_packet(&autopilot_payload),
-        gps_raw_int_packet(&autopilot_payload),
-        global_position_int_packet(&autopilot_payload),
-        attitude_packet(&autopilot_payload),
-        vfr_hud_packet(&autopilot_payload),
-        system_status_packet(system_id, payload.battery_remaining_pct),
-        extended_sys_state_packet(system_id, payload.landed),
-        autopilot_version_packet(system_id, &mavlink_identity),
-        home_position_packet(
-            system_id,
-            home_lat_deg,
-            home_lon_deg,
-            home_alt_msl_m,
-            payload.heading_deg,
-        ),
-        component_heartbeat_packet(system_id, CAMERA_COMPONENT_ID, MAV_TYPE_CAMERA),
-        component_heartbeat_packet(system_id, GIMBAL_COMPONENT_ID, MAV_TYPE_GIMBAL),
-        camera_information_packet_for_component(
-            system_id,
-            CAMERA_COMPONENT_ID,
-            &format!("{} FPV", payload.callsign),
-            0,
-        ),
-        mount_orientation_packet_for_component(
-            system_id,
-            CAMERA_COMPONENT_ID,
-            primary_pitch,
-            primary_yaw,
-        ),
-        camera_fov_status_packet_for_component(
-            system_id,
-            CAMERA_COMPONENT_ID,
-            payload.lat_deg,
-            payload.lon_deg,
-            payload.alt_msl_m,
-            primary_image_lat,
-            primary_image_lon,
-            primary_image_alt,
-            primary_roll,
-            primary_pitch,
-            primary_yaw,
-            payload.hfov_deg,
-            payload.vfov_deg,
-        ),
-        gimbal_manager_information_packet(system_id),
-    ];
-
-    if payload.has_turret_camera {
-        packets.push(component_heartbeat_packet(
-            system_id,
-            TURRET_CAMERA_COMPONENT_ID,
-            MAV_TYPE_CAMERA,
-        ));
-        packets.push(camera_information_packet_for_component(
-            system_id,
-            TURRET_CAMERA_COMPONENT_ID,
-            &format!("{} Turret", payload.callsign),
-            GIMBAL_COMPONENT_ID,
-        ));
-        packets.push(mount_orientation_packet_for_component(
-            system_id,
-            TURRET_CAMERA_COMPONENT_ID,
-            payload.gimbal_pitch_deg,
-            payload.gimbal_yaw_deg,
-        ));
-        packets.push(camera_fov_status_packet_for_component(
-            system_id,
-            TURRET_CAMERA_COMPONENT_ID,
-            payload.lat_deg,
-            payload.lon_deg,
-            payload.alt_msl_m,
-            payload.image_lat_deg,
-            payload.image_lon_deg,
-            payload.image_alt_msl_m,
-            payload.gimbal_roll_deg,
-            payload.gimbal_pitch_deg,
-            payload.gimbal_yaw_deg,
-            payload.hfov_deg,
-            payload.vfov_deg,
-        ));
-    }
-
-    let (active_pitch, active_roll, active_relative_yaw) = if active_is_turret {
-        (
-            payload.gimbal_pitch_deg,
-            payload.gimbal_roll_deg,
-            normalize_signed_deg(payload.gimbal_yaw_deg - payload.yaw_deg),
-        )
-    } else {
-        (payload.pitch_deg, payload.roll_deg, 0.0)
-    };
-    packets.push(mount_status_packet(
-        system_id,
-        active_pitch,
-        active_roll,
-        active_relative_yaw,
-    ));
-
-    if should_send_video_stream_information(&payload.video_uri) {
-        info!(
-            "Sending VIDEO_STREAM_INFORMATION for sysid={} uri={}",
-            system_id, payload.video_uri
-        );
-        packets.push(video_stream_information_packet_for_component(
-            system_id,
-            CAMERA_COMPONENT_ID,
-            &format!("{} FPV", payload.callsign),
-            &payload.video_uri,
-            payload.hfov_deg,
-            1,
-            1,
-            false,
-        ));
-        packets.push(video_stream_status_packet_for_component(
-            system_id,
-            CAMERA_COMPONENT_ID,
-            payload.hfov_deg,
-            1,
-            false,
-        ));
-
-        if payload.has_turret_camera {
-            packets.push(video_stream_information_packet_for_component(
-                system_id,
-                TURRET_CAMERA_COMPONENT_ID,
-                &format!("{} Turret", payload.callsign),
-                &payload.video_uri,
-                payload.hfov_deg,
-                1,
-                1,
-                false,
-            ));
-            packets.push(video_stream_status_packet_for_component(
-                system_id,
-                TURRET_CAMERA_COMPONENT_ID,
-                payload.hfov_deg,
-                1,
-                false,
-            ));
-        }
-    } else if !payload.video_uri.trim().is_empty() {
-        info!(
-            "Skipping VIDEO_STREAM_INFORMATION for sysid={} because URI is not a supported stream URI: {}",
-            system_id, payload.video_uri
-        );
-    }
-
-    for (index, packet) in packets.iter().enumerate() {
-        if let Err(error) = socket.send_to(packet, &payload.address) {
-            let _ = ctx.callback_data(
-                "MAVLINK MOCK ERROR",
-                "Failed to send MAVLink packet",
-                error.to_string(),
-            );
-            info!(
-                "MAVLink system failed sending packet {} to {}: {}",
-                index, payload.address, error
-            );
-            return "Failed to send MAVLink system telemetry";
-        }
-    }
-
-    info!(
-        "MAVLink system sent {} packets to {} for sysid={} (camera comp={}, gimbal comp={})",
-        packets.len(),
-        payload.address,
-        system_id,
-        CAMERA_COMPONENT_ID,
-        GIMBAL_COMPONENT_ID
-    );
-    "Sent MAVLink system telemetry"
-}
-
-fn normalize_signed_deg(value: f32) -> f32 {
-    let normalized = ((value % 360.0) + 360.0) % 360.0;
-    if normalized > 180.0 {
-        normalized - 360.0
-    } else {
-        normalized
-    }
-}
-
-fn fpv_image_point(
-    lat_deg: f64,
-    lon_deg: f64,
-    alt_msl_m: f32,
-    rel_alt_m: f32,
-    pitch_deg: f32,
-    yaw_deg: f32,
-) -> (f64, f64, f32) {
-    let pitch_rad = pitch_deg.to_radians();
-    let vertical = (-pitch_rad.sin()).max(0.01);
-    let slant_m = (rel_alt_m.max(1.0) / vertical).clamp(1.0, 15_000.0);
-    let ground_m = slant_m * pitch_rad.cos().abs();
-    let yaw_rad = yaw_deg.to_radians();
-    let north_m = ground_m * yaw_rad.cos();
-    let east_m = ground_m * yaw_rad.sin();
-    let lat_rad = lat_deg.to_radians();
-    let meters_per_degree_lat = 111_320.0;
-    let meters_per_degree_lon = (111_320.0 * lat_rad.cos().abs()).max(1.0);
-
-    (
-        lat_deg + north_m as f64 / meters_per_degree_lat,
-        lon_deg + east_m as f64 / meters_per_degree_lon,
-        alt_msl_m - rel_alt_m,
-    )
-}

src/uas/state.rs

@@ -1,112 +0,0 @@
-use std::collections::HashMap;
-use std::sync::Mutex;
-
-use lazy_static::lazy_static;
-
-use super::payload::UasSystemPayload;
-
-#[derive(Clone)]
-pub(crate) struct LatestUasSystem {
-    pub mavlink_identity: String,
-    pub callsign: String,
-    pub lat_deg: f64,
-    pub lon_deg: f64,
-    pub alt_msl_m: f32,
-    pub rel_alt_m: f32,
-    pub heading_deg: f32,
-    pub fpv_pitch_deg: f32,
-    pub fpv_yaw_deg: f32,
-    pub gimbal_pitch_deg: f32,
-    pub gimbal_yaw_deg: f32,
-    pub video_uri: String,
-    pub hfov_deg: f32,
-    pub vfov_deg: f32,
-    pub image_lat_deg: f64,
-    pub image_lon_deg: f64,
-    pub image_alt_msl_m: f32,
-    pub has_turret_camera: bool,
-    pub active_camera_component: u8,
-    pub home_lat_deg: f64,
-    pub home_lon_deg: f64,
-    pub home_alt_msl_m: f32,
-}
-
-lazy_static! {
-    static ref LATEST_UAS_SYSTEMS: Mutex<HashMap<u8, LatestUasSystem>> = Mutex::new(HashMap::new());
-}
-
-pub(crate) fn record_system(system_id: u8, mavlink_identity: &str, payload: &UasSystemPayload) {
-    if let Ok(mut systems) = LATEST_UAS_SYSTEMS.lock() {
-        let active_camera_component = systems
-            .get(&system_id)
-            .map(|system| system.active_camera_component)
-            .unwrap_or(super::constants::CAMERA_COMPONENT_ID);
-        let home = systems
-            .get(&system_id)
-            .map(|system| {
-                (
-                    system.home_lat_deg,
-                    system.home_lon_deg,
-                    system.home_alt_msl_m,
-                )
-            })
-            .unwrap_or((
-                payload.lat_deg,
-                payload.lon_deg,
-                payload.alt_msl_m - payload.rel_alt_m,
-            ));
-
-        systems.insert(
-            system_id,
-            LatestUasSystem {
-                mavlink_identity: mavlink_identity.to_string(),
-                callsign: payload.callsign.clone(),
-                lat_deg: payload.lat_deg,
-                lon_deg: payload.lon_deg,
-                alt_msl_m: payload.alt_msl_m,
-                rel_alt_m: payload.rel_alt_m,
-                heading_deg: payload.heading_deg,
-                fpv_pitch_deg: payload.pitch_deg,
-                fpv_yaw_deg: payload.yaw_deg,
-                gimbal_pitch_deg: payload.gimbal_pitch_deg,
-                gimbal_yaw_deg: payload.gimbal_yaw_deg,
-                video_uri: payload.video_uri.clone(),
-                hfov_deg: payload.hfov_deg,
-                vfov_deg: payload.vfov_deg,
-                image_lat_deg: payload.image_lat_deg,
-                image_lon_deg: payload.image_lon_deg,
-                image_alt_msl_m: payload.image_alt_msl_m,
-                has_turret_camera: payload.has_turret_camera,
-                active_camera_component,
-                home_lat_deg: home.0,
-                home_lon_deg: home.1,
-                home_alt_msl_m: home.2,
-            },
-        );
-    }
-}
-
-pub(crate) fn set_home(system_id: u8, lat_deg: f64, lon_deg: f64, alt_msl_m: f32) {
-    if let Ok(mut systems) = LATEST_UAS_SYSTEMS.lock() {
-        if let Some(system) = systems.get_mut(&system_id) {
-            system.home_lat_deg = lat_deg;
-            system.home_lon_deg = lon_deg;
-            system.home_alt_msl_m = alt_msl_m;
-        }
-    }
-}
-
-pub(crate) fn latest_system(system_id: u8) -> Option<LatestUasSystem> {
-    LATEST_UAS_SYSTEMS
-        .lock()
-        .ok()
-        .and_then(|systems| systems.get(&system_id).cloned())
-}
-
-pub(crate) fn set_active_camera(system_id: u8, component_id: u8) {
-    if let Ok(mut systems) = LATEST_UAS_SYSTEMS.lock() {
-        if let Some(system) = systems.get_mut(&system_id) {
-            system.active_camera_component = component_id;
-        }
-    }
-}

src/udp_socket.rs

@@ -15,14 +15,15 @@ pub enum UdpCommand {
 
 pub struct UdpClient {
     pub(crate) tx: Sender<UdpCommand>,
-    pub(crate) address: String,
 }
 
 impl UdpClient {
     pub fn start(&self, address: String, rx: Receiver<UdpCommand>, ctx: Context) {
-        thread::spawn(move || {
+        if let Some(ref client) = *UDP_CLIENT.lock().unwrap() {
-            info!("Starting UDP client thread for destination {}", address);
+            client.stop();
+        }
 
+        thread::spawn(move || {
             let socket = match UdpSocket::bind("0.0.0.0:0") {
                 Ok(s) => s,
                 Err(e) => {
@@ -31,28 +32,19 @@ impl UdpClient {
                         "Failed to bind UDP socket",
                         e.to_string(),
                     );
-                    info!("Failed to bind UDP socket for {}: {}", address, e);
+                    info!("Failed to bind UDP socket: {}", e);
                     return;
                 }
             };
 
-            if let Ok(local_addr) = socket.local_addr() {
-                info!(
-                    "UDP client bound local socket {} for destination {}",
-                    local_addr, address
-                );
-            }
-
             let _ = ctx.callback_data("UDP SOCKET", "EUD Connected", address.clone());
-            info!("UDP client reported EUD Connected for {}", address);
 
             let mut running = true;
             while running {
                 match rx.recv() {
                     Ok(UdpCommand::SendMessage(message, context)) => {
-                        info!("UDP client sending {} bytes to {}", message.len(), address);
                         if let Err(e) = socket.send_to(message.as_bytes(), &address) {
-                            info!("Failed to send UDP message to {}: {}", address, e);
+                            info!("Failed to send UDP message: {}", e);
                             let _ = context.callback_data(
                                 "UDP SOCKET ERROR",
                                 "Failed to send UDP message",
@@ -62,15 +54,13 @@ impl UdpClient {
                     }
                     Ok(UdpCommand::Stop) => {
                         running = false;
-                        info!("Stopping UDP client for {}", address);
+                        info!("Stopping UDP client.");
                     }
                     Err(error) => {
-                        info!("Error receiving UDP command for {}: {}", address, error);
+                        info!("Error receiving command: {}", error.to_string());
                     }
                 }
             }
-
-            info!("UDP client thread exited for {}", address);
         });
     }
 
@@ -83,9 +73,7 @@ impl UdpClient {
 
     pub fn stop(&self) {
         let tx = self.tx.clone();
-        let address = self.address.clone();
         thread::spawn(move || {
-            info!("Queueing stop for UDP client {}", address);
             tx.send(UdpCommand::Stop).unwrap();
         });
     }
@@ -96,32 +84,14 @@ lazy_static! {
 }
 
 pub fn start(ctx: Context, address: String) -> &'static str {
-    info!("UDP socket start requested for {}", address);
-
     let (tx, rx): (Sender<UdpCommand>, Receiver<UdpCommand>) = mpsc::channel();
 
-    let client = UdpClient {
+    let client = UdpClient { tx };
-        tx,
-        address: address.clone(),
-    };
-
-    {
-        let mut client_guard = UDP_CLIENT.lock().unwrap();
-        if let Some(ref existing_client) = *client_guard {
-            info!(
-                "Stopping previous UDP client {} before starting {}",
-                existing_client.address, address
-            );
-            existing_client.stop();
-        }
-        *client_guard = Some(UdpClient {
-            tx: client.tx.clone(),
-            address: client.address.clone(),
-        });
-    }
-
     client.start(address, rx, ctx);
 
+    let mut client_guard = UDP_CLIENT.lock().unwrap();
+    *client_guard = Some(client);
+
     "Starting UDP Client"
 }
 
@@ -130,7 +100,6 @@ pub fn send_payload(ctx: Context, payload: String) -> &'static str {
         client.send_payload(ctx, payload);
     } else {
         let _ = ctx.callback_null("UDP SOCKET ERROR", "UDP Socket is not running");
-        info!("UDP send requested while socket was not running");
     }
 
     "Sending payload to UDP server"
@@ -148,12 +117,10 @@ pub fn send_gps_cot(
 
 pub fn stop(ctx: Context) -> &'static str {
     if let Some(ref client) = *UDP_CLIENT.lock().unwrap() {
-        info!("UDP socket stop requested for {}", client.address);
         client.stop();
         let _ = ctx.callback_null("UDP SOCKET", "EUD Disconnected");
     } else {
         let _ = ctx.callback_null("UDP SOCKET ERROR", "UDP Socket is not running");
-        info!("UDP stop requested while socket was not running");
     }
 
     "Stopping UDP Client"

src/video_stream.rs

@@ -1,6 +1,5 @@
 use arma_rs::Context;
 use lazy_static::lazy_static;
-use log::info;
 use std::process::Command;
 use std::sync::mpsc::{self, Receiver, Sender};
 use std::sync::Mutex;
@@ -17,34 +16,53 @@ lazy_static! {
 #[cfg(target_os = "windows")]
 const CREATE_NO_WINDOW: u32 = 0x08000000;
 
-fn stop_existing_stream() {
+fn build_rtsp_url(
-    if let Ok(mut lock) = STREAM_CTRL.lock() {
+    address: &str,
-        if let Some(tx) = lock.take() {
+    port: &str,
-            let _ = tx.send(());
+    stream_path: &str,
-        }
+    username: &str,
+    password: &str,
+) -> String {
+    if username.is_empty() || password.is_empty() {
+        format!("rtsp://{}:{}/{}", address, port, stream_path)
+    } else {
+        format!(
+            "rtsp://{}:{}@{}:{}/{}",
+            username, password, address, port, stream_path
+        )
     }
 }
 
-fn spawn_ffmpeg_with_args(
+#[cfg(any(target_os = "windows", target_os = "linux"))]
-    mut cmd: Command,
+fn spawn_ffmpeg(rtsp_url: String, stop_rx: Receiver<()>, status_tx: Sender<Result<(), String>>) {
-    stop_rx: Receiver<()>,
-    status_tx: Sender<Result<(), String>>,
-    description: String,
-) {
     thread::spawn(move || {
-        info!("Starting FFmpeg video stream: {}", description);
+        let mut cmd = Command::new("ffmpeg");
+        cmd.args(&[
+            "-f",
+            "x11grab",
+            "-framerate",
+            "30",
+            "-video_size",
+            "1920x1080",
+            "-i",
+            ":0",
+            "-f",
+            "rtsp",
+            "-rtsp_transport",
+            "tcp",
+            &rtsp_url,
+        ]);
 
         #[cfg(target_os = "windows")]
         let child_result = cmd.creation_flags(CREATE_NO_WINDOW).spawn();
 
-        #[cfg(not(target_os = "windows"))]
+        #[cfg(target_os = "linux")]
         let child_result = cmd.spawn();
 
         match child_result {
             Ok(mut child) => {
                 let _ = status_tx.send(Ok(()));
                 let _ = stop_rx.recv();
-                info!("Stopping FFmpeg video stream: {}", description);
                 let _ = child.kill();
             }
             Err(e) => {
@@ -62,77 +80,30 @@ pub fn start_stream(
     username: String,
     password: String,
 ) -> &'static str {
-    stop_existing_stream();
+    #[cfg(any(target_os = "windows", target_os = "linux"))]
-
+    {
         let (stop_tx, stop_rx) = mpsc::channel();
         let (status_tx, status_rx) = mpsc::channel();
 
-    let rtsp_url = if username.is_empty() || password.is_empty() {
+        let rtsp_url = build_rtsp_url(&address, &port, &stream_path, &username, &password);
-        format!("rtsp://{}:{}/{}", address, port, stream_path)
-    } else {
-        format!("rtsp://{}:{}@{}:{}/{}", username, password, address, port, stream_path)
-    };
 
-    let mut cmd = Command::new("ffmpeg");
+        spawn_ffmpeg(rtsp_url, stop_rx, status_tx);
-    #[cfg(target_os = "windows")]
-    cmd.args([
-        "-f",
-        "gdigrab",
-        "-framerate",
-        "15",
-        "-i",
-        "desktop",
-        "-an",
-        "-c:v",
-        "libx264",
-        "-preset",
-        "ultrafast",
-        "-tune",
-        "zerolatency",
-        "-pix_fmt",
-        "yuv420p",
-        "-f",
-        "rtsp",
-        "-rtsp_transport",
-        "tcp",
-        &rtsp_url,
-    ]);
 
-    #[cfg(target_os = "linux")]
+        match STREAM_CTRL.lock() {
-    cmd.args([
+            Ok(mut lock) => *lock = Some(stop_tx),
-        "-f",
+            Err(e) => {
-        "x11grab",
+                let _ = ctx.callback_data(
-        "-framerate",
+                    "VIDEO ERROR",
-        "15",
+                    "Failed to acquire lock for stream control",
-        "-video_size",
+                    e.to_string(),
-        "1280x720",
+                );
-        "-i",
+                return "stream control lock error";
-        ":0.0",
+            }
-        "-an",
-        "-c:v",
-        "libx264",
-        "-preset",
-        "ultrafast",
-        "-tune",
-        "zerolatency",
-        "-pix_fmt",
-        "yuv420p",
-        "-f",
-        "rtsp",
-        "-rtsp_transport",
-        "tcp",
-        &rtsp_url,
-    ]);
-
-    spawn_ffmpeg_with_args(cmd, stop_rx, status_tx, format!("RTSP {}", rtsp_url));
-
-    if let Ok(mut lock) = STREAM_CTRL.lock() {
-        *lock = Some(stop_tx);
         }
 
         match status_rx.recv_timeout(Duration::from_secs(2)) {
             Ok(Ok(())) => {
-            let _ = ctx.callback_null("VIDEO", "FFmpeg RTSP stream started successfully");
+                let _ = ctx.callback_null("VIDEO", "FFmpeg started successfully");
                 "starting video stream"
             }
             Ok(Err(e)) => {
@@ -146,85 +117,10 @@ pub fn start_stream(
         }
     }
 
-pub fn start_rtp_stream(ctx: Context, address: String, port: String) -> &'static str {
+    #[cfg(not(any(target_os = "windows", target_os = "linux")))]
-    stop_existing_stream();
+    {
-
+        ctx.callback_null("VIDEO ERROR", "Screen capture is only supported on Windows");
-    let (stop_tx, stop_rx) = mpsc::channel();
+        "unsupported platform"
-    let (status_tx, status_rx) = mpsc::channel();
-    let rtp_url = format!("rtp://{}:{}", address, port);
-
-    let mut cmd = Command::new("ffmpeg");
-
-    #[cfg(target_os = "windows")]
-    cmd.args([
-        "-f",
-        "gdigrab",
-        "-framerate",
-        "15",
-        "-i",
-        "desktop",
-        "-an",
-        "-c:v",
-        "libx264",
-        "-preset",
-        "ultrafast",
-        "-tune",
-        "zerolatency",
-        "-pix_fmt",
-        "yuv420p",
-        "-g",
-        "30",
-        "-f",
-        "rtp",
-        &rtp_url,
-    ]);
-
-    #[cfg(target_os = "linux")]
-    cmd.args([
-        "-f",
-        "x11grab",
-        "-framerate",
-        "15",
-        "-video_size",
-        "1280x720",
-        "-i",
-        ":0.0",
-        "-an",
-        "-c:v",
-        "libx264",
-        "-preset",
-        "ultrafast",
-        "-tune",
-        "zerolatency",
-        "-pix_fmt",
-        "yuv420p",
-        "-g",
-        "30",
-        "-f",
-        "rtp",
-        &rtp_url,
-    ]);
-
-    spawn_ffmpeg_with_args(cmd, stop_rx, status_tx, format!("RTP {}", rtp_url));
-
-    if let Ok(mut lock) = STREAM_CTRL.lock() {
-        *lock = Some(stop_tx);
-    }
-
-    match status_rx.recv_timeout(Duration::from_secs(2)) {
-        Ok(Ok(())) => {
-            info!("Started RTP video stream toward {}", rtp_url);
-            let _ = ctx.callback_null("VIDEO", "FFmpeg RTP stream started successfully");
-            "starting RTP video stream"
-        }
-        Ok(Err(e)) => {
-            let _ = ctx.callback_data("VIDEO ERROR", "FFmpeg failed to start RTP stream", e);
-            "ffmpeg failed to start RTP stream"
-        }
-        Err(_) => {
-            let _ = ctx.callback_null("VIDEO ERROR", "FFmpeg RTP stream did not respond in time");
-            "ffmpeg RTP stream did not respond"
-        }
     }
 }