T4 pb 12150

.github/workflows/sync-upstream.yaml

@@ -0,0 +1,28 @@
+name: sync-upstream
+
+on:
+  schedule:
+    - cron: 0 0 * * *
+  workflow_dispatch:
+
+jobs:
+  sync-upstream:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Generate token
+        id: generate-token
+        uses: tibdex/github-app-token@v1
+        with:
+          app_id: ${{ secrets.APP_ID }}
+          private_key: ${{ secrets.PRIVATE_KEY }}
+
+      - name: Run sync-branches
+        uses: autowarefoundation/autoware-github-actions/sync-branches@v1
+        with:
+          token: ${{ steps.generate-token.outputs.token }}
+          base-branch: tier4/main
+          sync-pr-branch: sync-upstream
+          sync-target-repository: https://github.com/autowarefoundation/autoware.universe.git
+          sync-target-branch: main
+          pr-title: "chore: sync upstream"
+          auto-merge-method: merge

perception/image_projection_based_fusion/launch/roi_cluster_fusion.launch.xml

@@ -24,6 +24,7 @@
 
   <!-- debug -->
   <arg name="debug_mode" default="false"/>
+
   <arg name="filter_scope_minx" default="-100"/>
   <arg name="filter_scope_maxx" default="100"/>
   <arg name="filter_scope_miny" default="-100"/>

system/system_monitor/CMakeLists.txt

@@ -62,10 +62,26 @@ else()
   endif()
 endif()
 
+if(CMAKE_ECU_PLATFORM STREQUAL "adlink")
+  set(CMAKE_ECU_PLATFORM "adlink")
+else()
+  set(CMAKE_ECU_PLATFORM "unknown")
+endif()
+
 message(STATUS "HOST_SYSTEM_VERSION: " ${CMAKE_HOST_SYSTEM_VERSION})
 message(STATUS "SYSTEM_PROCESSOR: " ${CMAKE_SYSTEM_PROCESSOR})
 message(STATUS "CPU PLATFORM: " ${CMAKE_CPU_PLATFORM})
 message(STATUS "GPU PLATFORM: " ${CMAKE_GPU_PLATFORM})
