Feature/flight structure

flight/__init__.py

@@ -0,0 +1,18 @@
+"""Initialization file for state exporting"""
+from typing import Dict
+from states.state import State
+from states.start_state import Start
+from states.pre_processing import PreProcess
+from states.takeoff import Takeoff
+from states.waypoints import Waypoints
+from states.land import Land
+from states.final_state import Final
+
+STATES: Dict[str, State] = {
+    "Start State": Start,
+    "Pre-Processing": PreProcess,
+    "Takeoff": Takeoff,
+    "Waypoints": Waypoints,
+    "Land": Land,
+    "Final State": Final
+}

flight/state_settings.py

@@ -0,0 +1,121 @@
+"""Class to contain setters and getters for settings in various flight states"""
+
+DEFAULT_WAYPOINTS: int = 14             # Total number of waypoints flown to in Auto. flight of SUAS2022
+DEFAULT_RUN_TITLE: str = "N/A"          # Title of flight mission for logging
+DEFAULT_RUN_DESCRIPTION: str = "N/A"    # Description of current flight mission for logging
+
+
+class StateSettings:
+    """
+    Initialize settings for state machine
+    Functions:
+        __init__: Sets preliminary values for SUAS overheads
+        simple_takeoff() -> None: Enables access to status of simple_takeoff
+                         -> bool: Setter to determine if testing takeoff procedure desired
+        num_waypoints() -> None: Enables access to number of waypoints in the competition
+                        -> int: Sets the number of waypoints in the competition
+        run_title() -> None: Enables access to set name of the current flight
+                    -> str: Sets the name of the current flight for logging
+        run_description() -> None: Enables access to description of current flight mission
+                          -> str: Sets the description of current flight mission
+    Member Variables:
+        __num_waypoints: Number of waypoints on flight plan
+        __run_title: Title of Competition
+        __run_description: Description for Competition
+    """
+    def __init__(self, takeoff_bool: bool = False, num_waypoints: int = DEFAULT_WAYPOINTS,
+                 title: str = DEFAULT_RUN_TITLE, description: str = DEFAULT_RUN_DESCRIPTION):
+        """Default constructor results in default settings
+        Args:
+            takeoff_bool: bool - determines if a simple takeoff procedure should be executed for testing
+            num_waypoints: int - Number of waypoints, extracted from SUAS mission plan
+            title: str - Title of current flight mission, for logging purposes
+            description: str - Description of current flight mission, for logging purposes
+        """
+        self.__simple_takeoff = takeoff_bool
+        self.__num_waypoints = num_waypoints
+        self.__run_title = title
+        self.__run_description = description
+
+    # ---- Takeoff settings ---- #
+    @property
+    def simple_takeoff(self) -> bool:
+        """Establishes simple_takeoff as a private member variable
+        Args:
+            N/A
+        Returns:
+            bool: Status of simple_takeoff variable
+        """
+        return self.__simple_takeoff
+
+    @simple_takeoff.setter
+    def simple_takeoff(self, simple_takeoff: bool) -> None:
+        """Setter for whether to perform simple takeoff instead of regular takeoff
+        Args:
+            simple_takeoff: bool - True for drone to go straight up, False to behave normally
+        Returns:
+            None
+        """
+        self.__simple_takeoff = simple_takeoff
+
+    # ---- Waypoint Settings ---- #
+    @property
+    def num_waypoints(self) -> int:
+        """Establishes num_waypoints as private member variable
+        Args:
+            N/A
+        Returns:
+            int: Number of waypoints in the competition
+        """
+        return self.__num_waypoints
+
+    @num_waypoints.setter
+    def num_waypoints(self, waypoints: int) -> None:
+        """Set the number of waypoints given by Interop System
+        Args:
+            waypoints: int - Number of waypoints present in mission plan
+        Returns:
+            None
+        """
+        self.__num_waypoints = waypoints
+
+    # ---- Other settings ---- #
+    @property
+    def run_title(self) -> str:
+        """Set a title for the run/test to be output in logging
+        Args:
+            N/A
+        Returns:
+            str: Created title for flight mission
+        """
+        return self.__run_title
+
+    @run_title.setter
+    def run_title(self, title: str) -> None:
+        """Sets the title of the flight mission for logging
+        Args:
+            title: str - Desired title for the flight
+        Returns:
+            None
+        """
+        self.__run_title = title
+
+    @property
+    def run_description(self) -> str:
+        """Set a description for the run/test to be output in logging
+        Args:
+            N/A
+        Returns:
+            str: Desired description for flight mission
+        """
+        return self.__run_description
+
+    @run_description.setter
+    def run_description(self, description: str) -> None:
+        """Sets a description of the flight mission
+        Args:
+            description: str - Written description for flight mission for logs
+        Returns:
+            None
+        """
+        self.__run_description = description

