Merged beta into master

Tools/px4airframes/README.md

@@ -0,0 +1 @@
+This folder contains a python library used by px_process_params.py

Tools/px4airframes/__init__.py

@@ -0,0 +1 @@
+__all__ = ["srcscanner", "srcparser", "xmlout", "rcout"]

Tools/px4airframes/rcout.py

@@ -0,0 +1,54 @@
+from xml.sax.saxutils import escape
+import codecs
+
+class RCOutput():
+    def __init__(self, groups, board):
+        result = (  "#\n"
+                    "#\n"
+                    "#  THIS FILE IS AUTO-GENERATED. DO NOT EDIT!\n"
+                    "#\n"
+                    "#\n"
+                    "# SYS_AUTOSTART = 0 means no autostart (default)\n"
+                    "#\n"
+                    "# AUTOSTART PARTITION:\n"
+                    "#  0    ..   999        Reserved (historical)\n"
+                    "#  1000 ..   1999       Simulation setups\n"
+                    "#  2000 ..   2999       Standard planes\n"
+                    "#  3000 ..   3999       Flying wing\n"
+                    "#  4000 ..   4999       Quadrotor x\n"
+                    "#  5000 ..   5999       Quadrotor +\n"
+                    "#  6000 ..   6999       Hexarotor x\n"
+                    "#  7000 ..   7999       Hexarotor +\n"
+                    "#  8000 ..   8999       Octorotor x\n"
+                    "#  9000 ..   9999       Octorotor +\n"
+                    "# 10000 ..  10999       Quadrotor Wide arm / H frame\n"
+                    "# 11000 ..  11999       Hexa Cox\n"
+                    "# 12000 ..  12999       Octo Cox\n"
+                    "# 13000 ..  13999       VTOL\n"
+                    "# 14000 ..  14999       Tri Y\n"
+                    "\n")
+        for group in groups:
+            result += "# GROUP: %s\n\n" % group.GetName()
+            for param in group.GetParams():
+                path = param.GetPath().rsplit('/', 1)[1]
+                id_val = param.GetId()
+                name = param.GetFieldValue("short_desc")
+                long_desc = param.GetFieldValue("long_desc")
+
+                result +=   "#\n"
+                result +=   "# %s\n" % param.GetName()
+                result +=   "if param compare SYS_AUTOSTART %s\n" % id_val
+                result +=   "then\n"
+                result +=   "\tsh /etc/init.d/%s\n" % path
+                result +=   "fi\n"
+
+                #if long_desc is not None:
+                #    result += "# %s\n" % long_desc
+                result += "\n"
+
+            result += "\n"
+        self.output = result;
+
+    def Save(self, filename):
+        with codecs.open(filename, 'w', 'utf-8') as f:
+            f.write(self.output)

Tools/px4airframes/srcparser.py