+message(STATUS "ECU PLATFORM: " ${CMAKE_ECU_PLATFORM})
+
+set(ECU_MONITOR_SOURCE
+  src/ecu_monitor/ecu_monitor_base.cpp
+  src/ecu_monitor/${CMAKE_ECU_PLATFORM}_ecu_monitor.cpp
+)
+
+ament_auto_add_library(ecu_monitor_lib SHARED
+  ${ECU_MONITOR_SOURCE}
+)
 
 set(CPU_MONITOR_SOURCE
   src/cpu_monitor/cpu_monitor_base.cpp
@@ -129,6 +145,7 @@ find_package(Boost REQUIRED COMPONENTS
 )
 
 ## Specify libraries to link a library or executable target against
+target_link_libraries(ecu_monitor_lib ${Boost_LIBRARIES} ${LIBRARIES})
 target_link_libraries(cpu_monitor_lib ${Boost_LIBRARIES} ${LIBRARIES})
 target_link_libraries(hdd_monitor_lib ${Boost_LIBRARIES} ${LIBRARIES})
 target_link_libraries(mem_monitor_lib ${LIBRARIES})
@@ -175,6 +192,11 @@ rclcpp_components_register_node(gpu_monitor_lib
   EXECUTABLE gpu_monitor
 )
 
+rclcpp_components_register_node(ecu_monitor_lib
+  PLUGIN "ECUMonitor"
+  EXECUTABLE ecu_monitor
+)
+
 # TODO(yunus.caliskan): Port the tests to ROS2, robustify the tests.
 if(BUILD_TESTING)
   # ament_add_ros_isolated_gtest(test_cpu_monitor
@@ -293,6 +315,10 @@ if(BUILD_TESTING)
 
 endif()
 
+#############
+## Install ##
+#############
+
 ament_auto_package(INSTALL_TO_SHARE
   launch
   config

system/system_monitor/include/system_monitor/ecu_monitor/adlink_ecu_monitor.hpp

@@ -0,0 +1,50 @@
+// Copyright 2020 Tier IV, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+/**
+ * @file adlink_ecu_monitor.h
+ * @brief  ECU monitor class
+ */
+
+#ifndef SYSTEM_MONITOR__ECU_MONITOR__ADLINK_ECU_MONITOR_HPP_
+#define SYSTEM_MONITOR__ECU_MONITOR__ADLINK_ECU_MONITOR_HPP_
+
+#include "system_monitor/ecu_monitor/ecu_monitor_base.hpp"
+
+#include <string>
+
+class ECUMonitor : public ECUMonitorBase
+{
+public:
+  /**
+   * @brief constructor
+   * @param [in] options Options associated with this node.
+   */
+  explicit ECUMonitor(const rclcpp::NodeOptions & options);
+
+protected:
+  /**
+   * @brief check ECU thermal throttling
+   * @param [out] stat diagnostic message passed directly to diagnostic publish calls
+   * @note NOLINT syntax is needed since diagnostic_updater asks for a non-const reference
+   * to pass diagnostic message updated in this function to diagnostic publish calls.
+   */
+  void checkVoltage(
+    diagnostic_updater::DiagnosticStatusWrapper & stat);  // NOLINT(runtime/references)
+  bool sensors_exists_;                      //!< @brief flag if sensors exists
+  float voltage_warn_;
+  float voltage_error_;
+};
+
+#endif  // SYSTEM_MONITOR__ECU_MONITOR__ADLINK_ECU_MONITOR_HPP_

system/system_monitor/include/system_monitor/ecu_monitor/ecu_monitor_base.hpp

@@ -0,0 +1,53 @@
+// Copyright 2020 Tier IV, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+/**
+ * @file ecu_monitor_base.h
+ * @brief ECU monitor base class
+ */
+
+#ifndef SYSTEM_MONITOR__ECU_MONITOR__ECU_MONITOR_BASE_HPP_
+#define SYSTEM_MONITOR__MONITOR__ECU_MONITOR_BASE_HPP_
+
+#include <diagnostic_updater/diagnostic_updater.hpp>
+
+#include <climits>
+#include <map>
+#include <string>
+#include <vector>
+
+class ECUMonitorBase : public rclcpp::Node
+{
+public:
+  /**
+   * @brief Update the diagnostic state.
+   */
+  void update();
+
+protected:
+  using DiagStatus = diagnostic_msgs::msg::DiagnosticStatus;
+
+  /**
+   * @brief constructor
+   * @param [in] node_name Name of the node.
+   * @param [in] options Options associated with this node.
+   */
+  ECUMonitorBase(const std::string & node_name, const rclcpp::NodeOptions & options);
+
+  diagnostic_updater::Updater updater_;  //!< @brief Updater class which advertises to /diagnostics
+
+  char hostname_[HOST_NAME_MAX + 1];        //!< @brief host name
+};
+
+#endif  // SYSTEM_MONITOR_ECU_MONITOR_ECU_MONITOR_BASE_HPP_

system/system_monitor/include/system_monitor/ecu_monitor/unknown_ecu_monitor.hpp

@@ -0,0 +1,39 @@
+// Copyright 2020 Tier IV, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+/**
+ * @file unknown_ecu_monitor.h
+ * @brief Unknown ECU monitor class
+ */
+
+#ifndef SYSTEM_MONITOR_ECU_MONITOR__UNKNOWN_ECU_MONITOR_HPP_
+#define SYSTEM_MONITOR__ECU_MONITOR__UNKNOWN_ECU_MONITOR_HPP_
+
+#include "system_monitor/ecu_monitor/ecu_monitor_base.hpp"
+
+#include <string>
+
+class ECUMonitor : public ECUMonitorBase
+{
+public:
+  /**
+   * @brief constructor
+   * @param [in] node_name Name of the node.
+   * @param [in] options Options associated with this node.
+   */
+  explicit ECUMonitor(const rclcpp::NodeOptions & options);
+
+};
+
+#endif  // SYSTEM_MONITOR__ECU_MONITOR__UNKNOWN_ECU_MONITOR_HPP_

system/system_monitor/launch/system_monitor.launch.py

@@ -96,6 +96,16 @@ def launch_setup(context, *args, **kwargs):
             gpu_monitor_config,
         ],
     )
+    with open(LaunchConfiguration("ecu_monitor_config_file").perform(context), "r") as f:
+        ecu_monitor_config = yaml.safe_load(f)["/**"]["ros__parameters"]
+    ecu_monitor = ComposableNode(
+        package="system_monitor",
+        plugin="ECUMonitor",
+        name="ecu_monitor",
+        parameters=[
+            ecu_monitor_config,
+        ],
+    )
 
     # set container to run all required components in the same process
     container = ComposableNodeContainer(
@@ -104,6 +114,7 @@ def launch_setup(context, *args, **kwargs):
         package="rclcpp_components",
         executable="component_container_mt",
         composable_node_descriptions=[
+            ecu_monitor,
             cpu_monitor,
             hdd_monitor,
             mem_monitor,
@@ -151,6 +162,10 @@ def generate_launch_description():
                 "gpu_monitor_config_file",
                 default_value=os.path.join(system_monitor_path, "gpu_monitor.param.yaml"),
             ),
+            DeclareLaunchArgument(
+                "ecu_monitor_config_file",
+                default_value=os.path.join(system_monitor_path, "ecu_monitor.param.yaml"),
+            ),
             OpaqueFunction(function=launch_setup),
         ]
     )

system/system_monitor/launch/system_monitor.launch.xml

