Introduction to WinTAK: Windows Tactical Awareness Kit

WinTAK, the Windows Tactical Awareness Kit, is a powerful situational awareness tool designed for Windows operating systems. As a counterpart to the popular ATAK (Android Tactical Awareness Kit), WinTAK provides a robust platform for developing custom plugins and applications to enhance tactical operations and drone management.

At the monthly Drone Software Meetup Group, Godfrey Nolan, President at RIIS, showed the attendees how to get started with WinTAK. This article explores the fundamentals of WinTAK, its architecture, and the basics of how to develop on it with a specific focus on drone integration. As usual, you can follow along with the video or read the written version of the tutorial below.

What is WinTAK?

WinTAK is essentially ATAK for Windows. Many users prefer or require the Windows operating system, making WinTAK a natural alternative to the Android-based ATAK. While the iOS version of ATAK exists, in our personal experience, its plugin capabilities are more limited, possibly due to iOS security restrictions, which can be a significant drawback for developers.

One of the major advantages of WinTAK is its ability to run on more powerful systems than ATAK. Windows computers can be equipped with advanced graphics cards and substantial RAM, providing performance advantages over even high-end Android devices. This makes WinTAK particularly suitable for resource-intensive applications.

Something to note about WinTAK plugins is that they are not directly compatible with ATAK, which can feel a bit confusing. They are different ecosystems, and although more powerful, WinTAK has fewer plugins out in the wild.

For this article, we’ll be working with WinTAK-CIV, the civilian version available to the general public through TAK.gov, similar to the civilian version of ATAK.

WinTAK Architecture and Technology Stack

WinTAK is built using .NET and C# technologies. Specifically, it runs on the .NET Framework 4.8.1, which may seem somewhat dated in the fast-moving world of software development, but it provides a stable platform for the application. Development for WinTAK is typically done using Visual Studio 2022, with the Community Edition being sufficient for most development needs.

The architecture of WinTAK includes:

• Modular Plugin Architecture: WinTAK uses the Managed Extensibility Framework (MEF) for dependency injection, enabling dynamic plugin loading. This allows developers to create and load plugins that can be added to or removed from WinTAK without modifying the core application.

• NuGet Integration: WinTAK leverages NuGet packages, including Prism. More specifically, it utilizes Prism Dynamic, and Prism.Core, which helps structure the user interface with the map on the left and contextual information panels on the right.

• UI Components with WPF: The user interface is built using WPF (Windows Presentation Foundation) which is similar to XAML files.

• Messaging and Geospatial Features: WinTAK provides similar messaging and geospatial capabilities to ATAK, enabling effective tactical coordination and awareness.

Getting Started with WinTAK Development

Installation Requirements

1. Begin by downloading WinTAK-Civ from TAK.gov. After creating an account navigate to the product page for WinTAK-CIV and scroll down to the developer resources section.

2. Download the latest version of the WinTAK SDK (currently 5.3) and the WinTAK Templates (.vsix file).

   

3. Install the WinTAK via the installer executable.

   

4. Double-click the VSIX file to install the WinTAK templates for Visual Studio.

   

5. When creating a new project in Visual Studio, search for “WinTAK templates” to find the plugin template.

Note that the ecosystem for WinTAK plugins is still developing, with relatively few plugins available compared to ATAK. However, resources like the WinTAK “Hello World” plugin repository by Hellikandra provide excellent examples for developers looking to create WinTAK plugins.

Okay, now that we have the basics installed, we are now ready to start making our first plugin.

Creating Your First WinTAK Plugin

Let’s walk through creating a simple “Hello World” plugin for WinTAK to ensure your development environment is properly set up and to understand the basic structure of a WinTAK plugin.

The Hello World Plugin

The goal of our first plugin is modest: we want to create a simple panel in the plugins tab that displays “Hello World” when clicked. This will verify that all components of our development environment are working correctly.

Here are the steps to create the Hello World plugin:

1. Create a new project using the WinTAK template in Visual Studio 2022.

2. Set up local NuGet dependencies. This is a crucial step, as your project will initially fail to find the Prism and TAK packages. To fix this:

   • Go to Tools > NuGet Package Manager > Package Manager Settings

   • Under Package Sources, click the “+” button to add a new source

   • Browse to your WinTAK installation folder (typically Program Files) and select the NuGet subfolder

   • Name the source “WinTAK NuGet” and save the changes

3. Ensure you’re using .NET Framework 4.8.1. The plugin won’t work with other versions.

