From ee312d7542777d63128c215837d8d589523f609b Mon Sep 17 00:00:00 2001 From: henrykotze Date: Wed, 29 Nov 2023 15:10:56 +0200 Subject: [PATCH] windsensor driver: ft7_technologies copied paste along with formatting change Some cleanup of driver Some formatting and more debugging info year updates, remove private vars, rm CMakeList naming updates deleted files removed unnecessary parameters improved naming Resolved documentation workflow issue uorb topic name: sensor_wind -> sensor_airflow log sensor_airflow optionally --- msg/CMakeLists.txt | 1 + msg/SensorAirflow.msg | 5 + src/drivers/wind_sensor/Kconfig | 10 + .../ft_technologies/CMakeLists.txt | 46 +++ .../wind_sensor/ft_technologies/Kconfig | 5 + .../ft_technologies/ft7_technologies.cpp | 359 ++++++++++++++++++ .../ft_technologies/ft7_technologies.hpp | 102 +++++ .../ft_technologies/ft7_technologies_main.cpp | 162 ++++++++ .../wind_sensor/ft_technologies/module.yaml | 6 + src/modules/logger/logged_topics.cpp | 1 + 10 files changed, 697 insertions(+) create mode 100644 msg/SensorAirflow.msg create mode 100644 src/drivers/wind_sensor/Kconfig create mode 100644 src/drivers/wind_sensor/ft_technologies/CMakeLists.txt create mode 100644 src/drivers/wind_sensor/ft_technologies/Kconfig create mode 100644 src/drivers/wind_sensor/ft_technologies/ft7_technologies.cpp create mode 100644 src/drivers/wind_sensor/ft_technologies/ft7_technologies.hpp create mode 100644 src/drivers/wind_sensor/ft_technologies/ft7_technologies_main.cpp create mode 100644 src/drivers/wind_sensor/ft_technologies/module.yaml diff --git a/msg/CMakeLists.txt b/msg/CMakeLists.txt index e2cf0889791d..cf37ec339f22 100644 --- a/msg/CMakeLists.txt +++ b/msg/CMakeLists.txt @@ -182,6 +182,7 @@ set(msg_files SensorsStatus.msg SensorsStatusImu.msg SensorUwb.msg + SensorAirflow.msg SystemPower.msg TakeoffStatus.msg TaskStackInfo.msg diff --git a/msg/SensorAirflow.msg b/msg/SensorAirflow.msg new file mode 100644 index 000000000000..dd55ad0b0c70 --- /dev/null +++ b/msg/SensorAirflow.msg @@ -0,0 +1,5 @@ +uint64 timestamp # time since system start (microseconds) +uint32 device_id # unique device ID for the sensor that does not change between power cycles +float32 speed # the speed being reported by the wind / airflow sensor +float32 direction # the direction bein report by the wind / airflow sensor +uint8 status # Status code from the sensor diff --git a/src/drivers/wind_sensor/Kconfig b/src/drivers/wind_sensor/Kconfig new file mode 100644 index 000000000000..128e91491d94 --- /dev/null +++ b/src/drivers/wind_sensor/Kconfig @@ -0,0 +1,10 @@ +menu "Wind Sensors" + menuconfig COMMON_WIND_SENSOR + bool "Common wind sensor's" + default n + select DRIVERS_WIND_SENSOR_FT_TECHNOLOGIES + ---help--- + Enable default set of wind sensor drivers + + rsource "*/Kconfig" +endmenu diff --git a/src/drivers/wind_sensor/ft_technologies/CMakeLists.txt b/src/drivers/wind_sensor/ft_technologies/CMakeLists.txt new file mode 100644 index 000000000000..5f9d9c2d63d7 --- /dev/null +++ b/src/drivers/wind_sensor/ft_technologies/CMakeLists.txt @@ -0,0 +1,46 @@ +############################################################################ +# +# Copyright (c) 2023 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_add_module( + MODULE drivers__wind_sensor__ft_technologies + MAIN ft7_technologies + COMPILE_FLAGS + -Wno-cast-align # TODO: fix and enable + SRCS + ft7_technologies.cpp + ft7_technologies.hpp + ft7_technologies_main.cpp + DEPENDS + px4_work_queue + MODULE_CONFIG + module.yaml + ) diff --git a/src/drivers/wind_sensor/ft_technologies/Kconfig b/src/drivers/wind_sensor/ft_technologies/Kconfig new file mode 100644 index 000000000000..fa3f186952fc --- /dev/null +++ b/src/drivers/wind_sensor/ft_technologies/Kconfig @@ -0,0 +1,5 @@ +menuconfig DRIVERS_WIND_SENSOR_FT_TECHNOLOGIES + bool "ft7_technologies" + default n + ---help--- + Enable support for ft7_technologies diff --git a/src/drivers/wind_sensor/ft_technologies/ft7_technologies.cpp b/src/drivers/wind_sensor/ft_technologies/ft7_technologies.cpp new file mode 100644 index 000000000000..43f74c50ad66 --- /dev/null +++ b/src/drivers/wind_sensor/ft_technologies/ft7_technologies.cpp @@ -0,0 +1,359 @@ +/**************************************************************************** + * + * Copyright (c) 2023 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. + * + ****************************************************************************/ + +#include "ft7_technologies.hpp" + +#include +#include +#include +#include + +Ft7Technologies::Ft7Technologies(const char *port) : + ScheduledWorkItem(MODULE_NAME, px4::serial_port_to_wq(port)), + _sample_perf(perf_alloc(PC_ELAPSED, MODULE_NAME": read")), + _comms_errors(perf_alloc(PC_COUNT, MODULE_NAME": com_err")) +{ + /* store port name */ + strncpy(_port, port, sizeof(_port) - 1); + + /* enforce null termination */ + _port[sizeof(_port) - 1] = '\0'; + + _sensor_airflow_pub.advertise(); +} + +Ft7Technologies::~Ft7Technologies() +{ + stop(); + + perf_free(_sample_perf); + perf_free(_comms_errors); +} + +int +Ft7Technologies::init() +{ + _interval = 1e6 / 10; // 10 Hz, The maximum query frequency is 10Hz + start(); + + return PX4_OK; +} + +int Ft7Technologies::measure() +{ + // Send the command to begin a measurement. + const char cmd[] = {'$', '/', '/', ',', 'W', 'V', '?', '*', '/', '/', '\r', '\n', '\0'}; + int ret = ::write(_fd, cmd, 12); + + perf_begin(_sample_perf); + + if (ret != 12) { + perf_count(_comms_errors); + return ret; + } + + _last_measure = hrt_absolute_time(); + + return PX4_OK; +} + +uint8_t Ft7Technologies::hex2int(char ch) +{ + if (ch >= '0' && ch <= '9') { + return ch - '0'; + } + + if (ch >= 'A' && ch <= 'F') { + return ch - 'A' + 10; + } + + if (ch >= 'a' && ch <= 'f') { + return ch - 'a' + 10; + } + + return -1; +} + +bool Ft7Technologies::checksum(char *buf, uint32_t checksum) +{ + + uint32_t checksum_verify = 0; + + for (int i = 0; i < _byte_counter; i++) { + + if (!(buf[i] == '$' || buf[i] == '*')) { + checksum_verify ^= buf[i]; + } + + if (buf[i] == '*') { + i = _byte_counter; + } + } + + return checksum_verify == checksum; +} + +int Ft7Technologies::collect() +{ + // PX4_INFO("collect"); + + /* clear buffer if last read was too long ago */ + // int64_t read_elapsed = hrt_elapsed_time(&_last_read); + + /* the buffer for read chars is buflen minus null termination */ + char readbuf[sizeof(_linebuf)]; + unsigned readlen = sizeof(readbuf) - 1; + + /* read from the sensor (uart buffer) */ + // const hrt_abstime timestamp_sample = hrt_absolute_time(); + + int ret = ::read(_fd, readbuf, readlen); + + // PX4_INFO("collect() ret: %d \n", ret); + + if (ret < 0) { + // PX4_INFO("read err: %d", ret); + return -EAGAIN; + + } else if (ret == 0) { + perf_count(_comms_errors); + return -EAGAIN; + } + + _last_read = hrt_absolute_time(); + + bool valid = false; + + //$,WVP=,,* + for (int i = 0; i < ret; i++) { + // _px4_windsensor.update(timestamp_sample, (double)ret, 13.0f, _status); + // received a full message + _readbuf[_byte_counter] = readbuf[i]; + _byte_counter += 1; + + + if (readbuf[i] == '\n') { + + _checksum = (uint32_t)atoi((char *)_raw_checksum); + _hex_checksum = 0; + + sensor_airflow_s sensor_airflow{}; + sensor_airflow.timestamp = hrt_absolute_time(); + sensor_airflow.speed = (float)atoi((char *)_raw_speed) / 10.0f; + sensor_airflow.direction = ((float)atoi((char *)_raw_angle) - 180.0f) * M_PI_F / 180.0f; + sensor_airflow.status = (uint8_t)atoi((char *)_raw_status); + + if (_checksum_counter == 2) { + _hex_checksum = hex2int(_raw_checksum[0]) << 4 | hex2int(_raw_checksum[1]); + + } else { + _hex_checksum = hex2int(_raw_checksum[0]); + } + + // checksum is verified + if (checksum(_readbuf, _hex_checksum)) { + + _sensor_airflow_pub.publish(sensor_airflow); + valid = true; + + } + + // reset counters + _msg_part_counter = 0; + _byte_counter = 0; + _msg_byte_counter = 0; + _checksum_counter = 0; + memset(readbuf, 0, sizeof(_linebuf)); + memset(_readbuf, 0, sizeof(_linebuf)); + memset(_raw_speed, 0, 5); + memset(_raw_angle, 0, 5); + memset(_raw_status, 0, 2); + memset(_raw_checksum, 0, 3); + + } + + else if (readbuf[i] == '$' || readbuf[i] == ',' || readbuf[i] == '=' || readbuf[i] == '*' || readbuf[i] == '\r') { + _msg_part_counter += 1; + _msg_byte_counter = 0; + + } else { + + if (readbuf[i] != '.') { + + if (_msg_part_counter == 3) { // speed measurement + _raw_speed[_msg_byte_counter] = readbuf[i]; + + } else if (_msg_part_counter == 4) { // angle measurement + _raw_angle[_msg_byte_counter] = readbuf[i]; + + } else if (_msg_part_counter == 5) { // status + _raw_status[_msg_byte_counter] = readbuf[i]; + + } else if (_msg_part_counter == 6) { // checksum + _checksum_counter += 1; + _raw_checksum[_msg_byte_counter] = readbuf[i]; + + } + + _msg_byte_counter += 1; + + } + + } + + } + + if (!valid) { + return -EAGAIN; + } + + perf_end(_sample_perf); + return PX4_OK; +} + +void Ft7Technologies::start() +{ + /* reset the report ring and state machine */ + _collect_phase = false; + + /* schedule a cycle to start things */ + ScheduleNow(); +} + +void Ft7Technologies::stop() +{ + ScheduleClear(); +} + +void Ft7Technologies::Run() +{ + + /* fds initialized? */ + if (_fd < 0) { + /* open fd */ + _fd = ::open(_port, O_RDWR | O_NOCTTY | O_NONBLOCK); + + if (_fd < 0) { + PX4_ERR("open failed (%i)", errno); + return; + } + + struct termios uart_config; + + int termios_state; + + /* fill the struct for the new configuration */ + tcgetattr(_fd, &uart_config); + + /* clear ONLCR flag (which appends a CR for every LF) */ + // uart_config.c_oflag &= ~ONLCR; + uart_config.c_iflag &= ~(IGNBRK | BRKINT | ICRNL | INLCR | PARMRK | INPCK | ISTRIP | IXON); + + /* no parity, one stop bit */ + uart_config.c_oflag &= ~(OCRNL | ONLCR | ONLRET | ONOCR | OFILL | OPOST); + + // No line processing: + // echo off, echo newline off, canonical mode off, + // extended input processing off, signal chars off + uart_config.c_lflag &= ~(ECHO | ECHONL | ICANON | IEXTEN | ISIG); + + // Turn off character processing + // clear current char size mask, no parity checking, + // no output processing, force 8 bit input + uart_config.c_cflag &= ~(CSIZE | PARENB); + + uart_config.c_cflag |= CS8; + + unsigned speed = B9600; + + /* set baud rate */ + if ((termios_state = cfsetispeed(&uart_config, speed)) < 0) { + PX4_ERR("CFG: %d ISPD", termios_state); + } + + if ((termios_state = cfsetospeed(&uart_config, speed)) < 0) { + PX4_ERR("CFG: %d OSPD", termios_state); + } + + if ((termios_state = tcsetattr(_fd, TCSANOW, &uart_config)) < 0) { + PX4_ERR("baud %d ATTR", termios_state); + } + + } + + /* collection phase? */ + if (_collect_phase) { + + /* perform collection */ + int collect_ret = collect(); + + if (collect_ret == -EAGAIN) { + + if (hrt_elapsed_time(&_last_measure) > (_interval * 15) / 10) { + // resend the command again + // we waited to long to receive a response from the sensor + // so we are resending the command again + _collect_phase = false; + } + + ScheduleNow(); + return; + // we received a valid response from the sensor. we need to + // send another command through + + } else if (collect_ret == PX4_OK) { + + /* next phase is measurement */ + _collect_phase = false; + } + + } + + /* measurement phase */ + if (OK != measure()) { + PX4_INFO("measure error"); + } + + /* next phase is collection */ + _collect_phase = true; + + /* schedule a fresh cycle call when the measurement is done */ + ScheduleDelayed(_interval); +} + +void Ft7Technologies::print_info() +{ + PX4_INFO_RAW("%s: port: %s\n", MODULE_NAME, _port); + perf_print_counter(_sample_perf); + perf_print_counter(_comms_errors); +} diff --git a/src/drivers/wind_sensor/ft_technologies/ft7_technologies.hpp b/src/drivers/wind_sensor/ft_technologies/ft7_technologies.hpp new file mode 100644 index 000000000000..816942797347 --- /dev/null +++ b/src/drivers/wind_sensor/ft_technologies/ft7_technologies.hpp @@ -0,0 +1,102 @@ +/**************************************************************************** + * + * Copyright (c) 2023 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 ft7_technolofies.hpp + * @author Henry Kotze + * + * Driver for the FT Technology Wind Sensor. FT742 + */ + +#pragma once + +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +using namespace time_literals; + + +class Ft7Technologies : public px4::ScheduledWorkItem +{ +public: + Ft7Technologies(const char *port); + ~Ft7Technologies() override; + + int init(); + void print_info(); + +private: + + void start(); + void stop(); + void Run() override; + int measure(); + int collect(); + bool checksum(char *buf, uint32_t checksum); + uint8_t hex2int(char ch); + + uORB::Publication _sensor_airflow_pub{ORB_ID(sensor_airflow)}; + + char _port[20] {}; + char _readbuf[30] {}; + uint64_t _interval{100000}; + bool _collect_phase{false}; + int _fd{-1}; + char _linebuf[20] {}; + hrt_abstime _last_read{0}; + hrt_abstime _last_measure{0}; + + char _raw_angle[5]; + char _raw_speed[5]; + char _raw_status[2]; + char _raw_checksum[3]; + + uint16_t _checksum{0}; + uint32_t _hex_checksum{0}; + int _msg_part_counter{0}; + int _byte_counter{0}; + int _msg_byte_counter{0}; + uint32_t _checksum_counter{0}; + + perf_counter_t _sample_perf; + perf_counter_t _comms_errors; + +}; diff --git a/src/drivers/wind_sensor/ft_technologies/ft7_technologies_main.cpp b/src/drivers/wind_sensor/ft_technologies/ft7_technologies_main.cpp new file mode 100644 index 000000000000..85ec29b182ec --- /dev/null +++ b/src/drivers/wind_sensor/ft_technologies/ft7_technologies_main.cpp @@ -0,0 +1,162 @@ +/**************************************************************************** + * + * Copyright (c) 2023 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. + * + ****************************************************************************/ + +#include "ft7_technologies.hpp" + +#include +#include + +namespace ft7_technologies_wind_sensor +{ + +Ft7Technologies *g_dev{nullptr}; + +static int start(const char *port) +{ + if (g_dev != nullptr) { + PX4_WARN("already started"); + return -1; + } + + if (port == nullptr) { + PX4_ERR("no device specified"); + return -1; + } + + /* create the driver */ + g_dev = new Ft7Technologies(port); + PX4_INFO("port name: %s", port); + + if (g_dev == nullptr) { + return -1; + } + + if (g_dev->init() != PX4_OK) { + delete g_dev; + g_dev = nullptr; + return -1; + } + + return 0; +} + +static int stop() +{ + if (g_dev != nullptr) { + delete g_dev; + g_dev = nullptr; + + } else { + return -1; + } + + return 0; +} + +static int status() +{ + if (g_dev == nullptr) { + PX4_ERR("driver not running"); + return -1; + } + + g_dev->print_info(); + + return 0; +} + +static int usage() +{ + PRINT_MODULE_DESCRIPTION( + R"DESCR_STR( +### Description + +Serial bus driver for the FT Technologies Digital Wind Sensor FT742. This driver is required to operate alongside +a RS485 to UART signal transfer module. + +Most boards are configured to enable/start the driver on a specified UART using the SENS_FTX_CFG parameter. + +### Examples + +Attempt to start driver on a specified serial device. +$ ft_technologies_serial start -d /dev/ttyS1 +Stop driver +$ ft_technologies_serial stop +)DESCR_STR"); + + PRINT_MODULE_USAGE_NAME("ft_technologies_serial", "driver"); + PRINT_MODULE_USAGE_COMMAND_DESCR("start", "Start driver"); + PRINT_MODULE_USAGE_PARAM_STRING('d', nullptr, nullptr, "Serial device", false); + PRINT_MODULE_USAGE_COMMAND_DESCR("stop", "Stop driver"); + return PX4_OK; +} + +} // namespace + +extern "C" __EXPORT int ft7_technologies_main(int argc, char *argv[]) +{ + const char *device_path = nullptr; + int ch; + int myoptind = 1; + const char *myoptarg = nullptr; + + while ((ch = px4_getopt(argc, argv, "d:", &myoptind, &myoptarg)) != EOF) { + switch (ch) { + case 'd': + device_path = myoptarg; + break; + + default: + ft7_technologies_wind_sensor::usage(); + return -1; + } + } + + if (myoptind >= argc) { + ft7_technologies_wind_sensor::usage(); + return -1; + } + + if (!strcmp(argv[myoptind], "start")) { + return ft7_technologies_wind_sensor::start(device_path); + + } else if (!strcmp(argv[myoptind], "stop")) { + return ft7_technologies_wind_sensor::stop(); + + } else if (!strcmp(argv[myoptind], "status")) { + return ft7_technologies_wind_sensor::status(); + } + + ft7_technologies_wind_sensor::usage(); + return -1; +} diff --git a/src/drivers/wind_sensor/ft_technologies/module.yaml b/src/drivers/wind_sensor/ft_technologies/module.yaml new file mode 100644 index 000000000000..4ff7dd05f74e --- /dev/null +++ b/src/drivers/wind_sensor/ft_technologies/module.yaml @@ -0,0 +1,6 @@ +module_name: FT Technologies Digital Wind Sensor (serial) +serial_config: + - command: ft7_technologies start -d ${SERIAL_DEV} + port_config_param: + name: SENS_FTX_CFG + group: Sensors diff --git a/src/modules/logger/logged_topics.cpp b/src/modules/logger/logged_topics.cpp index e9f3c3004a37..4e97ebbbfaed 100644 --- a/src/modules/logger/logged_topics.cpp +++ b/src/modules/logger/logged_topics.cpp @@ -97,6 +97,7 @@ void LoggedTopics::add_default_topics() add_optional_topic("px4io_status"); add_topic("radio_status"); add_topic("rtl_time_estimate", 1000); + add_optional_topic("sensor_airflow", 100); add_topic("sensor_combined"); add_optional_topic("sensor_correction"); add_optional_topic("sensor_gyro_fft", 50);