@@ -0,0 +1,346 @@
+import sys
+import re
+
+class ParameterGroup(object):
+    """
+    Single parameter group
+    """
+    def __init__(self, name):
+        self.name = name
+        self.params = []
+
+    def AddParameter(self, param):
+        """
+        Add parameter to the group
+        """
+        self.params.append(param)
+
+    def GetName(self):
+        """
+        Get parameter group name
+        """
+        return self.name
+
+    def GetParams(self):
+        """
+        Returns the parsed list of parameters. Every parameter is a Parameter
+        object. Note that returned object is not a copy. Modifications affect
+        state of the parser.
+        """
+        return sorted(self.params,
+                key=lambda x: x.GetFieldValue("code"))
+
+class Parameter(object):
+    """
+    Single parameter
+    """
+
+    # Define sorting order of the fields
+    priority = {
+		"board": 9,
+        "short_desc": 8,
+        "long_desc": 7,
+        "min": 5,
+        "max": 4,
+        "unit": 3,
+        # all others == 0 (sorted alphabetically)
+    }
+
+    def __init__(self, path, name, airframe_type, airframe_id, maintainer):
+        self.fields = {}
+        self.outputs = {}
+        self.path = path
+        self.name = name
+        self.type = airframe_type
+        self.id = airframe_id
+        self.maintainer = maintainer
+
+    def GetPath(self):
+        return self.path
+
+    def GetName(self):
+        return self.name
+
+    def GetType(self):
+        return self.type
+
+    def GetId(self):
+        return self.id
+
+    def GetMaintainer(self):
+        return self.maintainer
+
+    def SetField(self, code, value):
+        """
+        Set named field value
+        """
+        self.fields[code] = value
+
+    def SetOutput(self, code, value):
+        """
+        Set named output value
+        """
+        self.outputs[code] = value
+
+    def GetFieldCodes(self):
+        """
+        Return list of existing field codes in convenient order
+        """
+        keys = self.fields.keys()
+        keys = sorted(keys)
+        keys = sorted(keys, key=lambda x: self.priority.get(x, 0), reverse=True)
+        return keys
+
+    def GetFieldValue(self, code):
+        """
+        Return value of the given field code or None if not found.
+        """
+        fv =  self.fields.get(code)
+        if not fv:
+                # required because python 3 sorted does not accept None
+                return ""
+        return self.fields.get(code)
+
+    def GetOutputCodes(self):
+        """
+        Return list of existing output codes in convenient order
+        """
+        keys = self.outputs.keys()
+        keys = sorted(keys)
+        keys = sorted(keys, key=lambda x: self.priority.get(x, 0), reverse=True)
+        return keys
+
+    def GetOutputValue(self, code):
+        """
+        Return value of the given output code or None if not found.
+        """
+        fv =  self.outputs.get(code)
+        if not fv:
+                # required because python 3 sorted does not accept None
+                return ""
+        return self.outputs.get(code)
+
+class SourceParser(object):
+    """
+    Parses provided data and stores all found parameters internally.
+    """
+
+    re_split_lines = re.compile(r'[\r\n]+')
+    re_comment_start = re.compile(r'^\#\s')
+    re_comment_content = re.compile(r'^\#\s*(.*)')
+    re_comment_tag = re.compile(r'@([a-zA-Z][a-zA-Z0-9_]*)\s*(.*)')
+    re_comment_end = re.compile(r'(.*?)\s*\#\n/')
+    re_cut_type_specifier = re.compile(r'[a-z]+$')
+    re_is_a_number = re.compile(r'^-?[0-9\.]')
+    re_remove_dots = re.compile(r'\.+$')
+    re_remove_carriage_return = re.compile('\n+')
+
+    valid_tags = set(["url", "maintainer", "output", "name", "type"])
+
+    # Order of parameter groups
+    priority = {
+        # All other groups = 0 (sort alphabetically)
+        "Miscellaneous": -10
+    }
+
+    def __init__(self):
+        self.param_groups = {}
+
+    def GetSupportedExtensions(self):
+        """
+        Returns list of supported file extensions that can be parsed by this
+        parser. The parser uses any extension.
+        """
+        return [""]
+
+    def Parse(self, path, contents):
+        """
+        Incrementally parse program contents and append all found airframes
+        to the list.
+        """
+
+        airframe_id = None
+        airframe_id = path.rsplit('/',1)[1].split('_',1)[0]
+
+        # Skip if not numeric
+        if (not self.IsNumber(airframe_id)):
+            return True
+
+        # This code is essentially a comment-parsing grammar. "state"
+        # represents parser state. It contains human-readable state
+        # names.
+        state = None
+        tags = {}
+        outputs = {}
+        for line in self.re_split_lines.split(contents):
+            line = line.strip()
+            # Ignore empty lines
+            if line == "":
+                continue
+            if state is None and self.re_comment_start.match(line):
+                state = "wait-short"
+                short_desc = None
+                long_desc = None
+            if state is not None and state != "comment-processed":
+                m = self.re_comment_end.search(line)
+                if m:
+                    line = m.group(1)
+                    last_comment_line = True
+                else:
+                    last_comment_line = False
+                m = self.re_comment_content.match(line)
+                if m:
+                    comment_content = m.group(1)
+                    if comment_content == "":
+                        # When short comment ends with empty comment line,
+                        # start waiting for the next part - long comment.
+                        if state == "wait-short-end":
+                            state = "wait-long"
+                    else:
+                        m = self.re_comment_tag.match(comment_content)
+                        if m:
+                            tag, desc = m.group(1, 2)
+                            if (tag == "output"):
+                                key, text = desc.split(' ', 1)
+                                outputs[key] = text;
+                            else:
+                                tags[tag] = desc
+                            current_tag = tag
+                            state = "wait-tag-end"
+                        elif state == "wait-short":
+                            # Store first line of the short description
+                            short_desc = comment_content
+                            state = "wait-short-end"
+                        elif state == "wait-short-end":
+                            # Append comment line to the short description
+                            short_desc += "\n" + comment_content
+                        elif state == "wait-long":
+                            # Store first line of the long description
+                            long_desc = comment_content
+                            state = "wait-long-end"
+                        elif state == "wait-long-end":
+                            # Append comment line to the long description
+                            long_desc += "\n" + comment_content
+                        elif state == "wait-tag-end":
+                            # Append comment line to the tag text
+                            tags[current_tag] += "\n" + comment_content
+                        else:
+                            raise AssertionError(
+                                    "Invalid parser state: %s" % state)
+                elif not last_comment_line:
+                    # Invalid comment line (inside comment, but not starting with
+                    # "*" or "*/". Reset parsed content.
+                    state = None
+                if last_comment_line:
+                    state = "comment-processed"
+            else:
+                state = None
+
+        # Process parsed content
+        airframe_type = None
+        maintainer = "John Doe <john@example.com>"
+        airframe_name = None
+
+        # Done with file, store
+        for tag in tags:
+            if tag == "maintainer":
+                maintainer = tags[tag]
+            elif tag == "type":
+                airframe_type = tags[tag]
+            elif tag == "name":
+                airframe_name = tags[tag]
+            elif tag not in self.valid_tags:
+                sys.stderr.write("Aborting due to invalid documentation tag: '%s'\n" % tag)
+                return False
+
+        # Sanity check
+        if airframe_type == None:
+            sys.stderr.write("Aborting due to missing @type tag in file: '%s'\n" % path)
+            return False
+
+        if airframe_name == None:
+            sys.stderr.write("Aborting due to missing @name tag in file: '%s'\n" % path)
+            return False
+
+        # We already know this is an airframe config, so add it
+        param = Parameter(path, airframe_name, airframe_type, airframe_id, maintainer)
+
+        # Done with file, store
+        for tag in tags:
+            if tag == "maintainer":
+                maintainer = tags[tag]
+            if tag == "type":
+                airframe_type = tags[tag]
+            if tag == "name":
+                airframe_name = tags[tag]
+            else:
+                param.SetField(tag, tags[tag])
+
+        # Store outputs
+        for output in outputs:
+            param.SetOutput(output, outputs[output])
+
+        # Store the parameter
+        if airframe_type not in self.param_groups:
+            self.param_groups[airframe_type] = ParameterGroup(airframe_type)
+        self.param_groups[airframe_type].AddParameter(param)
+
+        return True
+    
+    def IsNumber(self, numberString):
+        try:
+            float(numberString)
+            return True
+        except ValueError:
+            return False
+
+    def Validate(self):
+        """
+        Validates the airframe meta data.
+        """
+        seenParamNames = []
+        for group in self.GetParamGroups():
+            for param in group.GetParams():
+                name  = param.GetName()
+                board = param.GetFieldValue("board")
+                # Check for duplicates
+                name_plus_board = name + "+" + board
+                for seenParamName in seenParamNames:
+                    if seenParamName == name_plus_board:
+                        sys.stderr.write("Duplicate parameter definition: {0}\n".format(name_plus_board))
+                        return False
+                seenParamNames.append(name_plus_board)
+                # Validate values
+                default = param.GetDefault()
+                min = param.GetFieldValue("min")
+                max = param.GetFieldValue("max")
+                #sys.stderr.write("{0} default:{1} min:{2} max:{3}\n".format(name, default, min, max))
+                if default != "" and not self.IsNumber(default):
+                    sys.stderr.write("Default value not number: {0} {1}\n".format(name, default))
+                    return False
+                if min != "":
+                    if not self.IsNumber(min):
+                        sys.stderr.write("Min value not number: {0} {1}\n".format(name, min))
+                        return False
+                    if default != "" and float(default) < float(min):
+                        sys.stderr.write("Default value is smaller than min: {0} default:{1} min:{2}\n".format(name, default, min))
+                        return False
+                if max != "":
+                    if not self.IsNumber(max):
+                        sys.stderr.write("Max value not number: {0} {1}\n".format(name, max))
+                        return False
+                    if default != "" and float(default) > float(max):
+                        sys.stderr.write("Default value is larger than max: {0} default:{1} max:{2}\n".format(name, default, max))
+                        return False
+        return True
+
+    def GetParamGroups(self):
+        """
+        Returns the parsed list of parameters. Every parameter is a Parameter
+        object. Note that returned object is not a copy. Modifications affect
+        state of the parser.
+        """
+        groups = self.param_groups.values()
+        groups = sorted(groups, key=lambda x: x.GetName())
+        groups = sorted(groups, key=lambda x: self.priority.get(x.GetName(), 0), reverse=True)
+        return groups

