mirror of
https://gitee.com/mirrors_PX4/PX4-Autopilot.git
synced 2026-06-28 06:00:34 +08:00
cmake remove circular linking and reorganize
- px4_add_module now requires MAIN - px4_add_library doesn't automatically link
This commit is contained in:
Daniel Agar
@@ -1,129 +0,0 @@
|
||||
############################################################################
|
||||
#
|
||||
# Copyright (c) 2017 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.
|
||||
#
|
||||
############################################################################
|
||||
|
||||
set(SRCS)
|
||||
if ("${CONFIG_SHMEM}" STREQUAL "1")
|
||||
message(STATUS "parameters shared memory enabled")
|
||||
list(APPEND SRCS
|
||||
param_shmem.c
|
||||
)
|
||||
else()
|
||||
list(APPEND SRCS
|
||||
param.c
|
||||
)
|
||||
endif()
|
||||
|
||||
if (NOT PARAM_DEFAULT_OVERRIDES)
|
||||
set(PARAM_DEFAULT_OVERRIDES "{}")
|
||||
endif()
|
||||
|
||||
# get full path for each module
|
||||
set(module_list)
|
||||
if (DISABLE_PARAMS_MODULE_SCOPING)
|
||||
# search all directories with .c files (potentially containing parameters)
|
||||
file(GLOB_RECURSE new_list
|
||||
${PX4_SOURCE_DIR}/src/*.c
|
||||
${external_module_paths}
|
||||
)
|
||||
foreach(file_path ${new_list})
|
||||
get_filename_component(dir_path ${file_path} PATH)
|
||||
list(APPEND module_list "${dir_path}")
|
||||
endforeach()
|
||||
list(REMOVE_DUPLICATES module_list)
|
||||
else()
|
||||
foreach(module ${config_module_list})
|
||||
# include all subdirectories as well
|
||||
file(GLOB children RELATIVE ${PX4_SOURCE_DIR}/src/${module} ${PX4_SOURCE_DIR}/src/${module}/*)
|
||||
foreach(child ${children})
|
||||
if(IS_DIRECTORY ${PX4_SOURCE_DIR}/src/${module}/${child})
|
||||
list(APPEND module_list ${PX4_SOURCE_DIR}/src/${module}/${child})
|
||||
endif()
|
||||
endforeach()
|
||||
|
||||
list(APPEND module_list ${PX4_SOURCE_DIR}/src/${module})
|
||||
endforeach()
|
||||
|
||||
list(APPEND module_list ${external_module_paths})
|
||||
endif()
|
||||
|
||||
list(REMOVE_DUPLICATES module_list)
|
||||
|
||||
set(parameters_xml ${PX4_BINARY_DIR}/parameters.xml)
|
||||
file(GLOB_RECURSE param_src_files ${PX4_SOURCE_DIR}/src/*params.c)
|
||||
add_custom_command(OUTPUT ${parameters_xml}
|
||||
COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/px_process_params.py
|
||||
--src-path ${module_list}
|
||||
--xml ${parameters_xml}
|
||||
--inject-xml ${CMAKE_CURRENT_SOURCE_DIR}/parameters_injected.xml
|
||||
--overrides ${PARAM_DEFAULT_OVERRIDES}
|
||||
--board ${BOARD}
|
||||
#--verbose
|
||||
DEPENDS
|
||||
${param_src_files}
|
||||
parameters_injected.xml
|
||||
px4params/srcparser.py
|
||||
px4params/srcscanner.py
|
||||
px4params/xmlout.py
|
||||
px_process_params.py
|
||||
COMMENT "Generating parameters.xml"
|
||||
)
|
||||
add_custom_target(parameters_xml DEPENDS ${parameters_xml})
|
||||
|
||||
# generate px4_parameters.c and px4_parameters{,_public}.h
|
||||
add_custom_command(OUTPUT px4_parameters.c px4_parameters.h px4_parameters_public.h
|
||||
COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/px_generate_params.py
|
||||
--xml ${parameters_xml} --dest ${CMAKE_CURRENT_BINARY_DIR}
|
||||
DEPENDS
|
||||
${PX4_BINARY_DIR}/parameters.xml
|
||||
px_generate_params.py
|
||||
templates/px4_parameters.c.jinja
|
||||
templates/px4_parameters.h.jinja
|
||||
templates/px4_parameters_public.h.jinja
|
||||
)
|
||||
|
||||
add_custom_target(parameter_headers DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/px4_parameters_public.h)
|
||||
add_dependencies(prebuild_targets parameter_headers)
|
||||
|
||||
px4_add_module(
|
||||
MODULE modules__systemlib__param
|
||||
COMPILE_FLAGS
|
||||
-Wno-sign-compare # TODO: fix all sign-compare
|
||||
INCLUDES
|
||||
${CMAKE_CURRENT_BINARY_DIR}
|
||||
SRCS
|
||||
${SRCS}
|
||||
px4_parameters.c
|
||||
px4_parameters.h
|
||||
DEPENDS
|
||||
platforms__common
|
||||
)
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,502 +0,0 @@
|
||||
/****************************************************************************
|
||||
*
|
||||
* Copyright (c) 2012-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.
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
/**
|
||||
* @file param.h
|
||||
*
|
||||
* Global parameter store.
|
||||
*
|
||||
* Note that a number of API members are marked const or pure; these
|
||||
* assume that the set of parameters cannot change, or that a parameter
|
||||
* cannot change type or size over its lifetime. If any of these assumptions
|
||||
* are invalidated, the attributes should be re-evaluated.
|
||||
*/
|
||||
|
||||
#ifndef _SYSTEMLIB_PARAM_PARAM_H
|
||||
#define _SYSTEMLIB_PARAM_PARAM_H
|
||||
|
||||
#include <stdint.h>
|
||||
#include <stdbool.h>
|
||||
#include <sys/types.h>
|
||||
|
||||
/** Maximum size of the parameter backing file */
|
||||
#define PARAM_FILE_MAXSIZE 4096
|
||||
|
||||
__BEGIN_DECLS
|
||||
|
||||
/**
|
||||
* Parameter types.
|
||||
*/
|
||||
#define PARAM_TYPE_INT32 0
|
||||
#define PARAM_TYPE_FLOAT 1
|
||||
#define PARAM_TYPE_STRUCT 100
|
||||
#define PARAM_TYPE_STRUCT_MAX (16384 + PARAM_TYPE_STRUCT)
|
||||
#define PARAM_TYPE_UNKNOWN (0xffff)
|
||||
|
||||
typedef uint16_t param_type_t;
|
||||
|
||||
|
||||
#ifdef __PX4_NUTTX // on NuttX use 16 bits to save RAM
|
||||
/**
|
||||
* Parameter handle.
|
||||
*
|
||||
* Parameters are represented by parameter handles, which can
|
||||
* be obtained by looking up parameters. They are an offset into a global
|
||||
* constant parameter array.
|
||||
*/
|
||||
typedef uint16_t param_t;
|
||||
|
||||
/**
|
||||
* Handle returned when a parameter cannot be found.
|
||||
*/
|
||||
#define PARAM_INVALID ((uint16_t)0xffff)
|
||||
|
||||
/**
|
||||
* Magic handle for hash check param
|
||||
*/
|
||||
#define PARAM_HASH ((uint16_t)INT16_MAX)
|
||||
|
||||
#else // on other platforms use 32 bits for better performance
|
||||
|
||||
/**
|
||||
* Parameter handle.
|
||||
*
|
||||
* Parameters are represented by parameter handles, which can
|
||||
* be obtained by looking up parameters. They are an offset into a global
|
||||
* constant parameter array.
|
||||
*/
|
||||
typedef uint32_t param_t;
|
||||
|
||||
/**
|
||||
* Handle returned when a parameter cannot be found.
|
||||
*/
|
||||
#define PARAM_INVALID ((uint32_t)0xffffffff)
|
||||
|
||||
/**
|
||||
* Magic handle for hash check param
|
||||
*/
|
||||
#define PARAM_HASH ((uint32_t)INT32_MAX)
|
||||
|
||||
#endif /* __PX4_NUTTX */
|
||||
|
||||
|
||||
/**
|
||||
* Initialize the param backend. Call this on startup before calling any other methods.
|
||||
*/
|
||||
__EXPORT void param_init(void);
|
||||
|
||||
/**
|
||||
* Look up a parameter by name.
|
||||
*
|
||||
* @param name The canonical name of the parameter being looked up.
|
||||
* @return A handle to the parameter, or PARAM_INVALID if the parameter does not exist.
|
||||
* This call will also set the parameter as "used" in the system, which is used
|
||||
* to e.g. show the parameter via the RC interface
|
||||
*/
|
||||
__EXPORT param_t param_find(const char *name);
|
||||
|
||||
/**
|
||||
* Look up a parameter by name.
|
||||
*
|
||||
* @param name The canonical name of the parameter being looked up.
|
||||
* @return A handle to the parameter, or PARAM_INVALID if the parameter does not exist.
|
||||
*/
|
||||
__EXPORT param_t param_find_no_notification(const char *name);
|
||||
|
||||
/**
|
||||
* Return the total number of parameters.
|
||||
*
|
||||
* @return The number of parameters.
|
||||
*/
|
||||
__EXPORT unsigned param_count(void);
|
||||
|
||||
/**
|
||||
* Return the actually used number of parameters.
|
||||
*
|
||||
* @return The number of parameters.
|
||||
*/
|
||||
__EXPORT unsigned param_count_used(void);
|
||||
|
||||
/**
|
||||
* Wether a parameter is in use in the system.
|
||||
*
|
||||
* @return True if it has been written or read
|
||||
*/
|
||||
__EXPORT bool param_used(param_t param);
|
||||
|
||||
/**
|
||||
* Look up a parameter by index.
|
||||
*
|
||||
* @param index An index from 0 to n, where n is param_count()-1.
|
||||
* @return A handle to the parameter, or PARAM_INVALID if the index is out of range.
|
||||
*/
|
||||
__EXPORT param_t param_for_index(unsigned index);
|
||||
|
||||
/**
|
||||
* Look up an used parameter by index.
|
||||
*
|
||||
* @param index The parameter to obtain the index for.
|
||||
* @return The index of the parameter in use, or -1 if the parameter does not exist.
|
||||
*/
|
||||
__EXPORT param_t param_for_used_index(unsigned index);
|
||||
|
||||
/**
|
||||
* Look up the index of a parameter.
|
||||
*
|
||||
* @param param The parameter to obtain the index for.
|
||||
* @return The index, or -1 if the parameter does not exist.
|
||||
*/
|
||||
__EXPORT int param_get_index(param_t param);
|
||||
|
||||
/**
|
||||
* Look up the index of an used parameter.
|
||||
*
|
||||
* @param param The parameter to obtain the index for.
|
||||
* @return The index of the parameter in use, or -1 if the parameter does not exist.
|
||||
*/
|
||||
__EXPORT int param_get_used_index(param_t param);
|
||||
|
||||
/**
|
||||
* Obtain the name of a parameter.
|
||||
*
|
||||
* @param param A handle returned by param_find or passed by param_foreach.
|
||||
* @return The name assigned to the parameter, or NULL if the handle is invalid.
|
||||
*/
|
||||
__EXPORT const char *param_name(param_t param);
|
||||
|
||||
/**
|
||||
* Obtain the volatile state of a parameter.
|
||||
*
|
||||
* @param param A handle returned by param_find or passed by param_foreach.
|
||||
* @return true if the parameter is volatile
|
||||
*/
|
||||
__EXPORT bool param_is_volatile(param_t param);
|
||||
|
||||
/**
|
||||
* Test whether a parameter's value has changed from the default.
|
||||
*
|
||||
* @return If true, the parameter's value has not been changed from the default.
|
||||
*/
|
||||
__EXPORT bool param_value_is_default(param_t param);
|
||||
|
||||
/**
|
||||
* Test whether a parameter's value has been changed but not saved.
|
||||
*
|
||||
* @return If true, the parameter's value has not been saved.
|
||||
*/
|
||||
__EXPORT bool param_value_unsaved(param_t param);
|
||||
|
||||
/**
|
||||
* Obtain the type of a parameter.
|
||||
*
|
||||
* @param param A handle returned by param_find or passed by param_foreach.
|
||||
* @return The type assigned to the parameter.
|
||||
*/
|
||||
__EXPORT param_type_t param_type(param_t param);
|
||||
|
||||
/**
|
||||
* Determine the size of a parameter.
|
||||
*
|
||||
* @param param A handle returned by param_find or passed by param_foreach.
|
||||
* @return The size of the parameter's value.
|
||||
*/
|
||||
__EXPORT size_t param_size(param_t param);
|
||||
|
||||
/**
|
||||
* Copy the value of a parameter.
|
||||
*
|
||||
* @param param A handle returned by param_find or passed by param_foreach.
|
||||
* @param val Where to return the value, assumed to point to suitable storage for the parameter type.
|
||||
* For structures, a bitwise copy of the structure is performed to this address.
|
||||
* @return Zero if the parameter's value could be returned, nonzero otherwise.
|
||||
*/
|
||||
__EXPORT int param_get(param_t param, void *val);
|
||||
|
||||
/**
|
||||
* Set the value of a parameter.
|
||||
*
|
||||
* @param param A handle returned by param_find or passed by param_foreach.
|
||||
* @param val The value to set; assumed to point to a variable of the parameter type.
|
||||
* For structures, the pointer is assumed to point to a structure to be copied.
|
||||
* @return Zero if the parameter's value could be set from a scalar, nonzero otherwise.
|
||||
*/
|
||||
__EXPORT int param_set(param_t param, const void *val);
|
||||
|
||||
/**
|
||||
* Mark a parameter as used. Only marked parameters will be sent to a GCS.
|
||||
* A call to param_find() will mark a param as used as well.
|
||||
*
|
||||
* @param param A handle returned by param_find or passed by param_foreach.
|
||||
*/
|
||||
__EXPORT void param_set_used(param_t param);
|
||||
|
||||
/**
|
||||
* Set the value of a parameter, but do not notify the system about the change.
|
||||
*
|
||||
* @param param A handle returned by param_find or passed by param_foreach.
|
||||
* @param val The value to set; assumed to point to a variable of the parameter type.
|
||||
* For structures, the pointer is assumed to point to a structure to be copied.
|
||||
* @return Zero if the parameter's value could be set from a scalar, nonzero otherwise.
|
||||
*/
|
||||
__EXPORT int param_set_no_notification(param_t param, const void *val);
|
||||
|
||||
/**
|
||||
* Notify the system about parameter changes. Can be used for example after several calls to
|
||||
* param_set_no_notification() to avoid unnecessary system notifications.
|
||||
*/
|
||||
__EXPORT void param_notify_changes(void);
|
||||
|
||||
/**
|
||||
* Reset a parameter to its default value.
|
||||
*
|
||||
* This function frees any storage used by struct parameters, and returns the parameter
|
||||
* to its default value.
|
||||
*
|
||||
* @param param A handle returned by param_find or passed by param_foreach.
|
||||
* @return Zero on success, nonzero on failure
|
||||
*/
|
||||
__EXPORT int param_reset(param_t param);
|
||||
|
||||
/**
|
||||
* Reset all parameters to their default values.
|
||||
*
|
||||
* This function also releases the storage used by struct parameters.
|
||||
*/
|
||||
__EXPORT void param_reset_all(void);
|
||||
|
||||
/**
|
||||
* Reset all parameters to their default values except for excluded parameters.
|
||||
*
|
||||
* This function also releases the storage used by struct parameters.
|
||||
*
|
||||
* @param excludes Array of param names to exclude from resetting. Use a wildcard
|
||||
* at the end to exclude parameters with a certain prefix.
|
||||
* @param num_excludes The number of excludes provided.
|
||||
*/
|
||||
__EXPORT void param_reset_excludes(const char *excludes[], int num_excludes);
|
||||
|
||||
/**
|
||||
* Export changed parameters to a file.
|
||||
* Note: this method requires a large amount of stack size!
|
||||
*
|
||||
* @param fd File descriptor to export to.
|
||||
* @param only_unsaved Only export changed parameters that have not yet been exported.
|
||||
* @return Zero on success, nonzero on failure.
|
||||
*/
|
||||
__EXPORT int param_export(int fd, bool only_unsaved);
|
||||
|
||||
/**
|
||||
* Import parameters from a file, discarding any unrecognized parameters.
|
||||
*
|
||||
* This function merges the imported parameters with the current parameter set.
|
||||
*
|
||||
* @param fd File descriptor to import from. (Currently expected to be a file.)
|
||||
* @return Zero on success, nonzero if an error occurred during import.
|
||||
* Note that in the failure case, parameters may be inconsistent.
|
||||
*/
|
||||
__EXPORT int param_import(int fd);
|
||||
|
||||
/**
|
||||
* Load parameters from a file.
|
||||
*
|
||||
* This function resets all parameters to their default values, then loads new
|
||||
* values from a file.
|
||||
*
|
||||
* @param fd File descriptor to import from. (Currently expected to be a file.)
|
||||
* @return Zero on success, nonzero if an error occurred during import.
|
||||
* Note that in the failure case, parameters may be inconsistent.
|
||||
*/
|
||||
__EXPORT int param_load(int fd);
|
||||
|
||||
/**
|
||||
* Apply a function to each parameter.
|
||||
*
|
||||
* Note that the parameter set is not locked during the traversal. It also does
|
||||
* not hold an internal state, so the callback function can block or sleep between
|
||||
* parameter callbacks.
|
||||
*
|
||||
* @param func The function to invoke for each parameter.
|
||||
* @param arg Argument passed to the function.
|
||||
* @param only_changed If true, the function is only called for parameters whose values have
|
||||
* been changed from the default.
|
||||
* @param only_changed If true, the function is only called for parameters which have been
|
||||
* used in one of the running applications.
|
||||
*/
|
||||
__EXPORT void param_foreach(void (*func)(void *arg, param_t param), void *arg, bool only_changed, bool only_used);
|
||||
|
||||
/**
|
||||
* Set the default parameter file name.
|
||||
*
|
||||
* @param filename Path to the default parameter file. The file is not require to
|
||||
* exist.
|
||||
* @return Zero on success.
|
||||
*/
|
||||
__EXPORT int param_set_default_file(const char *filename);
|
||||
|
||||
/**
|
||||
* Get the default parameter file name.
|
||||
*
|
||||
* @return The path to the current default parameter file; either as
|
||||
* a result of a call to param_set_default_file, or the
|
||||
* built-in default.
|
||||
*/
|
||||
__EXPORT const char *param_get_default_file(void);
|
||||
|
||||
/**
|
||||
* Save parameters to the default file.
|
||||
* Note: this method requires a large amount of stack size!
|
||||
*
|
||||
* This function saves all parameters with non-default values.
|
||||
*
|
||||
* @return Zero on success.
|
||||
*/
|
||||
__EXPORT int param_save_default(void);
|
||||
|
||||
/**
|
||||
* Load parameters from the default parameter file.
|
||||
*
|
||||
* @return Zero on success.
|
||||
*/
|
||||
__EXPORT int param_load_default(void);
|
||||
|
||||
/**
|
||||
* Generate the hash of all parameters and their values
|
||||
*
|
||||
* @return CRC32 hash of all param_ids and values
|
||||
*/
|
||||
__EXPORT uint32_t param_hash_check(void);
|
||||
|
||||
|
||||
/**
|
||||
* Enable/disable the param autosaving.
|
||||
* Re-enabling with changed params will not cause an autosave.
|
||||
* @param enable true: enable autosaving, false: disable autosaving
|
||||
*/
|
||||
__EXPORT void param_control_autosave(bool enable);
|
||||
|
||||
/*
|
||||
* Macros creating static parameter definitions.
|
||||
*
|
||||
* Note that these structures are not known by name; they are
|
||||
* collected into a section that is iterated by the parameter
|
||||
* code.
|
||||
*
|
||||
* Note that these macros cannot be used in C++ code due to
|
||||
* their use of designated initializers. They should probably
|
||||
* be refactored to avoid the use of a union for param_value_u.
|
||||
*/
|
||||
|
||||
/** define an int32 parameter */
|
||||
#define PARAM_DEFINE_INT32(_name, _default)
|
||||
|
||||
/** define a float parameter */
|
||||
#define PARAM_DEFINE_FLOAT(_name, _default)
|
||||
|
||||
/** define a parameter that points to a structure */
|
||||
#define PARAM_DEFINE_STRUCT(_name, _default)
|
||||
|
||||
/**
|
||||
* Parameter value union.
|
||||
*/
|
||||
union param_value_u {
|
||||
void *p;
|
||||
int32_t i;
|
||||
float f;
|
||||
};
|
||||
|
||||
/**
|
||||
* Static parameter definition structure.
|
||||
*
|
||||
* This is normally not used by user code; see the PARAM_DEFINE macros
|
||||
* instead.
|
||||
*/
|
||||
struct param_info_s {
|
||||
const char *name
|
||||
|
||||
// GCC 4.8 and higher don't implement proper alignment of static data on
|
||||
// 64-bit. This means that the 24-byte param_info_s variables are
|
||||
// 16 byte aligned by GCC and that messes up the assumption that
|
||||
// sequential items in the __param segment can be addressed as an array.
|
||||
// The assumption is that the address of the second parameter is at
|
||||
// ¶m[0]+sizeof(param[0]). When compiled with clang it is
|
||||
// true, with gcc is is not true.
|
||||
// See https://llvm.org/bugs/show_bug.cgi?format=multiple&id=18006
|
||||
// The following hack is for GCC >=4.8 only. Clang works fine without
|
||||
// this.
|
||||
#ifdef __PX4_POSIX
|
||||
__attribute__((aligned(16)));
|
||||
#else
|
||||
;
|
||||
#endif
|
||||
param_type_t type;
|
||||
uint16_t volatile_param: 1;
|
||||
union param_value_u val;
|
||||
};
|
||||
|
||||
__END_DECLS
|
||||
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if 0 // set to 1 to debug param type mismatches
|
||||
#include <cstdio>
|
||||
#define CHECK_PARAM_TYPE(param, type) \
|
||||
if (param_type(param) != type) { \
|
||||
/* use printf() to avoid having to use more includes */ \
|
||||
printf("wrong type passed to param_get() for param %s\n", param_name(param)); \
|
||||
}
|
||||
#else
|
||||
#define CHECK_PARAM_TYPE(param, type)
|
||||
#endif
|
||||
|
||||
// param is a C-interface. This means there is no overloading, and thus no type-safety for param_get().
|
||||
// So for C++ code we redefine param_get() to inlined overloaded versions, which gives us type-safety
|
||||
// w/o having to use a different interface
|
||||
static inline int param_get_cplusplus(param_t param, float *val)
|
||||
{
|
||||
CHECK_PARAM_TYPE(param, PARAM_TYPE_FLOAT);
|
||||
return param_get(param, val);
|
||||
}
|
||||
static inline int param_get_cplusplus(param_t param, int32_t *val)
|
||||
{
|
||||
CHECK_PARAM_TYPE(param, PARAM_TYPE_INT32);
|
||||
return param_get(param, val);
|
||||
}
|
||||
#undef CHECK_PARAM_TYPE
|
||||
|
||||
#define param_get(param, val) param_get_cplusplus(param, val)
|
||||
|
||||
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#endif
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,138 +0,0 @@
|
||||
<?xml version='1.0' encoding='UTF-8'?>
|
||||
<parameters>
|
||||
<version>3</version>
|
||||
<group name="UAVCAN Motor Parameters" no_code_generation="true">
|
||||
<parameter default="75" name="ctl_bw" type="INT32">
|
||||
<short_desc>Speed controller bandwidth</short_desc>
|
||||
<long_desc>Speed controller bandwidth, in Hz. Higher values result in faster speed and current rise times, but may result in overshoot and higher current consumption. For fixed-wing aircraft, this value should be less than 50 Hz; for multirotors, values up to 100 Hz may provide improvements in responsiveness.</long_desc>
|
||||
<unit>Hertz</unit>
|
||||
<min>10</min>
|
||||
<max>250</max>
|
||||
</parameter>
|
||||
<parameter default="1" name="ctl_dir" type="INT32">
|
||||
<short_desc>Reverse direction</short_desc>
|
||||
<long_desc>Motor spin direction as detected during initial enumeration. Use 0 or 1 to reverse direction.</long_desc>
|
||||
<min>0</min>
|
||||
<max>1</max>
|
||||
</parameter>
|
||||
<parameter default="1" name="ctl_gain" type="FLOAT">
|
||||
<short_desc>Speed (RPM) controller gain</short_desc>
|
||||
<long_desc>Speed (RPM) controller gain. Determines controller
|
||||
aggressiveness; units are amp-seconds per radian. Systems with
|
||||
higher rotational inertia (large props) will need gain increased;
|
||||
systems with low rotational inertia (small props) may need gain
|
||||
decreased. Higher values result in faster response, but may result
|
||||
in oscillation and excessive overshoot. Lower values result in a
|
||||
slower, smoother response.</long_desc>
|
||||
<unit>amp-seconds per radian</unit>
|
||||
<decimal>3</decimal>
|
||||
<min>0.00</min>
|
||||
<max>1.00</max>
|
||||
</parameter>
|
||||
<parameter default="3.5" name="ctl_hz_idle" type="FLOAT">
|
||||
<short_desc>Idle speed (e Hz)</short_desc>
|
||||
<long_desc>Idle speed (e Hz)</long_desc>
|
||||
<unit>Hertz</unit>
|
||||
<decimal>3</decimal>
|
||||
<min>0.0</min>
|
||||
<max>100.0</max>
|
||||
</parameter>
|
||||
<parameter default="25" name="ctl_start_rate" type="INT32">
|
||||
<short_desc>Spin-up rate (e Hz/s)</short_desc>
|
||||
<long_desc>Spin-up rate (e Hz/s)</long_desc>
|
||||
<unit>Hz/s</unit>
|
||||
<min>5</min>
|
||||
<max>1000</max>
|
||||
</parameter>
|
||||
<parameter default="0" name="esc_index" type="INT32">
|
||||
<short_desc>Index of this ESC in throttle command messages.</short_desc>
|
||||
<long_desc>Index of this ESC in throttle command messages.</long_desc>
|
||||
<unit>Index</unit>
|
||||
<min>0</min>
|
||||
<max>15</max>
|
||||
</parameter>
|
||||
<parameter default="20034" name="id_ext_status" type="INT32">
|
||||
<short_desc>Extended status ID</short_desc>
|
||||
<long_desc>Extended status ID</long_desc>
|
||||
<min>1</min>
|
||||
<max>1000000</max>
|
||||
</parameter>
|
||||
<parameter default="50000" name="int_ext_status" type="INT32">
|
||||
<short_desc>Extended status interval (µs)</short_desc>
|
||||
<long_desc>Extended status interval (µs)</long_desc>
|
||||
<unit>µs</unit>
|
||||
<min>0</min>
|
||||
<max>1000000</max>
|
||||
</parameter>
|
||||
<parameter default="50000" name="int_status" type="INT32">
|
||||
<short_desc>ESC status interval (µs)</short_desc>
|
||||
<long_desc>ESC status interval (µs)</long_desc>
|
||||
<unit>µs</unit>
|
||||
<max>1000000</max>
|
||||
</parameter>
|
||||
<parameter default="12" name="mot_i_max" type="FLOAT">
|
||||
<short_desc>Motor current limit in amps</short_desc>
|
||||
<long_desc>Motor current limit in amps. This determines the maximum
|
||||
current controller setpoint, as well as the maximum allowable
|
||||
current setpoint slew rate. This value should generally be set to
|
||||
the continuous current rating listed in the motor’s specification
|
||||
sheet, or set equal to the motor’s specified continuous power
|
||||
divided by the motor voltage limit.</long_desc>
|
||||
<unit>Amps</unit>
|
||||
<decimal>3</decimal>
|
||||
<min>1</min>
|
||||
<max>80</max>
|
||||
</parameter>
|
||||
<parameter default="2300" name="mot_kv" type="INT32">
|
||||
<short_desc>Motor Kv in RPM per volt</short_desc>
|
||||
<long_desc>Motor Kv in RPM per volt. This can be taken from the motor’s
|
||||
specification sheet; accuracy will help control performance but
|
||||
some deviation from the specified value is acceptable.</long_desc>
|
||||
<unit>RPM/v</unit>
|
||||
<min>0</min>
|
||||
<max>4000</max>
|
||||
</parameter>
|
||||
<parameter default="0.0" name="mot_ls" type="FLOAT">
|
||||
<short_desc>READ ONLY: Motor inductance in henries.</short_desc>
|
||||
<long_desc>READ ONLY: Motor inductance in henries. This is measured on start-up.</long_desc>
|
||||
<unit>henries</unit>
|
||||
<decimal>3</decimal>
|
||||
</parameter>
|
||||
<parameter default="14" name="mot_num_poles" type="INT32">
|
||||
<short_desc>Number of motor poles.</short_desc>
|
||||
<long_desc>Number of motor poles. Used to convert mechanical speeds to
|
||||
electrical speeds. This number should be taken from the motor’s
|
||||
specification sheet.</long_desc>
|
||||
<unit>Poles</unit>
|
||||
<min>2</min>
|
||||
<max>40</max>
|
||||
</parameter>
|
||||
<parameter default="0.0" name="mot_rs" type="FLOAT">
|
||||
<short_desc>READ ONLY: Motor resistance in ohms</short_desc>
|
||||
<long_desc>READ ONLY: Motor resistance in ohms. This is measured on start-up. When
|
||||
tuning a new motor, check that this value is approximately equal
|
||||
to the value shown in the motor’s specification sheet.</long_desc>
|
||||
<unit>Ohms</unit>
|
||||
<decimal>3</decimal>
|
||||
</parameter>
|
||||
<parameter default="0.5" name="mot_v_accel" type="FLOAT">
|
||||
<short_desc>Acceleration limit (V)</short_desc>
|
||||
<long_desc>Acceleration limit (V)</long_desc>
|
||||
<unit>Volts</unit>
|
||||
<decimal>3</decimal>
|
||||
<min>0.01</min>
|
||||
<max>1.00</max>
|
||||
</parameter>
|
||||
<parameter default="14.8" name="mot_v_max" type="FLOAT">
|
||||
<short_desc>Motor voltage limit in volts</short_desc>
|
||||
<long_desc>Motor voltage limit in volts. The current controller’s
|
||||
commanded voltage will never exceed this value. Note that this may
|
||||
safely be above the nominal voltage of the motor; to determine the
|
||||
actual motor voltage limit, divide the motor’s rated power by the
|
||||
motor current limit.</long_desc>
|
||||
<unit>Volts</unit>
|
||||
<decimal>3</decimal>
|
||||
<min>0</min>
|
||||
</parameter>
|
||||
</group>
|
||||
</parameters>
|
||||
@@ -1 +0,0 @@
|
||||
This folder contains a python library used by px_process_params.py
|
||||
@@ -1 +0,0 @@
|
||||
__all__ = ["srcscanner", "srcparser", "xmlout", "dokuwikiout", "dokuwikirpc", "scope"]
|
||||
@@ -1,44 +0,0 @@
|
||||
from xml.sax.saxutils import escape
|
||||
import codecs
|
||||
|
||||
class DokuWikiTablesOutput():
|
||||
def __init__(self, groups):
|
||||
result = ("====== Parameter Reference ======\n"
|
||||
"<note>**This list is auto-generated from the source code** and contains the most recent parameter documentation.</note>\n"
|
||||
"\n")
|
||||
for group in groups:
|
||||
result += "==== %s ====\n\n" % group.GetName()
|
||||
result += "|< 100% 25% 45% 10% 10% 10% >|\n"
|
||||
result += "^ Name ^ Description ^ Min ^ Max ^ Default ^\n"
|
||||
result += "^ ::: ^ Comment ^^^^\n"
|
||||
for param in group.GetParams():
|
||||
code = param.GetName()
|
||||
def_val = param.GetDefault()
|
||||
name = param.GetFieldValue("short_desc")
|
||||
min_val = param.GetFieldValue("min")
|
||||
max_val = param.GetFieldValue("max")
|
||||
long_desc = param.GetFieldValue("long_desc")
|
||||
|
||||
if name == code:
|
||||
name = ""
|
||||
else:
|
||||
name = name.replace("\n", " ")
|
||||
name = name.replace("|", "%%|%%")
|
||||
name = name.replace("^", "%%^%%")
|
||||
|
||||
result += "| **%s** |" % code
|
||||
result += " %s |" % name
|
||||
result += " %s |" % (min_val or "")
|
||||
result += " %s |" % (max_val or "")
|
||||
result += " %s |" % (def_val or "")
|
||||
result += "\n"
|
||||
|
||||
if long_desc is not None:
|
||||
result += "| ::: | <div>%s</div> ||||\n" % long_desc
|
||||
|
||||
result += "\n"
|
||||
self.output = result;
|
||||
|
||||
def Save(self, filename):
|
||||
with codecs.open(filename, 'w', 'utf-8') as f:
|
||||
f.write(self.output)
|
||||
@@ -1,16 +0,0 @@
|
||||
try:
|
||||
import xmlrpclib
|
||||
except ImportError:
|
||||
import xmlrpc.client as xmlrpclib
|
||||
|
||||
# See https://www.dokuwiki.org/devel:xmlrpc for a list of available functions!
|
||||
# Usage example:
|
||||
# xmlrpc = dokuwikirpc.get_xmlrpc(url, username, password)
|
||||
# print(xmlrpc.dokuwiki.getVersion())
|
||||
|
||||
def get_xmlrpc(url, username, password):
|
||||
#proto, url = url.split("://")
|
||||
#url = proto + "://" + username + ":" + password + "@" + url + "/lib/exe/xmlrpc.php"
|
||||
url += "/lib/exe/xmlrpc.php?u=" + username + "&p=" + password
|
||||
|
||||
return xmlrpclib.ServerProxy(url)
|
||||
@@ -1,105 +0,0 @@
|
||||
from xml.sax.saxutils import escape
|
||||
import codecs
|
||||
|
||||
class MarkdownTablesOutput():
|
||||
def __init__(self, groups):
|
||||
result = ("# Parameter Reference\n"
|
||||
"> **Note** **This list is auto-generated from the source code** and contains the most recent parameter documentation.\n"
|
||||
"\n")
|
||||
for group in groups:
|
||||
result += '## %s\n\n' % group.GetName()
|
||||
|
||||
#Check if scope (module where parameter is defined) is the same for all parameters in the group.
|
||||
# If so then display just once about the table.
|
||||
scope_set = set()
|
||||
for param in group.GetParams():
|
||||
scope_set.add(param.GetFieldValue("scope"))
|
||||
if len(scope_set)==1:
|
||||
result+='\nThe module where these parameters are defined is: *%s*.\n\n' % list(scope_set)[0]
|
||||
|
||||
|
||||
result += '<table style="width: 100%; table-layout:fixed; font-size:1.5rem; overflow: auto; display:block;">\n'
|
||||
result += ' <colgroup><col style="width: 23%"><col style="width: 46%"><col style="width: 11%"><col style="width: 11%"><col style="width: 9%"></colgroup>\n'
|
||||
result += ' <thead>\n'
|
||||
result += ' <tr><th>Name</th><th>Description</th><th>Min > Max (Incr.)</th><th>Default</th><th>Units</th></tr>\n'
|
||||
result += ' </thead>\n'
|
||||
result += '<tbody>\n'
|
||||
|
||||
for param in group.GetParams():
|
||||
code = param.GetName()
|
||||
name = param.GetFieldValue("short_desc") or ''
|
||||
long_desc = param.GetFieldValue("long_desc") or ''
|
||||
min_val = param.GetFieldValue("min") or ''
|
||||
max_val = param.GetFieldValue("max") or ''
|
||||
increment = param.GetFieldValue("increment") or ''
|
||||
def_val = param.GetDefault() or ''
|
||||
unit = param.GetFieldValue("unit") or ''
|
||||
type = param.GetType()
|
||||
reboot_required = param.GetFieldValue("reboot_required") or ''
|
||||
#board = param.GetFieldValue("board") or '' ## Disabled as no board values are defined in any parameters!
|
||||
#decimal = param.GetFieldValue("decimal") or '' #Disabled as is intended for GCS not people
|
||||
#field_codes = param.GetFieldCodes() ## Disabled as not needed for display.
|
||||
#boolean = param.GetFieldValue("boolean") # or '' # Disabled - does not appear useful.
|
||||
|
||||
|
||||
# Format values for display.
|
||||
# Display min/max/increment value based on what values are defined.
|
||||
max_min_combined = ''
|
||||
if min_val or max_val:
|
||||
if not min_val:
|
||||
min_val='?'
|
||||
if not max_val:
|
||||
max_val='?'
|
||||
max_min_combined+='%s > %s ' % (min_val, max_val)
|
||||
if increment:
|
||||
max_min_combined+='(%s)' % increment
|
||||
|
||||
if long_desc is not '':
|
||||
long_desc = '<p><strong>Comment:</strong> %s</p>' % long_desc
|
||||
|
||||
if name == code:
|
||||
name = ""
|
||||
code='<strong id="%s">%s</strong>' % (code, code)
|
||||
|
||||
if reboot_required:
|
||||
reboot_required='<p><b>Reboot required:</b> %s</p>\n' % reboot_required
|
||||
|
||||
scope=''
|
||||
if not len(scope_set)==1 or len(scope_set)==0:
|
||||
scope = param.GetFieldValue("scope") or ''
|
||||
if scope:
|
||||
scope='<p><b>Module:</b> %s</p>\n' % scope
|
||||
|
||||
|
||||
enum_codes=param.GetEnumCodes() or '' # Gets numerical values for parameter.
|
||||
enum_output=''
|
||||
# Format codes and their descriptions for display.
|
||||
if enum_codes:
|
||||
enum_output+='<strong>Values:</strong><ul>'
|
||||
enum_codes=sorted(enum_codes,key=float)
|
||||
for item in enum_codes:
|
||||
enum_output+='\n<li><strong>%s:</strong> %s</li> \n' % (item, param.GetEnumValue(item))
|
||||
enum_output+='</ul>\n'
|
||||
|
||||
|
||||
bitmask_list=param.GetBitmaskList() #Gets bitmask values for parameter
|
||||
bitmask_output=''
|
||||
#Format bitmask values
|
||||
if bitmask_list:
|
||||
bitmask_output+='<strong>Bitmask:</strong><ul>'
|
||||
for bit in bitmask_list:
|
||||
bit_text = param.GetBitmaskBit(bit)
|
||||
bitmask_output+=' <li><strong>%s:</strong> %s</li> \n' % (bit, bit_text)
|
||||
bitmask_output+='</ul>\n'
|
||||
|
||||
|
||||
result += '<tr>\n <td style="vertical-align: top;">%s (%s)</td>\n <td style="vertical-align: top;"><p>%s</p>%s %s %s %s %s</td>\n <td style="vertical-align: top;">%s</td>\n <td style="vertical-align: top;">%s </td>\n <td style="vertical-align: top;">%s</td>\n</tr>\n' % (code,type,name, long_desc, enum_output, bitmask_output, reboot_required, scope, max_min_combined,def_val,unit)
|
||||
|
||||
#Close the table.
|
||||
result += '</tbody></table>\n\n'
|
||||
|
||||
self.output = result
|
||||
|
||||
def Save(self, filename):
|
||||
with codecs.open(filename, 'w', 'utf-8') as f:
|
||||
f.write(self.output)
|
||||
@@ -1,32 +0,0 @@
|
||||
import os
|
||||
import re
|
||||
|
||||
class Scope(object):
|
||||
"""
|
||||
Single parameter group
|
||||
"""
|
||||
re_deep_lines = re.compile(r'.*\/.*\/')
|
||||
def __init__(self,):
|
||||
self.scope = set()
|
||||
|
||||
|
||||
def __str__(self):
|
||||
return self.scope.__str__()
|
||||
|
||||
def Add(self, scope):
|
||||
"""
|
||||
Add Scope to set
|
||||
"""
|
||||
self.scope.add(scope)
|
||||
|
||||
def Has(self, scope):
|
||||
"""
|
||||
Check for existance
|
||||
"""
|
||||
if len(self.scope) == 0:
|
||||
return True
|
||||
# Anything in the form xxxxx/yyyyy/zzzzz....
|
||||
# is treated as xxxxx/yyyyy
|
||||
while (self.re_deep_lines.match(scope)):
|
||||
scope = os.path.dirname(scope)
|
||||
return scope in self.scope
|
||||
@@ -1,404 +0,0 @@
|
||||
import sys
|
||||
import re
|
||||
import math
|
||||
|
||||
global default_var
|
||||
default_var = {}
|
||||
|
||||
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 param: param.name)
|
||||
|
||||
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,
|
||||
"decimal": 2,
|
||||
# all others == 0 (sorted alphabetically)
|
||||
}
|
||||
|
||||
def __init__(self, name, type, default = ""):
|
||||
self.fields = {}
|
||||
self.values = {}
|
||||
self.bitmask = {}
|
||||
self.name = name
|
||||
self.type = type
|
||||
self.default = default
|
||||
self.volatile = "false"
|
||||
self.category = ""
|
||||
|
||||
def GetName(self):
|
||||
return self.name
|
||||
|
||||
def GetType(self):
|
||||
return self.type
|
||||
|
||||
def GetDefault(self):
|
||||
return self.default
|
||||
|
||||
def GetCategory(self):
|
||||
return self.category.title()
|
||||
|
||||
def GetVolatile(self):
|
||||
return self.volatile
|
||||
|
||||
def SetField(self, code, value):
|
||||
"""
|
||||
Set named field value
|
||||
"""
|
||||
self.fields[code] = value
|
||||
|
||||
def SetEnumValue(self, code, value):
|
||||
"""
|
||||
Set named enum value
|
||||
"""
|
||||
self.values[code] = value
|
||||
|
||||
def SetBitmaskBit(self, index, bit):
|
||||
"""
|
||||
Set named enum value
|
||||
"""
|
||||
self.bitmask[index] = bit
|
||||
|
||||
def SetVolatile(self):
|
||||
"""
|
||||
Set volatile flag
|
||||
"""
|
||||
self.volatile = "true"
|
||||
|
||||
def SetCategory(self, category):
|
||||
"""
|
||||
Set param category
|
||||
"""
|
||||
self.category = category
|
||||
|
||||
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 fv
|
||||
|
||||
def GetEnumCodes(self):
|
||||
"""
|
||||
Return list of existing value codes in convenient order
|
||||
"""
|
||||
return sorted(self.values.keys(), key=float)
|
||||
|
||||
def GetEnumValue(self, code):
|
||||
"""
|
||||
Return value of the given enum code or None if not found.
|
||||
"""
|
||||
fv = self.values.get(code)
|
||||
if not fv:
|
||||
# required because python 3 sorted does not accept None
|
||||
return ""
|
||||
return fv
|
||||
|
||||
def GetBitmaskList(self):
|
||||
"""
|
||||
Return list of existing bitmask codes in convenient order
|
||||
"""
|
||||
keys = self.bitmask.keys()
|
||||
return sorted(keys, key=float)
|
||||
|
||||
def GetBitmaskBit(self, index):
|
||||
"""
|
||||
Return value of the given bitmask code or None if not found.
|
||||
"""
|
||||
fv = self.bitmask.get(index)
|
||||
if not fv:
|
||||
# required because python 3 sorted does not accept None
|
||||
return ""
|
||||
return fv
|
||||
|
||||
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'^\/\*\*')
|
||||
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*\*\/')
|
||||
re_parameter_definition = re.compile(r'PARAM_DEFINE_([A-Z_][A-Z0-9_]*)\s*\(([A-Z_][A-Z0-9_]*)\s*,\s*([^ ,\)]+)\s*\)\s*;')
|
||||
re_px4_parameter_definition = re.compile(r'PX4_PARAM_DEFINE_([A-Z_][A-Z0-9_]*)\s*\(([A-Z_][A-Z0-9_]*)\s*\)\s*;')
|
||||
re_px4_param_default_definition = re.compile(r'#define\s*PARAM_([A-Z_][A-Z0-9_]*)\s*([^ ,\)]+)\s*')
|
||||
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(["group", "board", "min", "max", "unit", "decimal", "increment", "reboot_required", "value", "boolean", "bit", "category", "volatile"])
|
||||
|
||||
# Order of parameter groups
|
||||
priority = {
|
||||
# All other groups = 0 (sort alphabetically)
|
||||
"Miscellaneous": -10
|
||||
}
|
||||
|
||||
def __init__(self):
|
||||
self.param_groups = {}
|
||||
|
||||
def Parse(self, scope, contents):
|
||||
"""
|
||||
Incrementally parse program contents and append all found parameters
|
||||
to the list.
|
||||
"""
|
||||
# This code is essentially a comment-parsing grammar. "state"
|
||||
# represents parser state. It contains human-readable state
|
||||
# names.
|
||||
state = None
|
||||
for line in self.re_split_lines.split(contents):
|
||||
line = line.strip()
|
||||
# Ignore empty lines
|
||||
if line == "":
|
||||
continue
|
||||
if self.re_comment_start.match(line):
|
||||
state = "wait-short"
|
||||
short_desc = None
|
||||
long_desc = None
|
||||
tags = {}
|
||||
def_values = {}
|
||||
def_bitmask = {}
|
||||
elif 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 == "value"):
|
||||
# Take the meta info string and split the code and description
|
||||
metainfo = desc.split(" ", 1)
|
||||
def_values[metainfo[0]] = metainfo[1]
|
||||
elif (tag == "bit"):
|
||||
# Take the meta info string and split the code and description
|
||||
metainfo = desc.split(" ", 1)
|
||||
def_bitmask[metainfo[0]] = metainfo[1]
|
||||
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:
|
||||
tp = None
|
||||
name = None
|
||||
defval = ""
|
||||
# Non-empty line outside the comment
|
||||
m = self.re_px4_param_default_definition.match(line)
|
||||
# Default value handling
|
||||
if m:
|
||||
name_m, defval_m = m.group(1,2)
|
||||
default_var[name_m] = defval_m
|
||||
m = self.re_parameter_definition.match(line)
|
||||
if m:
|
||||
tp, name, defval = m.group(1, 2, 3)
|
||||
else:
|
||||
m = self.re_px4_parameter_definition.match(line)
|
||||
if m:
|
||||
tp, name = m.group(1, 2)
|
||||
if (name+'_DEFAULT') in default_var:
|
||||
defval = default_var[name+'_DEFAULT']
|
||||
if tp is not None:
|
||||
# Remove trailing type specifier from numbers: 0.1f => 0.1
|
||||
if defval != "" and self.re_is_a_number.match(defval):
|
||||
defval = self.re_cut_type_specifier.sub('', defval)
|
||||
param = Parameter(name, tp, defval)
|
||||
param.SetField("scope", scope)
|
||||
param.SetField("short_desc", name)
|
||||
# If comment was found before the parameter declaration,
|
||||
# inject its data into the newly created parameter.
|
||||
group = "Miscellaneous"
|
||||
if state == "comment-processed":
|
||||
if short_desc is not None:
|
||||
param.SetField("short_desc", self.re_remove_dots.sub('', short_desc))
|
||||
if long_desc is not None:
|
||||
long_desc = self.re_remove_carriage_return.sub(' ', long_desc)
|
||||
param.SetField("long_desc", long_desc)
|
||||
for tag in tags:
|
||||
if tag == "group":
|
||||
group = tags[tag]
|
||||
elif tag == "volatile":
|
||||
param.SetVolatile()
|
||||
elif tag == "category":
|
||||
param.SetCategory(tags[tag])
|
||||
elif tag not in self.valid_tags:
|
||||
sys.stderr.write("Skipping invalid documentation tag: '%s'\n" % tag)
|
||||
return False
|
||||
else:
|
||||
param.SetField(tag, tags[tag])
|
||||
for def_value in def_values:
|
||||
param.SetEnumValue(def_value, def_values[def_value])
|
||||
for def_bit in def_bitmask:
|
||||
param.SetBitmaskBit(def_bit, def_bitmask[def_bit])
|
||||
# Store the parameter
|
||||
if group not in self.param_groups:
|
||||
self.param_groups[group] = ParameterGroup(group)
|
||||
self.param_groups[group].AddParameter(param)
|
||||
state = None
|
||||
return True
|
||||
|
||||
def IsNumber(self, numberString):
|
||||
try:
|
||||
float(numberString)
|
||||
return True
|
||||
except ValueError:
|
||||
return False
|
||||
|
||||
def Validate(self):
|
||||
"""
|
||||
Validates the parameter meta data.
|
||||
"""
|
||||
seenParamNames = []
|
||||
for group in self.GetParamGroups():
|
||||
for param in group.GetParams():
|
||||
name = param.GetName()
|
||||
if len(name) > 16:
|
||||
sys.stderr.write("Parameter Name {0} is too long (Limit is 16)\n".format(name))
|
||||
return False
|
||||
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 default != "" and "." not in default:
|
||||
# sys.stderr.write("Default value does not contain dot (e.g. 10 needs to be written as 10.0): {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
|
||||
for code in param.GetEnumCodes():
|
||||
if not self.IsNumber(code):
|
||||
sys.stderr.write("Min value not number: {0} {1}\n".format(name, code))
|
||||
return False
|
||||
if param.GetEnumValue(code) == "":
|
||||
sys.stderr.write("Description for enum value is empty: {0} {1}\n".format(name, code))
|
||||
return False
|
||||
for index in param.GetBitmaskList():
|
||||
if not self.IsNumber(index):
|
||||
sys.stderr.write("bit value not number: {0} {1}\n".format(name, index))
|
||||
return False
|
||||
if not int(min) <= math.pow(2, int(index)) <= int(max):
|
||||
sys.stderr.write("Bitmask bit must be between {0} and {1}: {2} {3}\n".format(min, max, name, math.pow(2, int(index))))
|
||||
return False
|
||||
if param.GetBitmaskBit(index) == "":
|
||||
sys.stderr.write("Description for bitmask bit is empty: {0} {1}\n".format(name, index))
|
||||
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
|
||||
@@ -1,50 +0,0 @@
|
||||
import os
|
||||
import re
|
||||
import codecs
|
||||
import sys
|
||||
|
||||
class SourceScanner(object):
|
||||
"""
|
||||
Traverses directory tree, reads all source files, and passes their contents
|
||||
to the Parser.
|
||||
"""
|
||||
|
||||
def ScanDir(self, srcdirs, parser):
|
||||
"""
|
||||
Scans provided path and passes all found contents to the parser using
|
||||
parser.Parse method.
|
||||
"""
|
||||
extensions1 = tuple([".h"])
|
||||
extensions2 = tuple([".c"])
|
||||
for srcdir in srcdirs:
|
||||
for filename in os.listdir(srcdir):
|
||||
if filename.endswith(extensions1):
|
||||
path = os.path.join(srcdir, filename)
|
||||
if not self.ScanFile(path, parser):
|
||||
return False
|
||||
for filename in os.listdir(srcdir):
|
||||
if filename.endswith(extensions2):
|
||||
path = os.path.join(srcdir, 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.
|
||||
"""
|
||||
# Extract the scope: it is the directory within the repo. Either it
|
||||
# starts directly with 'src/module/abc', or it has the form 'x/y/z/src/module/abc'.
|
||||
# The output is 'module/abc' in both cases.
|
||||
prefix = "^(|.*" + os.path.sep + ")src" + os.path.sep
|
||||
scope = re.sub(prefix.replace("\\", "/"), "", os.path.dirname(os.path.relpath(path)).replace("\\", "/"))
|
||||
|
||||
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(scope, contents)
|
||||
@@ -1,82 +0,0 @@
|
||||
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, inject_xml_file_name):
|
||||
xml_parameters = ET.Element("parameters")
|
||||
xml_version = ET.SubElement(xml_parameters, "version")
|
||||
xml_version.text = "3"
|
||||
xml_version = ET.SubElement(xml_parameters, "parameter_version_major")
|
||||
xml_version.text = "1"
|
||||
xml_version = ET.SubElement(xml_parameters, "parameter_version_minor")
|
||||
xml_version.text = "15"
|
||||
importtree = ET.parse(inject_xml_file_name)
|
||||
injectgroups = importtree.getroot().findall("group")
|
||||
for igroup in injectgroups:
|
||||
xml_parameters.append(igroup)
|
||||
last_param_name = ""
|
||||
board_specific_param_set = False
|
||||
for group in groups:
|
||||
xml_group = ET.SubElement(xml_parameters, "group")
|
||||
xml_group.attrib["name"] = group.GetName()
|
||||
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, "parameter")
|
||||
xml_param.attrib["name"] = param.GetName()
|
||||
xml_param.attrib["default"] = param.GetDefault()
|
||||
xml_param.attrib["type"] = param.GetType()
|
||||
if (param.GetVolatile() == "true"):
|
||||
xml_param.attrib["volatile"] = param.GetVolatile()
|
||||
if (param.GetCategory()):
|
||||
xml_param.attrib["category"] = param.GetCategory()
|
||||
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
|
||||
if last_param_name != param.GetName():
|
||||
board_specific_param_set = False
|
||||
|
||||
if len(param.GetEnumCodes()) > 0:
|
||||
xml_values = ET.SubElement(xml_param, "values")
|
||||
for code in param.GetEnumCodes():
|
||||
xml_value = ET.SubElement(xml_values, "value")
|
||||
xml_value.attrib["code"] = code;
|
||||
xml_value.text = param.GetEnumValue(code)
|
||||
|
||||
if len(param.GetBitmaskList()) > 0:
|
||||
xml_values = ET.SubElement(xml_param, "bitmask")
|
||||
for index in param.GetBitmaskList():
|
||||
xml_value = ET.SubElement(xml_values, "bit")
|
||||
xml_value.attrib["index"] = index;
|
||||
xml_value.text = param.GetBitmaskBit(index)
|
||||
|
||||
indent(xml_parameters)
|
||||
self.xml_document = ET.ElementTree(xml_parameters)
|
||||
|
||||
def Save(self, filename):
|
||||
self.xml_document.write(filename, encoding="UTF-8")
|
||||
@@ -1,59 +0,0 @@
|
||||
#!/usr/bin/env python
|
||||
"""
|
||||
Param source code generation script.
|
||||
"""
|
||||
from __future__ import print_function
|
||||
import xml.etree.ElementTree as ET
|
||||
import codecs
|
||||
import argparse
|
||||
from jinja2 import Environment, FileSystemLoader
|
||||
import os
|
||||
|
||||
def generate(xml_file, dest='.'):
|
||||
"""
|
||||
Generate px4 param source from xml.
|
||||
|
||||
@param xml_file: input parameter xml file
|
||||
@param dest: Destination directory for generated files
|
||||
None means to scan everything.
|
||||
"""
|
||||
# pylint: disable=broad-except
|
||||
tree = ET.parse(xml_file)
|
||||
root = tree.getroot()
|
||||
|
||||
params = []
|
||||
for group in root:
|
||||
if group.tag == "group" and "no_code_generation" not in group.attrib:
|
||||
for param in group:
|
||||
params.append(param)
|
||||
|
||||
params = sorted(params, key=lambda name: name.attrib["name"])
|
||||
|
||||
script_path = os.path.dirname(os.path.realpath(__file__))
|
||||
|
||||
# for jinja docs see: http://jinja.pocoo.org/docs/2.9/api/
|
||||
env = Environment(
|
||||
loader=FileSystemLoader(os.path.join(script_path, 'templates')))
|
||||
|
||||
if not os.path.isdir(dest):
|
||||
os.path.mkdir(dest)
|
||||
|
||||
template_files = [
|
||||
'px4_parameters.h.jinja',
|
||||
'px4_parameters_public.h.jinja',
|
||||
'px4_parameters.c.jinja',
|
||||
]
|
||||
for template_file in template_files:
|
||||
template = env.get_template(template_file)
|
||||
with open(os.path.join(
|
||||
dest, template_file.replace('.jinja','')), 'w') as fid:
|
||||
fid.write(template.render(params=params))
|
||||
|
||||
if __name__ == "__main__":
|
||||
arg_parser = argparse.ArgumentParser()
|
||||
arg_parser.add_argument("--xml", help="parameter xml file")
|
||||
arg_parser.add_argument("--dest", help="destination path", default=os.path.curdir)
|
||||
args = arg_parser.parse_args()
|
||||
generate(xml_file=args.xml, dest=args.dest)
|
||||
|
||||
# vim: set et fenc=utf-8 ff=unix sts=4 sw=4 ts=4 :
|
||||
@@ -1,200 +0,0 @@
|
||||
#!/usr/bin/env python
|
||||
############################################################################
|
||||
#
|
||||
# Copyright (C) 2013-2017 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 paramers processor (main executable file)
|
||||
#
|
||||
# This tool scans the PX4 source code for declarations of tunable parameters
|
||||
# and outputs the list in various formats.
|
||||
#
|
||||
# Currently supported formats are:
|
||||
# * XML for the parametric UI generator
|
||||
# * Human-readable description in DokuWiki page format
|
||||
# * Human-readable description in Markdown page format for the PX4 dev guide
|
||||
#
|
||||
# This tool also allows to automatically upload the human-readable version
|
||||
# to the DokuWiki installation via XML-RPC.
|
||||
#
|
||||
|
||||
from __future__ import print_function
|
||||
import sys
|
||||
import os
|
||||
import argparse
|
||||
from px4params import srcscanner, srcparser, xmlout, dokuwikiout, dokuwikirpc, markdownout
|
||||
|
||||
import re
|
||||
import json
|
||||
import codecs
|
||||
|
||||
def main():
|
||||
# Parse command line arguments
|
||||
parser = argparse.ArgumentParser(description="Process parameter documentation.")
|
||||
parser.add_argument("-s", "--src-path",
|
||||
default=["../src"],
|
||||
metavar="PATH",
|
||||
nargs='*',
|
||||
help="one or more paths to source files to scan for parameters")
|
||||
parser.add_argument("-x", "--xml",
|
||||
nargs='?',
|
||||
const="parameters.xml",
|
||||
metavar="FILENAME",
|
||||
help="Create XML file"
|
||||
" (default FILENAME: parameters.xml)")
|
||||
parser.add_argument("-i", "--inject-xml",
|
||||
nargs='?',
|
||||
const="../Tools/parameters_injected.xml",
|
||||
metavar="FILENAME",
|
||||
help="Inject additional param XML file"
|
||||
" (default FILENAME: ../Tools/parameters_injected.xml)")
|
||||
parser.add_argument("-b", "--board",
|
||||
nargs='?',
|
||||
const="",
|
||||
metavar="BOARD",
|
||||
help="Board to create xml parameter xml for")
|
||||
parser.add_argument("-m", "--markdown",
|
||||
nargs='?',
|
||||
const="parameters.md",
|
||||
metavar="FILENAME",
|
||||
help="Create Markdown file"
|
||||
" (default FILENAME: parameters.md)")
|
||||
parser.add_argument("-w", "--wiki",
|
||||
nargs='?',
|
||||
const="parameters.wiki",
|
||||
metavar="FILENAME",
|
||||
help="Create DokuWiki file"
|
||||
" (default FILENAME: parameters.wiki)")
|
||||
parser.add_argument("-u", "--wiki-update",
|
||||
nargs='?',
|
||||
const="firmware:parameters",
|
||||
metavar="PAGENAME",
|
||||
help="Update DokuWiki page"
|
||||
" (default PAGENAME: firmware:parameters)")
|
||||
parser.add_argument("--wiki-url",
|
||||
default="https://pixhawk.org",
|
||||
metavar="URL",
|
||||
help="DokuWiki URL"
|
||||
" (default: https://pixhawk.org)")
|
||||
parser.add_argument("--wiki-user",
|
||||
default=os.environ.get('XMLRPCUSER', None),
|
||||
metavar="USERNAME",
|
||||
help="DokuWiki XML-RPC user name"
|
||||
" (default: $XMLRPCUSER environment variable)")
|
||||
parser.add_argument("--wiki-pass",
|
||||
default=os.environ.get('XMLRPCPASS', None),
|
||||
metavar="PASSWORD",
|
||||
help="DokuWiki XML-RPC user password"
|
||||
" (default: $XMLRPCUSER environment variable)")
|
||||
parser.add_argument("--wiki-summary",
|
||||
metavar="SUMMARY",
|
||||
default="Automagically updated parameter documentation from code.",
|
||||
help="DokuWiki page edit summary")
|
||||
parser.add_argument('-v', '--verbose',
|
||||
action='store_true',
|
||||
help="verbose output")
|
||||
parser.add_argument("-o", "--overrides",
|
||||
default="{}",
|
||||
metavar="OVERRIDES",
|
||||
help="a dict of overrides in the form of a json string")
|
||||
|
||||
args = parser.parse_args()
|
||||
|
||||
# Check for valid command
|
||||
if not (args.xml or args.wiki or args.wiki_update or args.markdown):
|
||||
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
|
||||
if (args.verbose):
|
||||
print("Scanning source path " + str(args.src_path))
|
||||
|
||||
if not scanner.ScanDir(args.src_path, parser):
|
||||
sys.exit(1)
|
||||
|
||||
if not parser.Validate():
|
||||
sys.exit(1)
|
||||
param_groups = parser.GetParamGroups()
|
||||
|
||||
if len(param_groups) == 0:
|
||||
print("Warning: no parameters found")
|
||||
|
||||
override_dict = json.loads(args.overrides)
|
||||
if len(override_dict.keys()) > 0:
|
||||
for group in param_groups:
|
||||
for param in group.GetParams():
|
||||
name = param.GetName()
|
||||
if name in override_dict.keys():
|
||||
val = str(override_dict[param.GetName()])
|
||||
param.default = val
|
||||
print("OVERRIDING {:s} to {:s}!!!!!".format(name, val))
|
||||
|
||||
# Output to XML file
|
||||
if args.xml:
|
||||
if args.verbose:
|
||||
print("Creating XML file " + args.xml)
|
||||
cur_dir = os.path.dirname(os.path.realpath(__file__))
|
||||
out = xmlout.XMLOutput(param_groups, args.board,
|
||||
os.path.join(cur_dir, args.inject_xml))
|
||||
out.Save(args.xml)
|
||||
|
||||
# Output to DokuWiki tables
|
||||
if args.wiki or args.wiki_update:
|
||||
out = dokuwikiout.DokuWikiTablesOutput(param_groups)
|
||||
if args.wiki:
|
||||
print("Creating wiki file " + args.wiki)
|
||||
out.Save(args.wiki)
|
||||
if args.wiki_update:
|
||||
if args.wiki_user and args.wiki_pass:
|
||||
print("Updating wiki page " + args.wiki_update)
|
||||
xmlrpc = dokuwikirpc.get_xmlrpc(args.wiki_url, args.wiki_user, args.wiki_pass)
|
||||
xmlrpc.wiki.putPage(args.wiki_update, out.output, {'sum': args.wiki_summary})
|
||||
else:
|
||||
print("Error: You need to specify DokuWiki XML-RPC username and password!")
|
||||
|
||||
# Output to Markdown/HTML tables
|
||||
if args.markdown:
|
||||
out = markdownout.MarkdownTablesOutput(param_groups)
|
||||
if args.markdown:
|
||||
print("Creating markdown file " + args.markdown)
|
||||
out.Save(args.markdown)
|
||||
|
||||
#print("All done!")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -1,38 +0,0 @@
|
||||
{# jinja syntax: http://jinja.pocoo.org/docs/2.9/templates/ #}
|
||||
#include <px4_parameters.h>
|
||||
|
||||
// DO NOT EDIT
|
||||
// This file is autogenerated from paramaters.xml
|
||||
|
||||
__BEGIN_DECLS
|
||||
|
||||
const
|
||||
#ifndef __PX4_DARWIN
|
||||
__attribute__((used, section("__param")))
|
||||
#endif
|
||||
|
||||
struct px4_parameters_t px4_parameters = {
|
||||
{% for param in params %}
|
||||
{
|
||||
"{{ param.attrib["name"] }}",
|
||||
PARAM_TYPE_{{ param.attrib["type"] }},
|
||||
{%- if param.attrib["volatile"] == "true" %}
|
||||
.volatile_param = 1,
|
||||
{%- else %}
|
||||
.volatile_param = 0,
|
||||
{%- endif %}
|
||||
{%- if param.attrib["type"] == "FLOAT" %}
|
||||
.val.f = {{ param.attrib["default"] }}
|
||||
{%- elif param.attrib["type"] == "INT32" %}
|
||||
.val.i = {{ param.attrib["default"] }}
|
||||
{%- endif %}
|
||||
},
|
||||
{% endfor %}
|
||||
{{ params | length }}
|
||||
};
|
||||
|
||||
//extern const struct px4_parameters_t px4_parameters;
|
||||
|
||||
__END_DECLS
|
||||
|
||||
{# vim: set noet ft=jinja fenc=utf-8 ff=unix sts=4 sw=4 ts=4 : #}
|
||||
@@ -1,21 +0,0 @@
|
||||
{# jinja syntax: http://jinja.pocoo.org/docs/2.9/templates/ #}
|
||||
#include <stdint.h>
|
||||
#include <systemlib/param/param.h>
|
||||
|
||||
// DO NOT EDIT
|
||||
// This file is autogenerated from parameters.xml
|
||||
|
||||
__BEGIN_DECLS
|
||||
|
||||
struct px4_parameters_t {
|
||||
{%- for param in params %}
|
||||
const struct param_info_s __param__{{ param.attrib["name"] }};
|
||||
{%- endfor %}
|
||||
const unsigned int param_count;
|
||||
};
|
||||
|
||||
extern const struct px4_parameters_t px4_parameters;
|
||||
|
||||
__END_DECLS
|
||||
|
||||
{# vim: set noet ft=jinja fenc=utf-8 ff=unix sts=4 sw=4 ts=4 : #}
|
||||
@@ -1,37 +0,0 @@
|
||||
{# jinja syntax: http://jinja.pocoo.org/docs/2.9/templates/ #}
|
||||
#include <stdint.h>
|
||||
#include <systemlib/param/param.h>
|
||||
|
||||
// DO NOT EDIT
|
||||
// This file is autogenerated from parameters.xml
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
|
||||
namespace px4 { {# wrap the enum in a namespace, otherwise we get shadowing errors for MAV_TYPE #}
|
||||
|
||||
/// Enum with all parameters
|
||||
enum class params {
|
||||
{# enums are guaranteed to start with 0 (if the value for the first is not
|
||||
specified), and then incremented by 1 (the implementation depends on that!) #}
|
||||
{%- for param in params %}
|
||||
{{ param.attrib["name"] }},
|
||||
{%- endfor %}
|
||||
|
||||
_COUNT
|
||||
};
|
||||
|
||||
// All parameter types
|
||||
{# (px4_parameters is marked as extern, so we cannot use it as constexpr) #}
|
||||
static const constexpr int param_types_array[] = {
|
||||
{%- for param in params %}
|
||||
PARAM_TYPE_{{ param.attrib["type"] }}, // {{ param.attrib["name"] }}
|
||||
{%- endfor %}
|
||||
};
|
||||
|
||||
|
||||
} // namespace px4
|
||||
|
||||
|
||||
#endif /* __cplusplus */
|
||||
|
||||
Reference in New Issue
Block a user