@@ -6,6 +6,7 @@
   <arg name="ntp_monitor_config_file" default="$(find-pkg-share system_monitor)/config/ntp_monitor.param.yaml"/>
   <arg name="process_monitor_config_file" default="$(find-pkg-share system_monitor)/config/process_monitor.param.yaml"/>
   <arg name="gpu_monitor_config_file" default="$(find-pkg-share system_monitor)/config/gpu_monitor.param.yaml"/>
+  <arg name="ecu_monitor_config_file" default="$(find-pkg-share system_monitor)/config/ecu_monitor.param.yaml"/>
 
   <group>
     <node pkg="system_monitor" exec="cpu_monitor" name="cpu_monitor" output="log" respawn="true">
@@ -29,5 +30,8 @@
     <node pkg="system_monitor" exec="gpu_monitor" name="gpu_monitor" output="log" respawn="true">
       <param from="$(var gpu_monitor_config_file)"/>
     </node>
+    <node pkg="system_monitor" exec="ecu_monitor" name="ecu_monitor" output="log" respawn="true">
+      <param from="$(var ecu_monitor_config_file)"/>
+    </node>
   </group>
 </launch>

system/system_monitor/src/ecu_monitor/adlink_ecu_monitor.cpp

@@ -0,0 +1,105 @@
+// Copyright 2020 Autoware Foundation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+/**
+ * @file _cpu_monitor.cpp
+ * @brief  CPU monitor class
+ */
+
+#include "system_monitor/ecu_monitor/adlink_ecu_monitor.hpp"
+
+#include "system_monitor/system_monitor_utility.hpp"
+
+#include <msr_reader/msr_reader.hpp>
+
+#include <boost/algorithm/string.hpp>
+#include <boost/archive/text_iarchive.hpp>
+#include <boost/filesystem.hpp>
+#include <boost/process.hpp>
+
+#include <fmt/format.h>
+#include <netinet/in.h>
+#include <sys/socket.h>
+
+#include <algorithm>
+#include <regex>
+#include <string>
+#include <vector>
+#include <regex>
+
+namespace bp = boost::process;
+
+ECUMonitor::ECUMonitor(const rclcpp::NodeOptions & options) : ECUMonitorBase("ecu_monitor", options)
+{
+  voltage_warn_ = declare_parameter<float>("low cmos battery warn", 2.9);
+  voltage_error_ = declare_parameter<float>("low cmos battery error", 2.7);
+
+  updater_.add("ECU CMOS Battery Voltage", this, &ECUMonitor::checkVoltage);
+  gethostname(hostname_, sizeof(hostname_));
+  // Check if command exists
+  fs::path p = bp::search_path("sensors");
+  sensors_exists_ = (p.empty()) ? false : true;
+}
+
+static float getVoltage() {
+    bp::ipstream is_out;
+    bp::ipstream is_err;
+    fs::path p = bp::search_path("sensors");
+    bp::child c(p.string(), bp::std_out > is_out, bp::std_err > is_err);
+    c.wait();
+
+    if(RCUTILS_UNLIKELY(c.exit_code() != 0)) {//failed to execute sensors 
+      return 0;
+    }
+    std::string line;
+    std::regex re(R"((\d+).(\d+))"); //in7:             3.06 V  (min =  +0.00 V, max =  +4.08 V)
+    for(int i = 0; i < 200 && std::getline(is_out, line); i++) {
+        auto voltageStringPos = line.find("in7:");
+        if( voltageStringPos != std::string::npos) {
+            std::smatch match;
+            std::regex_search(line, match, re);
+            auto voltageString = match.str(); 
+            return std::stof(voltageString);
+        }
+    }
+    return 0;//failed to read voltage
+}
+
+void ECUMonitor::checkVoltage(diagnostic_updater::DiagnosticStatusWrapper & stat)
+{
+  // Remember start time to measure elapsed time
+  const auto t_start = SystemMonitorUtility::startMeasurement();
+
+  if ( RCUTILS_UNLIKELY(!sensors_exists_) ) {
+    stat.summary(DiagStatus::ERROR, "sensors error");
+    stat.add(
+      "sensors", "Command 'sensors' not found, but can be installed with: 'sudo apt install lm-sensors' and 'sudo sensors-detect'");
+    return;
+  }
+
+  auto v = getVoltage();
+
+  stat.add("CMOS battey voltage", fmt::format("{}",v));
+  if( RCUTILS_UNLIKELY(v < voltage_warn_) ) {
+    stat.summary(DiagStatus::WARN, "LOW BATTERY");
+  } else {
+    stat.summary(DiagStatus::OK, "OK");
+  }
+
+  // Measure elapsed time since start time and report
+  SystemMonitorUtility::stopMeasurement(t_start, stat);
+}
+
+#include <rclcpp_components/register_node_macro.hpp>
+RCLCPP_COMPONENTS_REGISTER_NODE(ECUMonitor)