flight/states/final_state.py

@@ -0,0 +1,22 @@
+"""Final state to end all drone processes"""
+import logging
+from mavsdk import System
+from state import State
+from ..state_settings import StateSettings
+
+
+class Final(State):
+    """Empty state to end flight
+    Functions:
+        run() -> None: Ends the state machine
+    Member Variables:
+        None
+    """
+    async def run(self, drone: System):
+        """Do nothing and end
+        Args:
+            drone: System - drone object that must be passed to any function with control of the drone
+        Returns:
+            None
+        """
+        return

flight/states/land.py

@@ -0,0 +1,24 @@
+"""Landing the drone at home position after each other task is finished"""
+import logging
+from mavsdk import System
+from state import State
+from ..state_settings import StateSettings
+from states.final_state import Final
+
+
+class Land(State):
+    """
+    State to land the drone safely after finishing other flight & vision tasks
+    Functions:
+        run() -> Final: Running the landing procedure after returning to home
+    Member Variables:
+        None
+    """
+    async def run(self, drone: System) -> Final:
+        """Run landing function to have drone slowly return to home position
+        Args:
+            drone: System - MAVSDK drone object for direct drone control
+        Returns:
+            Final: final state for ending state machine
+        """
+        return Final(self.state_settings)

flight/states/pre_processing.py

@@ -0,0 +1,26 @@
+"""State to receive data from interop system and perform preliminary calculations"""
+import logging
+from mavsdk import System
+from state import State
+from ..state_settings import StateSettings
+from takeoff import Takeoff
+
+
+class PreProcess(State):
+    """
+    State to accept data and plan out optimal mission structure based on relative distances
+    Functions:
+        data_retrieval() -> Takeoff: Connects to Interop and downloads JSON data from system
+        ... # Will add more functions as needed during dev
+    Member Variables:
+        None
+    """
+    async def data_retrieval(self, drone: System) -> Takeoff:
+        """Prelim function to accept data
+        Args:
+            drone: System - MAVSDK drone object for direct drone control
+        Returns:
+            Takeoff: the next state, the Takeoff state to advance state machine
+        """
+        return Takeoff(self.state_settings)
+

flight/states/start_state.py

@@ -0,0 +1,23 @@
+"""Beginning state of flight operation, proceed to pre-processing"""
+import logging
+from mavsdk import System
+from state import State
+from ..state_settings import StateSettings
+from states.pre_processing import PreProcess
+
+
+class Start(State):
+    """Preliminary state, proceed state machine into pre-processing
+    Functions:
+        begin() -> PreProcess: beginning function to start state machine, proceeding to pre-processing step
+    Member Variables:
+        None
+    """
+    async def begin(self, drone: System) -> PreProcess:
+        """Initialization function to start flight state machine
+        Args:
+            drone: System - drone object for directv drone control
+        Returns:
+            PreProcess: data pre-processing state, to advance state machine
+        """
+        return PreProcess(self.state_settings)

flight/states/state.py

@@ -0,0 +1,55 @@
+"""Base State class which all other states inherit"""
+import logging
+from mavsdk import System
+from ..state_settings import StateSettings
+
+
+class State:
+    """
+    Base State class
+    Attributes:
+        drone (System): The drone object; used for flight.
+    """
+
+    def __init__(self, state_settings: StateSettings):
+        logging.info('State "%s" has begun', self.name)
+        self.state_settings = state_settings
+
+    async def run(self, drone: System):
+        """
+        Does all of the operations for the state
+        Parameters
+        ----------
+        drone : System
+            The drone system; used for flight operations.
+        Returns
+        -------
+        State or None
+            Either the next State in the machine or None if the machine stops
+        Raises
+        ------
+        Exception
+            If this function hasn't been overloaded.
+        """
+        raise Exception("Run not implemented for state")
+
+    async def _check_arm_or_arm(self, drone: System):
+        """
+        Verifies that the drone is armed, if not armed, arms the drone
+        Parameters
+        ----------
+        drone : System
+            The drone system; used for flight operations.
+        """
+        async for is_armed in drone.telemetry.armed():
+            if not is_armed:
+                logging.debug("Not armed. Attempting to arm")
+                await drone.action.arm()
+            else:
+                logging.warning("Drone armed")
+                break
+
+    @property
+    def name(self):
+        """Returns the name of the class"""
+        return type(self).__name__