Creating Your Own Algorithm for a SWARM Node - Command Line

Creating Your Own Algorithm

If you have a custom algorithm that you would like to run on a SWARM Node, you can do so by following the instructions below. These instructions assume that you are somewhat familiar with the SWARM RDS Client and have a basic understanding of how the system works.

Step 1

First, you will need to create a new folder called user_code in the SWARM-RDS-Client repository if there isn't one already there.

Step 2

Inside of this folder, you need to create a new folder that is exactly the name of the agent (ie. drone, vehicle, etc.) that will be used in the Simulation. For example, if I wanted to create a vehicle called Drone1, then I would create a folder called Drone1 inside of the user_code folder. Your file structure should look as follows:

Step 3

Next, you will create a new python file (.py) that must be the exact name of the Class that you will create. For example, if I had an algorithm called MyAlgorithm, then I would create a file called MyAlgorithm.py inside of the Drone1 folder. Your file structure should look as follows:

Step 4

Now, you will need to create your algorithm. We have provided a template below that you can use to get started. You can also find this template in the SWARMRDS/utilities folder with the file name algorithm_template.py.

There are only two requirements for your algorithm:

1. You must inherit from the Algorithm class that exists in utilities/algorithm_utils.py. Please reference the template File for how to import this class into your file.

2. You must implement the run method. This method is called every time the SWARM Node is updated. You can use this method to complete any computation that you want. The return of this method is specific to the settings that you provide (ie. what values you tell the SWARM Node to publish). You can find more information about the settings here: Settings.

Please refer to the file "SWARMRDS/utilities/data_classes.py" to see what data types are availabe in your algorithm and how to work with them.

Step 5

Now, you will need to configure your SWARM Simulations File so that it can work with PX4. We have provided an example file below and this file is also in the SWARM Developer Client, in the "settings" folder, titled CustomAlgorithmExampleSimulation.json.

    {
    "ID": 0,
    "SimulationName": "example",
    "RunLength": 200.0,
    "Scenario": {
        "Name": "DataCollection",
        "Options": {
            "MultiLevel": false,
            "LevelNames": [
                "Level1"
            ]
        }
    },
    "Environment": {
        "Name": "MountainVillage",
        "StartingLevelName": "Level1",
        "StreamVideo": true
    },
    "Data": {
        "VehicleState": {
            "Format": "SWARM"
        }
    },
    "Agents": {
        "Drone1": {
            "Vehicle": "Multirotor",
            "VehiclePhysicsProfile": "CodexX500",
            "VehicleOptions": {},
            "AutoPilot": "SWARM",
            "Sensors": {
                "Cameras": {
                    "Camera1": {
                        "Enabled": true,
                        "X": 0.35,
                        "Y": 0.0,
                        "Z": 0.0,
                        "Roll": 0.0,
                        "Pitch": 0.0,
                        "Yaw": 0.0,
                        "ImageType": "Scene",
                        "Width": 640,
                        "Height": 480,
                        "FOV_Degrees": 90.0,
                        "FramesPerSecond": 24.0,
                        "Record": true,
                        "OutputType": "Video",
                        "VideoName": "Camera1_Capture"
                    }
                }
            },
            "Controller": {
                "Name": "SWARMBase",
                "Gains": {
                    "P": 0.95,
                    "I": 0.02,
                    "D": 0.05
                }
            },
            "StartingPosition": {
                "X": 0.0,
                "Y": 0.0,
                "Z": -1.0,
                "Roll": 0.0,
                "Pitch": 0.0,
                "Yaw": 0.0
            },
            "SoftwareModules": {
                "HighLevelBehavior": {
                    "Algorithm": {
                        "Level": 3,
                        "States": [],
                        "Parameters": {
                            "completed_waypoint_distance": 1.25
                        },
                        "InputArgs": [
                            "Trajectory"
                        ],
                        "ClassName": "ExampleAlgorithm",
                        "ReturnValues": [
                            "Position",
                            "Heading",
                            "Speed"
                        ]
                    },
                    "Publishes": [
                        "MovementCommand"
                    ],
                    "Subscribes": [
                        "AgentState"
                    ]
                },
                "LowLevelPathPlanning": {
                    "Algorithm": {
                        "Level": 1,
                        "States": [],
                        "Parameters": {},
                        "InputArgs": [
                            "MovementCommand"
                        ],
                        "ClassName": "PassThroughPlanner",
                        "ReturnValues": [
                            "MovementCommand"
                        ]
                    },
                    "Parameters": {},
                    "Publishes": [],
                    "Subscribes": [
                        "MovementCommand",
                        "AgentState"
                    ]
                }
            }
        }
    }
}
    

Here are some key points of the settings file shown above:

• First, you will notice that we create our algorithm in the module with the name HighLevelBehavior. This will load in our module and handle everything, including receiving and publishing messages.
• Next, you will notice that the Algorithm structure has a field "Level", which is set to 3. This must be set to 3 so that your algorithm will be loaded appropriately.

Step 5

Now, you are ready to run the simulation. Go to the root of the SWARM Developer Client and type in the following information, assuming that you are using the provided CustomAlgorithmExampleSimulation.json file provided in the repo.

        python3 main.py --map-name SWARMHome --sim-settings CustomAlgorithmExampleSimulation
    

You will see that the simulation file is being validated. Once the system has uploaded your configuration file, you will see the following output.

The SWARM RDS Server will provide your algorithm with a set of fake data to validate that your algorithm will actually run. If your algorithm does not run, then you will see an error message in the console.

Step 6

You can visualize the simulator ouptut by starting your favorite Web Browser by either typing in "127.0.0.1" if you are using the local edition or clicking "Launch Streamer" on the RDS CLient application. You will see a gray screen, like below. Click on the screen to start the visualization.

The agent should move along the path defined in "settings/DefaultTrajectory.json".

Step 7 - View the Output

Once the simulation has completed, you can choose to download the data that has been collected by each agent.

Each module has a separate log file that is collected and provided to you for each agent in the system. Simply go to the "data" folder and looks at the "logs" folder to view the output log. Please view the ExampleAlgorithm.py file to see how to log data using our logging system.

Walkthrough

Coming soon, we will have a video describing setup with the GUI application.