Tools/px4airframes/srcscanner.py

@@ -0,0 +1,37 @@
+import os
+import re
+import codecs
+
+class SourceScanner(object):
+    """
+    Traverses directory tree, reads all source files, and passes their contents
+    to the Parser.
+    """
+
+    def ScanDir(self, srcdir, parser):
+        """
+        Scans provided path and passes all found contents to the parser using
+        parser.Parse method.
+        """
+        extensions = tuple(parser.GetSupportedExtensions())
+        for dirname, dirnames, filenames in os.walk(srcdir):
+            for filename in filenames:
+                if filename.endswith(extensions):
+                    path = os.path.join(dirname, filename)
+                    if not self.ScanFile(path, parser):
+                        return False
+        return True
+
+    def ScanFile(self, path, parser):
+        """
+        Scans provided file and passes its contents to the parser using
+        parser.Parse method.
+        """
+        with codecs.open(path, 'r', 'utf-8') as f:
+            try:
+                contents = f.read()
+            except:
+                contents = ''
+                print('Failed reading file: %s, skipping content.' % path)
+                pass
+        return parser.Parse(path, contents)

Tools/px4airframes/xmlout.py

@@ -0,0 +1,84 @@
+import xml.etree.ElementTree as ET
+import codecs
+
+def indent(elem, level=0):
+    i = "\n" + level*"  "
+    if len(elem):
+        if not elem.text or not elem.text.strip():
+            elem.text = i + "  "
+        if not elem.tail or not elem.tail.strip():
+            elem.tail = i
+        for elem in elem:
+            indent(elem, level+1)
+        if not elem.tail or not elem.tail.strip():
+            elem.tail = i
+    else:
+        if level and (not elem.tail or not elem.tail.strip()):
+            elem.tail = i
+
+class XMLOutput():
+
+    def __init__(self, groups, board):
+        xml_parameters = ET.Element("airframes")
+        xml_version = ET.SubElement(xml_parameters, "version")
+        xml_version.text = "1"
+        last_param_name = ""
+        board_specific_param_set = False
+        for group in groups:
+            xml_group = ET.SubElement(xml_parameters, "airframe_group")
+            xml_group.attrib["name"] = group.GetName()
+            if (group.GetName() == "Standard Plane"):
+                xml_group.attrib["image"] = "AirframeStandardPlane.png"
+            elif (group.GetName() == "Flying Wing"):
+                xml_group.attrib["image"] = "AirframeFlyingWing.png"
+            elif (group.GetName() == "Quadrotor x"):
+                xml_group.attrib["image"] = "AirframeQuadRotorX.png"
+            elif (group.GetName() == "Quadrotor +"):
+                xml_group.attrib["image"] = "AirframeQuadRotorPlus.png"
+            elif (group.GetName() == "Hexarotor x"):
+                xml_group.attrib["image"] = "AirframeHexaRotorX.png"
+            elif (group.GetName() == "Hexarotor +"):
+                xml_group.attrib["image"] = "AirframeHexaRotorPlus.png"
+            elif (group.GetName() == "Octorotor +"):
+                xml_group.attrib["image"] = "AirframeOctoRotorPlus.png"
+            elif (group.GetName() == "Octorotor x"):
+                xml_group.attrib["image"] = "AirframeOctoRotorX.png"
+            elif (group.GetName() == "Quadrotor Wide"):
+                xml_group.attrib["image"] = "AirframeQuadRotorH.png"
+            elif (group.GetName() == "Quadrotor H"):
+                xml_group.attrib["image"] = "AirframeQuadRotorH.png"
+            elif (group.GetName() == "Simulation"):
+                xml_group.attrib["image"] = "AirframeSimulation.png"
+            else:
+                xml_group.attrib["image"] = ""
+            for param in group.GetParams():
+                if (last_param_name == param.GetName() and not board_specific_param_set) or last_param_name != param.GetName():
+                    xml_param = ET.SubElement(xml_group, "airframe")
+                    xml_param.attrib["name"] = param.GetName()
+                    xml_param.attrib["id"] = param.GetId()
+                    xml_param.attrib["maintainer"] = param.GetMaintainer()
+                    last_param_name = param.GetName()
+                    for code in param.GetFieldCodes():
+                        value = param.GetFieldValue(code)
+                        if code == "board":
+                            if value == board:
+                                board_specific_param_set = True
+                                xml_field = ET.SubElement(xml_param, code)
+                                xml_field.text = value
+                            else:
+                                xml_group.remove(xml_param)
+                        else:
+                            xml_field = ET.SubElement(xml_param, code)
+                            xml_field.text = value
+                    for code in param.GetOutputCodes():
+                        value = param.GetOutputValue(code)
+                        xml_field = ET.SubElement(xml_param, "output")
+                        xml_field.attrib["name"] = code
+                        xml_field.text = value
+                if last_param_name != param.GetName():
+                    board_specific_param_set = False
+        indent(xml_parameters)
+        self.xml_document = ET.ElementTree(xml_parameters)
+
+    def Save(self, filename):
+        self.xml_document.write(filename, encoding="UTF-8")