4. Change the startup action to use plugins. Since we’re developing a plugin and not a standalone application, we need to:

   • Right-click on your project in Solution Explorer and select Properties

   • Go to the Debug tab

   • Change “Start Action” to “Start external program”

   • Browse to and select the WinTAK.exe in your installation directory

   • Use the same directory as your working directory

Project Setup

1. Open Visual Studio 2022 and select “Create a new project.”

   

2. Search for “WinTAK” in the project templates. If you don’t see it listed, make sure you’ve installed the WinTAK Templates (.vsix file).

3. Select the “WinTAK Plugin” template and provide a name for your project.

Configuring NuGet Dependencies

When you first run the project, you may encounter errors related to missing Prism or TAK packages. This is because the project is looking for these packages on NuGet.org, but we need to point it to our local installation:

1. Go to Tools > NuGet Package Manager > Package Manager Settings.

   

2. Navigate to Package Sources and click the “+” button.

3. Set the name to “WinTAK” and browse to the location of your WinTAK installation (typically in Program Files).

   

4. Select the “nuget” folder and click “OK.”

5. Make sure the new package source is enabled by checking the box next to it.

6. If errors persist, try cleaning and rebuilding the solution.

Setting the Framework Version

Ensure your project is using the correct .NET Framework version:

1. Right-click on your project in Solution Explorer and select “Properties.”

2. In the Application tab, set the Target Framework to “.NET Framework 4.8.1.”

   

While this plugin doesn’t do much, it confirms that your development environment is correctly set up and that you can create and deploy WinTAK plugins.

Configuring the Startup Action

WinTAK plugins are not standalone applications, so we need to configure Visual Studio to launch WinTAK when we debug our plugin:

1. In the project properties, navigate to the Debug tab.

   

2. Select “Start external program” and browse to the WinTAK executable (usually in Program Files).

3. Set the working directory to the same location.

4. Save these settings.

Building and Testing the Plugin

Now we’re ready to build and test our Hello World plugin:

1. Build the solution (F6 or Ctrl+Shift+B).

2. Start debugging (F5). This will launch WinTAK.

3. In WinTAK, you should see a notification that a new plugin has been discovered.

   

4. Enable the plugin by checking the checkbox next to it.

5. Click on the “Plugins” tab in the ribbon at the top of the WinTAK interface.

6. You should see your Hello World plugin listed. Clicking on it will display a simple panel on the right side of the interface.

If everything went according to plan, this is what you should see:

This basic plugin doesn’t do much, but it confirms that our development environment is properly set up and that we can create and load plugins into WinTAK.

Developing a Drone Plugin for WinTAK

Now that we’ve verified our setup with a simple Hello World plugin, let’s move on to something more practical: a drone plugin that displays the latitude and longitude of a drone in real-time.

Setting Up the Drone Plugin

Our drone plugin will display the longitude and latitude of a drone in a panel, read the drone’s position from a simulator running in the background, and use MAVLink to communicate with the drone simulator

Here’s the setup process:

1. Set up a drone simulator environment:

   • We’ll use Windows Subsystem for Linux (WSL) to run PX4 and Gazebo

   • QGroundControl (QGC) will serve as a bridge between the simulator and our plugin

2. Install WSL if you don’t already have it:

   wsl --install

3. Set up PX4 and Gazebo within WSL:

   sudo apt update
   sudo apt upgrade
   git clone <https://github.com/PX4/PX4-Autopilot> --recursive
   cd PX4-Autopilot
   bash
   
   

4. Get the IP address of your WSL instance:

   You’ll need this to configure QGroundControl.

5. Install and configure QGroundControl:

   • In QGC, go to Application Settings > Comm Links

   • Add a new connection to the simulator with the WSL IP address and port 18570

     

   • Under Application Settings > MAVLink, enable MAVLink forwarding on localhost:14445

     

Creating the Drone Plugin in Visual Studio

With our simulator environment set up, we can now create the drone plugin. Clone the project repository and inspect the files. Here are the important ones to take note of.

First is our View.xaml file to add a simple grid to display the latitude and longitude:

<Grid>
	<StackPanel>
    <TextBlock>
	    <Run Text="{Binding Lat}"/>
	    <Run Text=","/>
	    <Run Text="{Binding Lon}"/>
    </TextBlock>
  </StackPanel>
</Grid>

The next big thing is the DockPane.cs file to handle the communication with the simulator. All the fun happens here for the most part.

using System;
using System.ComponentModel.Composition;
using System.Diagnostics;
using System.IO;
using System.Net.Sockets;
using System.Net;
using lat_lon_wintak_plugin_example.Views;
using WinTak.Framework.Docking;
using WinTak.Framework.Docking.Attributes;
using System.Threading.Tasks;

namespace lat_lon_wintak_plugin_example.DockPanes
{
    [DockPane(Id, "lat_lon_wintak_plugin_example", Content = typeof(lat_lon_wintak_plugin_exampleView))]
    internal class lat_lon_wintak_plugin_exampleDockPane : DockPane
    {
        internal const string Id = "lat_lon_wintak_plugin_example_DockPanes_lat_lon_wintak_plugin_exampleDockPane";

        private double _lon;
        private double _lat;

        [ImportingConstructor]
        public lat_lon_wintak_plugin_exampleDockPane()
        {
            // Run this in a new thread so we don't block UI stuff
            Task.Run(() =>
            {
                // When MAVLink forwarding is enabled in QGC this is the default port it forwards to.
                // 14550 is usually used otherwise.
                int port = 14445;
                var udpClient = new UdpClient(port);
                var endPoint = new IPEndPoint(IPAddress.Loopback, port);

                var mavlinkParser = new MAVLink.MavlinkParse();

                Debug.Print("Listening for MAVLink packets on UDP: " + endPoint);
                while (true)
                {
                    if (udpClient.Available == 0)
                    {
                        continue;
                    }
                    try
                    {
                        // Receive UDP packet
                        byte[] data = udpClient.Receive(ref endPoint);

                        // Wrap byte array in a MemoryStream for mavlinkParser 
                        using (MemoryStream stream = new MemoryStream(data))
                        {
                            // Parse MAVLink message
                            var packet = mavlinkParser.ReadPacket(stream);

                            if (packet != null)
                            {
                                if (packet.msgid == 24) // Indicates this is a GPS_RAW_INT type MAVLink message
                                                        // See MAVLink.message_info (mavlink.cs) for definitions of other message types
                                {
                                    var gps_data = packet.ToStructure<MAVLink.mavlink_gps_raw_int_t>();

                                    //Debug.Print("long: " + gps_data.lon + "\\t lat: " + gps_data.lat);
                                    Lon = gps_data.lon;
                                    Lat = gps_data.lat;
                                }
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine("Error: " + ex.Message);
                    }
                }
            });
        }
        
        public double Lon
        {
            get { return _lon; }
            set { SetProperty(ref _lon, value); }
        }

        public double Lat
        {
            get { return _lat; }
            set { SetProperty(ref _lat, value

We are storing our latitude and longitude variables in private double _lon; and private double _lat;. When the pane is created it starts a udpClient on a new thread. Notice that we are running that client on port 14445, which we pointed to when we set up our MAVLink forwarding.

Within the while loop, if the client is available, we will receive the packets, parse the packets, and identify the GPS data. You can see that MAVLink is handling the heavy lifting on that for us here var gps_data = packet.ToStructure<MAVLink.mavlink_gps_raw_int_t>();. Then it will extract gps_data.lat and gps_data.lon and assign them to our variables from before.

Next, we have to generate our MAVLink communication files and import them into our project. We’ve included a video because these steps can be a little complicated.

First, you’re going to want to clone the repo:

git

Then, we are going to install our Python dependencies:

pip install -r

Then we are going to run mavgenerate .

python -m

That will give us this popup:

Browse the folders to decide which protocols we are going to use. The Output location should be the project directory. Then choose the language and switch it from Python to C#. Make sure the protocol is 2.0. Make sure Validate Units is set to off. Finally, hit generate.

Now, your MAVLink folder should have all of these.

Running the Drone Plugin

To run and test our drone plugin:

1. Start the PX4 simulator in WSL:

   make

2. Open QGroundControl and connect to the simulator.

3. Start your WinTAK plugin in Visual Studio.

   

4. Open the plugin panel in WinTAK to see the drone’s latitude and longitude updating in real time.

While the drone is running in the simulator, you can monitor the MAVLink messages using QGroundControl’s Analyze tools to verify that the data being displayed in your plugin is correct.

That’s a lot to digest all at once, so here’s a video to see how the final application comes together:

Conclusion

WinTAK provides a powerful platform for developing situational awareness applications on Windows, with particular strengths in integrating with drones and other tactical systems. By leveraging the .NET framework and C# language, developers can create sophisticated plugins that extend WinTAK’s capabilities in ways that match their specific operational requirements.

This is just the beginning of your TAK journey. This technology is increasingly in demand within the drone industry and is being deployed in all fields that require geospatial intelligence, like public safety, defense, and emergency response. If you’d like to learn more about TAK-releated technologies, be sure to check out the RIIS.com blog for more tutorials.

To learn more about drone application development join the Drone Software Meetup group for monthly tutorials and networking.