Tools/px_process_airframes.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python
+############################################################################
+#
+#   Copyright (C) 2013-2015 PX4 Development Team. All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# 1. Redistributions of source code must retain the above copyright
+#    notice, this list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright
+#    notice, this list of conditions and the following disclaimer in
+#    the documentation and/or other materials provided with the
+#    distribution.
+# 3. Neither the name PX4 nor the names of its contributors may be
+#    used to endorse or promote products derived from this software
+#    without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+# OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+# AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+#
+############################################################################
+
+#
+# PX4 airframe config processor (main executable file)
+#
+# This tool scans the PX4 source code for declarations of airframes
+#
+# Currently supported formats are:
+#   * XML for the parametric UI generator
+#
+#
+
+from __future__ import print_function
+import sys
+import os
+import argparse
+from px4airframes import srcscanner, srcparser, xmlout, rcout
+
+def main():
+    # Parse command line arguments
+    parser = argparse.ArgumentParser(description="Process airframe documentation.")
+    parser.add_argument("-a", "--airframes-path",
+                        default="../ROMFS/px4fmu_common",
+                        metavar="PATH",
+                        help="path to source files to scan for parameters")
+    parser.add_argument("-x", "--xml",
+                        nargs='?',
+                        const="airframes.xml",
+                        metavar="FILENAME",
+                        help="Create XML file"
+                             " (default FILENAME: airframes.xml)")
+    parser.add_argument("-s", "--start-script",
+                        nargs='?',
+                        const="rc.autostart",
+                        metavar="FILENAME",
+                        help="Create start script file")
+    parser.add_argument("-b", "--board",
+                         nargs='?',
+                         const="",
+                         metavar="BOARD",
+                         help="Board to create airframes xml for")
+    args = parser.parse_args()
+
+    # Check for valid command
+    if not (args.xml) and not (args.start_script):
+        print("Error: You need to specify at least one output method!\n")
+        parser.print_usage()
+        sys.exit(1)
+
+    # Initialize source scanner and parser
+    scanner = srcscanner.SourceScanner()
+    parser = srcparser.SourceParser()
+
+    # Scan directories, and parse the files
+    print("Scanning source path " + args.airframes_path)
+    if not scanner.ScanDir(args.airframes_path, parser):
+        sys.exit(1)
+    # We can't validate yet
+    # if not parser.Validate():
+    #     sys.exit(1)
+    param_groups = parser.GetParamGroups()
+
+    # Output to XML file
+    if args.xml:
+        print("Creating XML file " + args.xml)
+        out = xmlout.XMLOutput(param_groups, args.board)
+        out.Save(args.xml)
+
+    if args.start_script:
+        print("Creating start script " + args.start_script)
+        out = rcout.RCOutput(param_groups, args.board)
+        out.Save(args.start_script)
+
+    print("All done!")
+
+
+if __name__ == "__main__":
+    main()