From 9e444ade872bc436cf12bc12d03c3a5d51ac0b9e Mon Sep 17 00:00:00 2001 From: Romain Forlot Date: Tue, 11 Apr 2017 12:55:23 +0200 Subject: Handle project new architecture using new CMakeFile Change-Id: I672a9b49d9d5a3953ba6dccaafbbd738839f64a6 Signed-off-by: Romain Forlot # Conflicts: # low-can-binding/libs/bitfield-c # low-can-binding/libs/isotp-c # low-can-binding/libs/openxc-message-format --- .gitmodules | 24 +- CMakeLists.txt | 177 +++++- etc/config.cmake | 75 +++ etc/export.map | 1 + low-can-binding/CMakeLists.txt | 81 +++ low-can-binding/can/can-bus-dev.cpp | 255 +++++++++ low-can-binding/can/can-bus-dev.hpp | 65 +++ low-can-binding/can/can-bus.cpp | 398 +++++++++++++ low-can-binding/can/can-bus.hpp | 94 ++++ low-can-binding/can/can-command.hpp | 55 ++ low-can-binding/can/can-decoder.cpp | 233 ++++++++ low-can-binding/can/can-decoder.hpp | 49 ++ low-can-binding/can/can-message-definition.cpp | 55 ++ low-can-binding/can/can-message-definition.hpp | 57 ++ low-can-binding/can/can-message-set.cpp | 37 ++ low-can-binding/can/can-message-set.hpp | 47 ++ low-can-binding/can/can-message.cpp | 264 +++++++++ low-can-binding/can/can-message.hpp | 75 +++ low-can-binding/can/can-signals.cpp | 186 +++++++ low-can-binding/can/can-signals.hpp | 158 ++++++ low-can-binding/configuration-generated.cpp | 350 ++++++++++++ low-can-binding/configuration.cpp | 156 ++++++ low-can-binding/configuration.hpp | 120 ++++ .../diagnostic/active-diagnostic-request.cpp | 194 +++++++ .../diagnostic/active-diagnostic-request.hpp | 122 ++++ low-can-binding/diagnostic/diagnostic-manager.cpp | 618 +++++++++++++++++++++ low-can-binding/diagnostic/diagnostic-manager.hpp | 99 ++++ low-can-binding/diagnostic/diagnostic-message.cpp | 108 ++++ low-can-binding/diagnostic/diagnostic-message.hpp | 79 +++ low-can-binding/libs/bitfield-c | 1 + low-can-binding/libs/isotp-c | 1 + low-can-binding/libs/nanopb | 1 + low-can-binding/libs/openxc-message-format | 1 + low-can-binding/libs/uds-c | 1 + low-can-binding/low-can-binding.cpp | 279 ++++++++++ low-can-binding/low-can-binding.hpp | 33 ++ low-can-binding/packaging/wgt/config.xml | 11 + low-can-binding/packaging/wgt/etc/can_buses.json | 3 + low-can-binding/packaging/wgt/icon.png | Bin 0 -> 4035 bytes low-can-binding/subCMakeLists.txt | 135 +++++ low-can-binding/utils/config-parser.cpp | 84 +++ low-can-binding/utils/config-parser.hpp | 43 ++ low-can-binding/utils/openxc-utils.cpp | 282 ++++++++++ low-can-binding/utils/openxc-utils.hpp | 42 ++ low-can-binding/utils/signals.cpp | 76 +++ low-can-binding/utils/signals.hpp | 90 +++ low-can-binding/utils/socket.cpp | 89 +++ low-can-binding/utils/socket.hpp | 46 ++ low-can-binding/utils/timer.cpp | 102 ++++ low-can-binding/utils/timer.hpp | 53 ++ src/CMakeLists.txt | 123 ---- src/can/can-bus-dev.cpp | 255 --------- src/can/can-bus-dev.hpp | 65 --- src/can/can-bus.cpp | 398 ------------- src/can/can-bus.hpp | 94 ---- src/can/can-command.hpp | 55 -- src/can/can-decoder.cpp | 233 -------- src/can/can-decoder.hpp | 49 -- src/can/can-message-definition.cpp | 55 -- src/can/can-message-definition.hpp | 57 -- src/can/can-message-set.cpp | 37 -- src/can/can-message-set.hpp | 47 -- src/can/can-message.cpp | 264 --------- src/can/can-message.hpp | 75 --- src/can/can-signals.cpp | 186 ------- src/can/can-signals.hpp | 158 ------ src/can_buses.json.in | 3 - src/config.xml.in | 11 - src/configuration.cpp | 156 ------ src/configuration.hpp | 120 ---- src/diagnostic/active-diagnostic-request.cpp | 194 ------- src/diagnostic/active-diagnostic-request.hpp | 122 ---- src/diagnostic/diagnostic-manager.cpp | 618 --------------------- src/diagnostic/diagnostic-manager.hpp | 99 ---- src/diagnostic/diagnostic-message.cpp | 108 ---- src/diagnostic/diagnostic-message.hpp | 79 --- src/export.map | 1 - src/icon.png | Bin 4035 -> 0 bytes src/libs/bitfield-c | 1 - src/libs/isotp-c | 1 - src/libs/nanopb | 1 - src/libs/openxc-message-format | 1 - src/libs/uds-c | 1 - src/low-can-binding.cpp | 279 ---------- src/low-can-binding.hpp | 33 -- src/utils/config-parser.cpp | 84 --- src/utils/config-parser.hpp | 43 -- src/utils/openxc-utils.cpp | 282 ---------- src/utils/openxc-utils.hpp | 42 -- src/utils/signals.cpp | 76 --- src/utils/signals.hpp | 90 --- src/utils/socket.cpp | 89 --- src/utils/socket.hpp | 46 -- src/utils/timer.cpp | 102 ---- src/utils/timer.hpp | 53 -- 95 files changed, 5587 insertions(+), 4904 deletions(-) create mode 100644 etc/config.cmake create mode 100644 etc/export.map create mode 100644 low-can-binding/CMakeLists.txt create mode 100644 low-can-binding/can/can-bus-dev.cpp create mode 100644 low-can-binding/can/can-bus-dev.hpp create mode 100644 low-can-binding/can/can-bus.cpp create mode 100644 low-can-binding/can/can-bus.hpp create mode 100644 low-can-binding/can/can-command.hpp create mode 100644 low-can-binding/can/can-decoder.cpp create mode 100644 low-can-binding/can/can-decoder.hpp create mode 100644 low-can-binding/can/can-message-definition.cpp create mode 100644 low-can-binding/can/can-message-definition.hpp create mode 100644 low-can-binding/can/can-message-set.cpp create mode 100644 low-can-binding/can/can-message-set.hpp create mode 100644 low-can-binding/can/can-message.cpp create mode 100644 low-can-binding/can/can-message.hpp create mode 100644 low-can-binding/can/can-signals.cpp create mode 100644 low-can-binding/can/can-signals.hpp create mode 100644 low-can-binding/configuration-generated.cpp create mode 100644 low-can-binding/configuration.cpp create mode 100644 low-can-binding/configuration.hpp create mode 100644 low-can-binding/diagnostic/active-diagnostic-request.cpp create mode 100644 low-can-binding/diagnostic/active-diagnostic-request.hpp create mode 100644 low-can-binding/diagnostic/diagnostic-manager.cpp create mode 100644 low-can-binding/diagnostic/diagnostic-manager.hpp create mode 100644 low-can-binding/diagnostic/diagnostic-message.cpp create mode 100644 low-can-binding/diagnostic/diagnostic-message.hpp create mode 160000 low-can-binding/libs/bitfield-c create mode 160000 low-can-binding/libs/isotp-c create mode 160000 low-can-binding/libs/nanopb create mode 160000 low-can-binding/libs/openxc-message-format create mode 160000 low-can-binding/libs/uds-c create mode 100644 low-can-binding/low-can-binding.cpp create mode 100644 low-can-binding/low-can-binding.hpp create mode 100644 low-can-binding/packaging/wgt/config.xml create mode 100644 low-can-binding/packaging/wgt/etc/can_buses.json create mode 100644 low-can-binding/packaging/wgt/icon.png create mode 100644 low-can-binding/subCMakeLists.txt create mode 100644 low-can-binding/utils/config-parser.cpp create mode 100644 low-can-binding/utils/config-parser.hpp create mode 100644 low-can-binding/utils/openxc-utils.cpp create mode 100644 low-can-binding/utils/openxc-utils.hpp create mode 100644 low-can-binding/utils/signals.cpp create mode 100644 low-can-binding/utils/signals.hpp create mode 100644 low-can-binding/utils/socket.cpp create mode 100644 low-can-binding/utils/socket.hpp create mode 100644 low-can-binding/utils/timer.cpp create mode 100644 low-can-binding/utils/timer.hpp delete mode 100644 src/CMakeLists.txt delete mode 100644 src/can/can-bus-dev.cpp delete mode 100644 src/can/can-bus-dev.hpp delete mode 100644 src/can/can-bus.cpp delete mode 100644 src/can/can-bus.hpp delete mode 100644 src/can/can-command.hpp delete mode 100644 src/can/can-decoder.cpp delete mode 100644 src/can/can-decoder.hpp delete mode 100644 src/can/can-message-definition.cpp delete mode 100644 src/can/can-message-definition.hpp delete mode 100644 src/can/can-message-set.cpp delete mode 100644 src/can/can-message-set.hpp delete mode 100644 src/can/can-message.cpp delete mode 100644 src/can/can-message.hpp delete mode 100644 src/can/can-signals.cpp delete mode 100644 src/can/can-signals.hpp delete mode 100644 src/can_buses.json.in delete mode 100644 src/config.xml.in delete mode 100644 src/configuration.cpp delete mode 100644 src/configuration.hpp delete mode 100644 src/diagnostic/active-diagnostic-request.cpp delete mode 100644 src/diagnostic/active-diagnostic-request.hpp delete mode 100644 src/diagnostic/diagnostic-manager.cpp delete mode 100644 src/diagnostic/diagnostic-manager.hpp delete mode 100644 src/diagnostic/diagnostic-message.cpp delete mode 100644 src/diagnostic/diagnostic-message.hpp delete mode 100644 src/export.map delete mode 100644 src/icon.png delete mode 160000 src/libs/bitfield-c delete mode 160000 src/libs/isotp-c delete mode 160000 src/libs/nanopb delete mode 160000 src/libs/openxc-message-format delete mode 160000 src/libs/uds-c delete mode 100644 src/low-can-binding.cpp delete mode 100644 src/low-can-binding.hpp delete mode 100644 src/utils/config-parser.cpp delete mode 100644 src/utils/config-parser.hpp delete mode 100644 src/utils/openxc-utils.cpp delete mode 100644 src/utils/openxc-utils.hpp delete mode 100644 src/utils/signals.cpp delete mode 100644 src/utils/signals.hpp delete mode 100644 src/utils/socket.cpp delete mode 100644 src/utils/socket.hpp delete mode 100644 src/utils/timer.cpp delete mode 100644 src/utils/timer.hpp diff --git a/.gitmodules b/.gitmodules index de99e87d..74a13e89 100644 --- a/.gitmodules +++ b/.gitmodules @@ -1,15 +1,15 @@ -[submodule "src/libs/openxc-message-format"] - path = src/libs/openxc-message-format - url = https://github.com/openxc/openxc-message-format.git -[submodule "src/libs/nanopb"] - path = src/libs/nanopb +[submodule "low-can-binding/libs/openxc-message-format"] + path = low-can-binding/libs/openxc-message-format + url = https://github.com/openxc/openxc-message-format +[submodule "low-can-binding/libs/nanopb"] + path = low-can-binding/libs/nanopb url = https://github.com/nanopb/nanopb.git -[submodule "src/libs/uds-c"] - path = src/libs/uds-c +[submodule "low-can-binding/libs/uds-c"] + path = low-can-binding/libs/uds-c url = https://github.com/openxc/uds-c.git -[submodule "src/libs/bitfield-c"] - path = src/libs/bitfield-c +[submodule "low-can-binding/libs/bitfield-c"] + path = low-can-binding/libs/bitfield-c url = https://github.com/openxc/bitfield-c.git -[submodule "src/libs/isotp-c"] - path = src/libs/isotp-c - url = https://github.com/openxc/isotp-c.git +[submodule "low-can-binding/libs/isotp-c"] + path = low-can-binding/libs/isotp-c + url = https://github.com/openxc/isotp-c diff --git a/CMakeLists.txt b/CMakeLists.txt index 233ee695..4ba6136f 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,8 +1,7 @@ ########################################################################### -# Copyright 2016 IoT.bzh +# Copyright 2015, 2016, 2017 IoT.bzh # -# author: José Bollo -# author: Stéphane Desneux +# author: Fulup Ar Foll # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. @@ -17,6 +16,172 @@ # limitations under the License. ########################################################################### -cmake_minimum_required(VERSION 3.3) -project(low-can-binding) -add_subdirectory(src) + +#-------------------------------------------------------------------------- +# WARNING: +# Do not change this cmake template +# Customise your preferences in "./etc/config.cmake" +#-------------------------------------------------------------------------- + + +# Generic useful macro +# ----------------------- +macro(PROJECT_TARGET_ADD TARGET_NAME) + set(PROJECT_TARGETS ${PROJECT_TARGETS} ${TARGET_NAME} CACHE INTERNAL PROJECT_TARGETS) +endmacro(PROJECT_TARGET_ADD) + +macro(defstr name value) + add_definitions(-D${name}=${value}) +endmacro(defstr) + +macro(setc name value) + if(NOT DEFINED ${name}) + set(${name} ${value}) + endif(NOT DEFINED ${name}) +endmacro(setc) + +macro(fill_include_dir path) + file(GLOB_RECURSE dirlist LIST_DIRECTORIES true "${path}/*") + foreach(filename ${dirlist}) + if(IS_DIRECTORY ${filename}) + include_directories(${filename}) + endif(IS_DIRECTORY ${filename}) + endforeach() +endmacro(fill_include_dir) + +function(find_source_files path) + file(GLOB_RECURSE filelist "${path}/*.[cpx]") + foreach(filename ${filelist}) + if(NOT ${filename} MATCHES ".*(test|example|sample).*") + string(APPEND sources "${filename};") + endif(NOT ${filename} MATCHES ".*(test|example|sample).*") + endforeach() + set(sources_files ${sources} PARENT_SCOPE) +endfunction(find_source_files) + +CMAKE_MINIMUM_REQUIRED(VERSION 3.3) +setc(CMAKE_BUILD_TYPE Debug) +set(CMAKE_POSITION_INDEPENDENT_CODE ON) +set(CMP0048 1) + +# Compiler selection should append before project definition +# ----------------------------------------------------------- +foreach (GCC_VERSION "6" "5") + execute_process(COMMAND gcc-${GCC_VERSION} -dumpversion RESULT_VARIABLE GCCRC OUTPUT_QUIET ERROR_QUIET) + if(GCCRC EQUAL 0) + set(CMAKE_C_COMPILER "gcc-${GCC_VERSION}") + set(CMAKE_CXX_COMPILER "g++-${GCC_VERSION}") + set(CMAKE_C_VERSION ${GCC_VERSION}) + break() + endif(GCCRC EQUAL 0) +endforeach(GCC_VERSION) + +# Include project configuration +# ------------------------------ +include(${CMAKE_CURRENT_SOURCE_DIR}/etc/config.cmake) +project(${NAME} VERSION ${VERSION}) +setc(PROJECT_PRETTY_NAME "${PRETTY_NAME}") +setc(PROJECT_DESCRIPTION "${DESCRIPTION}") +setc(PROJECT_WGT_DIR "packaging/wgt") +setc(PROJECT_LIBDIR "libs") +setc(PROJECT_RESOURCES "data") + +message(STATUS "") +message(STATUS "Project=${PROJECT_NAME}/${VERSION}[${PRETTY_NAME} ${DESCRIPTION}]") +message(STATUS "") +message(STATUS "gcc/g++ version-${CMAKE_C_VERSION}.x selected") + +INCLUDE(FindPkgConfig) +INCLUDE(CheckIncludeFiles) +INCLUDE(CheckLibraryExists) +INCLUDE(GNUInstallDirs) + +# Default compilation options +############################################################################ +link_libraries(-Wl,--as-needed -Wl,--gc-sections) +add_compile_options(-Wall -Wextra -Wconversion) +add_compile_options(-Wno-unused-parameter) # frankly not using a parameter does it care? +add_compile_options(-Wno-sign-compare -Wno-sign-conversion) +add_compile_options(-Werror=maybe-uninitialized) +add_compile_options(-Werror=implicit-function-declaration) +add_compile_options(-ffunction-sections -fdata-sections) +add_compile_options(-fPIC) +add_compile_options(-g) + +setc(CMAKE_C_FLAGS_PROFILING "-g -O2 -pg -Wp,-U_FORTIFY_SOURCE") +setc(CMAKE_C_FLAGS_DEBUG "-g -O2 -ggdb -Wp,-U_FORTIFY_SOURCE") +setc(CMAKE_C_FLAGS_RELEASE "-O2") +setc(CMAKE_C_FLAGS_CCOV "-g -O2 --coverage") +setc(CMAKE_INSTALL_PREFIX "${CMAKE_SOURCE_DIR}/Install") + +# (BUG!!!) as PKG_CONFIG_PATH does not work [should be en env variable] +setc(PKG_CONFIG_USE_CMAKE_PREFIX_PATH 1) + +# Loop on required package and add options +foreach (PKG_CONFIG ${PKG_REQUIRED_LIST}) + PKG_CHECK_MODULES(${PKG_CONFIG} REQUIRED ${PKG_CONFIG}) + + INCLUDE_DIRECTORIES(${${PKG_CONFIG}_INCLUDE_DIRS}) + list (APPEND link_libraries ${${PKG_CONFIG}_LIBRARIES}) + add_compile_options (${${PKG_CONFIG}_CFLAGS}) +endforeach(PKG_CONFIG) + +# Optional LibEfence Malloc debug library +IF(CMAKE_BUILD_TYPE MATCHES DEBUG) +CHECK_LIBRARY_EXISTS(efence malloc "" HAVE_LIBEFENCE) +IF(HAVE_LIBEFENCE) + MESSAGE(STATUS "Linking with ElectricFence for debugging purposes...") + SET(libefence_LIBRARIES "-lefence") + list (APPEND link_libraries libefence_LIBRARIES}) +ENDIF(HAVE_LIBEFENCE) +ENDIF(CMAKE_BUILD_TYPE MATCHES DEBUG) + +# set default include directories +INCLUDE_DIRECTORIES(${EXTRA_INCLUDE_DIRS}) + +# If no install dir try to guest some smart default +if(BINDINGS_INSTALL_PREFIX) + set(BINDINGS_INSTALL_DIR ${BINDINGS_INSTALL_PREFIX}/${PROJECT_NAME}) +else() + set(BINDINGS_INSTALL_DIR ${CMAKE_INSTALL_FULL_LIBDIR}/${PROJECT_NAME}) +endif() + +# Default Linkflag +if(NOT BINDINGS_LINK_FLAG) + set(BINDINGS_LINK_FLAG "-Wl,--version-script=${CMAKE_SOURCE_DIR}/etc/export.map") +endif() + +# Bindings to compile +# -------------------- +file(GLOB filelist "[A-z]*") +foreach(filename ${filelist}) +if(EXISTS "${filename}/CMakeLists.txt") + add_subdirectory(${filename}) +endif(EXISTS "${filename}/CMakeLists.txt") +endforeach() + +# Add a dummy target to enable global dependency order +# ----------------------------------------------------- +if(EXTRA_DEPENDENCIES_ORDER) + set(DEPENDENCIES_TARGET ${PROJECT_NAME}_extra_dependencies) + add_custom_target(${DEPENDENCIES_TARGET} ALL + DEPENDS ${EXTRA_DEPENDENCY_ORDER} + ) +endif() + +# Cmake does not maintain targets list before 3.7 +# ------------------------------------------------- +if(${CMAKE_VERSION} VERSION_LESS 3.7) + set(GLOBAL_TARGET_LIST ${PROJECT_TARGETS}) +else() + get_property(GLOBAL_TARGET_LIST GLOBAL PROPERTY GlobalTargetList) +endif() + +# Print developer helper message when everything is done +# ------------------------------------------------------- +if(CLOSING_MESSAGE AND GLOBAL_TARGET_LIST) + add_custom_target(${PROJECT_NAME}_done ALL + DEPENDS ${DEPENDENCIES_TARGET} ${GLOBAL_TARGET_LIST} + COMMAND ${CMAKE_COMMAND} -E cmake_echo_color --cyan "++ ${CLOSING_MESSAGE}" + ) +endif() diff --git a/etc/config.cmake b/etc/config.cmake new file mode 100644 index 00000000..dc695b44 --- /dev/null +++ b/etc/config.cmake @@ -0,0 +1,75 @@ +########################################################################### +# Copyright 2015, 2016, 2017 IoT.bzh +# +# author: Fulup Ar Foll +# +# 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. +########################################################################### + +# Project Info +# ------------------ +set(NAME low-can-binding) +set(VERSION "1.0") +set(PRETTY_NAME "Low level CAN binding") +set(DESCRIPTION "Expose CAN Low Level APIs through AGL Framework") +set(URL "https://github.com/iotbzh/CAN_signaling") +set(PROJECT_ICON "icon.png") + +# Compilation Mode (DEBUG, RELEASE) +# ---------------------------------- +setc(CMAKE_BUILD_TYPE "DEBUG") + +# PKG_CONFIG required packages +# ----------------------------- +set (PKG_REQUIRED_LIST + json-c + libsystemd + afb-daemon +) + +# Static constante definition +# ----------------------------- +add_compile_options(-D_REENTRANT) +add_compile_options(-DPB_FIELD_16BIT) + +# Print a helper message when every thing is finished +setc(CLOSING_MESSAGE "Test with: afb-daemon --ldpaths=\$\$(pwd)/package/lib --port=1234 --roothttp=\$\$(pwd)/package/htdocs --tracereq=common --token=\"\" --verbose") +# ---------------------------------------------------- + +# (BUG!!!) as PKG_CONFIG_PATH does not work [should be an env variable] +# --------------------------------------------------------------------- +setc(CMAKE_INSTALL_PREFIX ${HOME}/opt) +setc(CMAKE_PREFIX_PATH ${CMAKE_INSTALL_PREFIX}/lib64/pkgconfig ${CMAKE_INSTALL_PREFIX}/lib/pkgconfig) +setc(LD_LIBRARY_PATH ${CMAKE_INSTALL_PREFIX}/lib64 ${CMAKE_INSTALL_PREFIX}/lib) + +# Optional dependencies order +# --------------------------- +#set(EXTRA_DEPENDENCIES_ORDER target1 target2 ...) + +# Optional Extra global include path +# ----------------------------------- +#set(EXTRA_INCLUDE_DIRS incdir1 incdir2 ...) + +# Optional extra libraries +# ------------------------- +set(EXTRA_LINK_LIBRARIES nanopb bitfield-c isotp-c uds-c openxc-message-format) + +# Optional force binding installation +# ------------------------------------ +# set(BINDINGS_INSTALL_PREFIX DestinationPath ) + +# Optional force binding Linking flag +# ------------------------------------ +# set(BINDINGS_LINK_FLAG LinkOptions ) + + diff --git a/etc/export.map b/etc/export.map new file mode 100644 index 00000000..52c1b4aa --- /dev/null +++ b/etc/export.map @@ -0,0 +1 @@ +{ global: afbBindingV1*; local: *; }; diff --git a/low-can-binding/CMakeLists.txt b/low-can-binding/CMakeLists.txt new file mode 100644 index 00000000..ae035c91 --- /dev/null +++ b/low-can-binding/CMakeLists.txt @@ -0,0 +1,81 @@ +########################################################################### +# Copyright 2015, 2016, 2017 IoT.bzh +# +# author: Fulup Ar Foll +# +# 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. +########################################################################### + +# Add target to project dependency list +PROJECT_TARGET_ADD(low-can-binding) + + # Define project Targets + fill_include_dir(${PROJECT_LIBDIR}) + file(GLOB filelist "${PROJECT_LIBDIR}/*") + foreach(filename ${filelist}) + if(IS_DIRECTORY ${filename}) + include_directories(${filename}) + STRING(REGEX REPLACE "^.*\/(.*)$" "\\1" shortname ${filename}) + find_source_files(${PROJECT_LIBDIR}) + add_library(${shortname} STATIC ${sources_files}) + endif(IS_DIRECTORY ${filename}) + endforeach() + + add_library(${PROJECT_NAME} MODULE ${PROJECT_NAME}.cpp configuration.cpp configuration-generated.cpp + can/can-bus.cpp can/can-bus-dev.cpp can/can-message-set.cpp can/can-message-definition.cpp can/can-message.cpp can/can-signals.cpp can/can-decoder.cpp + diagnostic/diagnostic-message.cpp diagnostic/diagnostic-manager.cpp diagnostic/active-diagnostic-request.cpp + utils/signals.cpp utils/openxc-utils.cpp utils/timer.cpp utils/socket.cpp) + + # Binder exposes a unique public entry point + SET_TARGET_PROPERTIES(${PROJECT_NAME} PROPERTIES + PREFIX "" + LINK_FLAGS ${BINDINGS_LINK_FLAG} + OUTPUT_NAME ${PROJECT_NAME} + ) + + # Library dependencies (include updates automatically) + TARGET_LINK_LIBRARIES(${PROJECT_NAME} + ${EXTRA_LINK_LIBRARIES} + ${link_libraries} + ) + + # installation directory + INSTALL(TARGETS ${PROJECT_NAME} + LIBRARY DESTINATION ${BINDINGS_INSTALL_DIR}) + + # WGT packaging + message(STATUS "Creation of ${PROJECT_NAME}.wgt package for AppFW") + + configure_file(${PROJECT_WGT_DIR}/config.xml config.xml) + + if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${PROJECT_WGT_DIR}/etc") + file(GLOB conf_files "${PROJECT_WGT_DIR}/etc/*") + foreach(filename ${conf_files}) + STRING(REGEX REPLACE "^.*\/(.*)$" "\\1" shortname ${filename}) + message(STATUS "Copying config file ${shortname}") + configure_file(${filename} ${shortname}) + endforeach() + endif(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${PROJECT_WGT_DIR}/etc") + + add_custom_command( + OUTPUT ${PROJECT_NAME}.wgt + DEPENDS ${PROJECT_NAME} ${EXTRA_LINK_LIBRARIES} ${conf_files} ${PROJECT_WGT_DIR}/config.xml + COMMAND rm -rf package + COMMAND mkdir -p package/lib package/htdocs package/etc + COMMAND cp config.xml package/ + COMMAND cp ${conf_files} package/etc + COMMAND cp ${CMAKE_CURRENT_SOURCE_DIR}/packaging/wgt/${PROJECT_ICON} package/icon.png + COMMAND cp ${PROJECT_NAME}.so package/lib + COMMAND wgtpkg-pack -f -o ${PROJECT_NAME}.wgt package + ) + add_custom_target(widget ALL DEPENDS ${PROJECT_NAME}.wgt) \ No newline at end of file diff --git a/low-can-binding/can/can-bus-dev.cpp b/low-can-binding/can/can-bus-dev.cpp new file mode 100644 index 00000000..fb76498f --- /dev/null +++ b/low-can-binding/can/can-bus-dev.cpp @@ -0,0 +1,255 @@ +/* +* Copyright (C) 2015, 2016, 2017 "IoT.bzh" +* Author "Romain Forlot" +* Author "Loïc Collignon" +* +* 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. +*/ + +#include +#include +#include +#include +#include +#include +#include + +#include "can-bus-dev.hpp" + +#include "can-bus.hpp" +#include "can-message.hpp" +#include "../low-can-binding.hpp" + +/// @brief Class constructor +/// +/// @param[in] dev_name - String representing the device name into the linux /dev tree +/// @param[in] address - integer identifier of the bus, set using init_can_dev from can_bus_t. +can_bus_dev_t::can_bus_dev_t(const std::string& dev_name, int32_t address) + : device_name_{dev_name}, address_{address} +{} + +std::string can_bus_dev_t::get_device_name() const +{ + return device_name_; +} + +uint32_t can_bus_dev_t::get_address() const +{ + return address_; +} + +/// @brief Open the can socket and returning it +/// +/// We try to open CAN socket and apply the following options +/// timestamp received messages and pass the socket to FD mode. +/// +/// @return -1 if something wrong. +int can_bus_dev_t::open() +{ + const int canfd_on = 1; + const int timestamp_on = 1; + struct ifreq ifr; + struct timeval timeout; + + DEBUG(binder_interface, "open: CAN Handler socket : %d", can_socket_.socket()); + if (can_socket_) + return 0; + + can_socket_.open(PF_CAN, SOCK_RAW, CAN_RAW); + if (can_socket_) + { + DEBUG(binder_interface, "open: CAN Handler socket correctly initialized : %d", can_socket_.socket()); + + // Set timeout for read + can_socket_.setopt(SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout, sizeof(timeout)); + + // Set timestamp for receveid frame + if (can_socket_.setopt(SOL_SOCKET, SO_TIMESTAMP, ×tamp_on, sizeof(timestamp_on)) < 0) + WARNING(binder_interface, "open: setsockopt SO_TIMESTAMP error: %s", ::strerror(errno)); + DEBUG(binder_interface, "open: Switch CAN Handler socket to use fd mode"); + + // try to switch the socket into CAN_FD mode + if (can_socket_.setopt(SOL_CAN_RAW, CAN_RAW_FD_FRAMES, &canfd_on, sizeof(canfd_on)) < 0) + { + NOTICE(binder_interface, "open: Can not switch into CAN Extended frame format."); + is_fdmode_on_ = false; + } + else + { + DEBUG(binder_interface, "open: Correctly set up CAN socket to use FD frames."); + is_fdmode_on_ = true; + } + + // Attempts to open a socket to CAN bus + ::strcpy(ifr.ifr_name, device_name_.c_str()); + DEBUG(binder_interface, "open: ifr_name is : %s", ifr.ifr_name); + if(::ioctl(can_socket_.socket(), SIOCGIFINDEX, &ifr) < 0) + { + ERROR(binder_interface, "open: ioctl failed. Error was : %s", strerror(errno)); + } + else + { + txAddress_.can_family = AF_CAN; + txAddress_.can_ifindex = ifr.ifr_ifindex; + + // And bind it to txAddress + DEBUG(binder_interface, "Bind the socket"); + if (can_socket_.bind((struct sockaddr *)&txAddress_, sizeof(txAddress_)) < 0) + ERROR(binder_interface, "Bind failed. %s", strerror(errno)); + else return 0; + } + close(); + } + else ERROR(binder_interface, "open: socket could not be created. Error was : %s", ::strerror(errno)); + return -1; +} + +/// @brief Close the bus. +/// +/// @return interger return value of socket.close() function +int can_bus_dev_t::close() +{ + return can_socket_.close(); +} + +/// @brief Read the can socket and retrieve canfd_frame. +/// +/// Read operation are blocking and we try to read CANFD frame +/// rather than classic CAN frame. CANFD frame are retro compatible. +can_message_t can_bus_dev_t::read() +{ + ssize_t nbytes; + struct canfd_frame cfd; + + // Test that socket is really opened + if (!can_socket_) + { + ERROR(binder_interface, "read: Socket unavailable. Closing thread."); + is_running_ = false; + } + + nbytes = ::read(can_socket_.socket(), &cfd, CANFD_MTU); + + // if we did not fit into CAN sized messages then stop_reading. + if (nbytes != CANFD_MTU && nbytes != CAN_MTU) + { + if (errno == ENETDOWN) + ERROR(binder_interface, "read: %s CAN device down", device_name_.c_str()); + ERROR(binder_interface, "read: Incomplete CAN(FD) frame"); + ::memset(&cfd, 0, sizeof(cfd)); + } + + DEBUG(binder_interface, "read: Found id: %X, length: %X, data %02X%02X%02X%02X%02X%02X%02X%02X", cfd.can_id, cfd.len, + cfd.data[0], cfd.data[1], cfd.data[2], cfd.data[3], cfd.data[4], cfd.data[5], cfd.data[6], cfd.data[7]); + return can_message_t::convert_from_canfd_frame(cfd, nbytes); +} + +/// @brief start reading threads and set flag is_running_ +/// @param[in] can_bus reference can_bus_t. it will be passed to the thread to allow using can_bus_t queue. +void can_bus_dev_t::start_reading(can_bus_t& can_bus) +{ + DEBUG(binder_interface, "Launching reading thread"); + is_running_ = true; + th_reading_ = std::thread(&can_bus_dev_t::can_reader, this, std::ref(can_bus)); + if(!th_reading_.joinable()) + is_running_ = false; +} + +/// @brief stop the reading thread setting flag is_running_ to false and and wait that the thread finish its job. +void can_bus_dev_t::stop_reading() +{ + is_running_ = false; +} + +/// @brief Thread function used to read the can socket. +/// @param[in] can_bus - object to be used to read the can socket +void can_bus_dev_t::can_reader(can_bus_t& can_bus) +{ + while(is_running_) + { + can_message_t msg = read(); + { + std::lock_guard can_message_lock(can_bus.get_can_message_mutex()); + can_bus.push_new_can_message(msg); + } + can_bus.get_new_can_message_cv().notify_one(); + } +} + +/// @brief Send a can message from a can_message_t object. +/// @param[in] can_msg - the can message object to send +/// +/// @return 0 if message snet, -1 if something wrong. +int can_bus_dev_t::send(can_message_t& can_msg) +{ + ssize_t nbytes; + canfd_frame f; + + f = can_msg.convert_to_canfd_frame(); + + if(can_socket_) + { + nbytes = ::sendto(can_socket_.socket(), &f, sizeof(struct canfd_frame), 0, + (struct sockaddr*)&txAddress_, sizeof(txAddress_)); + if (nbytes == -1) + { + ERROR(binder_interface, "send_can_message: Sending CAN frame failed."); + return -1; + } + return (int)nbytes; + } + else + { + ERROR(binder_interface, "send_can_message: socket not initialized. Attempt to reopen can device socket."); + open(); + } + return 0; +} + +/// @brief Static method used to send diagnostic CAN message +/// that follow isotp SendShimsMessage signature. This method is launched +/// from diagnostic manager's' same name method. It will use the diagnostic +/// manager configured CAN bus device to send the CAN message. +/// +/// @param[in] arbitration_id - CAN arbitration id. +/// @param[in] data - CAN message payload to send +/// @param[in] size - size of the data to send +/// +/// @return True if message sent, false if not. +bool can_bus_dev_t::shims_send(const uint32_t arbitration_id, const uint8_t* data, const uint8_t size) +{ + ssize_t nbytes; + canfd_frame f; + + f.can_id = arbitration_id; + f.len = size; + ::memcpy(f.data, data, size); + + if(can_socket_) + { + nbytes = ::sendto(can_socket_.socket(), &f, sizeof(struct canfd_frame), 0, + (struct sockaddr*)&txAddress_, sizeof(txAddress_)); + if (nbytes == -1) + { + ERROR(binder_interface, "send_can_message: Sending CAN frame failed."); + return false; + } + return true; + } + else + { + ERROR(binder_interface, "send_can_message: socket not initialized. Attempt to reopen can device socket."); + open(); + } + return false; +} diff --git a/low-can-binding/can/can-bus-dev.hpp b/low-can-binding/can/can-bus-dev.hpp new file mode 100644 index 00000000..a612e7d8 --- /dev/null +++ b/low-can-binding/can/can-bus-dev.hpp @@ -0,0 +1,65 @@ +/* + * Copyright (C) 2015, 2016, 2017 "IoT.bzh" + * Author "Romain Forlot" + * Author "Loïc Collignon" + * + * 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. + */ + +#pragma once + +#include +#include +#include +#include + +#include "../utils/socket.hpp" + +class can_bus_t; +class can_message_t; + +/// @brief Object representing a can device. Handle opening, closing and reading on the +/// socket. This is the low level object to be initialized and use by can_bus_t. +class can_bus_dev_t +{ +private: + std::string device_name_; ///< a string identifier identitfying the linux CAN device. + utils::socket_t can_socket_; + + int32_t address_; ///< an identifier used through binding that refer to that device + + bool is_fdmode_on_; ///< boolean telling if whether or not the can socket use fdmode. + struct sockaddr_can txAddress_; /// < internal member using to bind to the socket + + std::thread th_reading_; ///< Thread handling read the socket can device filling can_message_q_ queue of can_bus_t + bool is_running_ = false; ///< boolean telling whether or not reading is running or not + void can_reader(can_bus_t& can_bus); + +public: + can_bus_dev_t(const std::string& dev_name, int32_t address); + + std::string get_device_name() const; + uint32_t get_address() const; + + int open(); + int close(); + + void start_reading(can_bus_t& can_bus); + + void stop_reading(); + + can_message_t read(); + + int send(can_message_t& can_msg); + bool shims_send(const uint32_t arbitration_id, const uint8_t* data, const uint8_t size); +}; diff --git a/low-can-binding/can/can-bus.cpp b/low-can-binding/can/can-bus.cpp new file mode 100644 index 00000000..33f58fd9 --- /dev/null +++ b/low-can-binding/can/can-bus.cpp @@ -0,0 +1,398 @@ +/* + * Copyright (C) 2015, 2016 "IoT.bzh" + * Author "Romain Forlot" + * + * 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. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "can-bus.hpp" + +#include "can-signals.hpp" +#include "can-decoder.hpp" +#include "../configuration.hpp" +#include "../utils/signals.hpp" +#include "../utils/openxc-utils.hpp" + +extern "C" +{ + #include +} + +/// @brief Class constructor +/// +/// @param[in] conf_file - handle to the json configuration file. +can_bus_t::can_bus_t(int conf_file) + : conf_file_{conf_file} +{ +} + +std::map> can_bus_t::can_devices_; + +/// @brief Will make the decoding operation on a classic CAN message. It will not +/// handle CAN commands nor diagnostic messages that have their own method to get +/// this happens. +/// +/// It will add to the vehicle_message queue the decoded message and tell the event push +/// thread to process it. +/// +/// @param[in] can_message - a single CAN message from the CAN socket read, to be decode. +/// +/// @return How many signals has been decoded. +int can_bus_t::process_can_signals(can_message_t& can_message) +{ + int processed_signals = 0; + std::vector signals; + openxc_DynamicField search_key, decoded_message; + openxc_VehicleMessage vehicle_message; + + // First we have to found which can_signal_t it is + search_key = build_DynamicField((double)can_message.get_id()); + configuration_t::instance().find_can_signals(search_key, signals); + + // Decoding the message ! Don't kill the messenger ! + for(auto& sig : signals) + { + std::lock_guard subscribed_signals_lock(get_subscribed_signals_mutex()); + std::map& s = get_subscribed_signals(); + + // DEBUG message to make easier debugger STL containers... + //DEBUG(binder_interface, "Operator[] key char: %s, event valid? %d", sig.generic_name, afb_event_is_valid(s[sig.generic_name])); + //DEBUG(binder_interface, "Operator[] key string: %s, event valid? %d", sig.generic_name, afb_event_is_valid(s[std::string(sig.generic_name)])); + //DEBUG(binder_interface, "Nb elt matched char: %d", (int)s.count(sig.generic_name)); + //DEBUG(binder_interface, "Nb elt matched string: %d", (int)s.count(std::string(sig.generic_name)); + if( s.find(sig->get_name()) != s.end() && afb_event_is_valid(s[sig->get_name()])) + { + decoded_message = decoder_t::translateSignal(*sig, can_message, configuration_t::instance().get_can_signals()); + + openxc_SimpleMessage s_message = build_SimpleMessage(sig->get_name(), decoded_message); + vehicle_message = build_VehicleMessage(s_message); + + std::lock_guard decoded_can_message_lock(decoded_can_message_mutex_); + push_new_vehicle_message(vehicle_message); + processed_signals++; + } + } + + DEBUG(binder_interface, "process_can_signals: %d/%d CAN signals processed.", processed_signals, (int)signals.size()); + return processed_signals; +} + +/// @brief Will make the decoding operation on a diagnostic CAN message.Then it find the subscribed signal +/// corresponding and will add the vehicle_message to the queue of event to pushed before notifying +/// the event push thread to process it. +/// +/// @param[in] manager - the diagnostic manager object that handle diagnostic communication +/// @param[in] can_message - a single CAN message from the CAN socket read, to be decode. +/// +/// @return How many signals has been decoded. +int can_bus_t::process_diagnostic_signals(diagnostic_manager_t& manager, const can_message_t& can_message) +{ + int processed_signals = 0; + + std::lock_guard subscribed_signals_lock(get_subscribed_signals_mutex()); + std::map& s = get_subscribed_signals(); + + openxc_VehicleMessage vehicle_message = manager.find_and_decode_adr(can_message); + if( (vehicle_message.has_simple_message && vehicle_message.simple_message.has_name) && + (s.find(vehicle_message.simple_message.name) != s.end() && afb_event_is_valid(s[vehicle_message.simple_message.name]))) + { + std::lock_guard decoded_can_message_lock(decoded_can_message_mutex_); + push_new_vehicle_message(vehicle_message); + processed_signals++; + } + + return processed_signals; +} + +/// @brief thread to decoding raw CAN messages. +/// +/// Depending on the nature of message, if arbitration ID matches ID for a diagnostic response +/// then decoding a diagnostic message else use classic CAN signals decoding functions. +/// +/// It will take from the can_message_q_ queue the next can message to process then it search +/// about signal subscribed if there is a valid afb_event for it. We only decode signal for which a +/// subscription has been made. Can message will be decoded using translateSignal that will pass it to the +/// corresponding decoding function if there is one assigned for that signal. If not, it will be the default +/// noopDecoder function that will operate on it. +/// +/// TODO: make diagnostic messages parsing optionnal. +void can_bus_t::can_decode_message() +{ + can_message_t can_message; + + while(is_decoding_) + { + { + std::unique_lock can_message_lock(can_message_mutex_); + new_can_message_cv_.wait(can_message_lock); + while(!can_message_q_.empty()) + { + can_message = next_can_message(); + + if(configuration_t::instance().get_diagnostic_manager().is_diagnostic_response(can_message)) + process_diagnostic_signals(configuration_t::instance().get_diagnostic_manager(), can_message); + else + process_can_signals(can_message); + } + } + new_decoded_can_message_.notify_one(); + } +} + +/// @brief thread to push events to suscribers. It will read subscribed_signals map to look +/// which are events that has to be pushed. +void can_bus_t::can_event_push() +{ + openxc_VehicleMessage v_message; + openxc_SimpleMessage s_message; + json_object* jo; + + while(is_pushing_) + { + std::unique_lock decoded_can_message_lock(decoded_can_message_mutex_); + new_decoded_can_message_.wait(decoded_can_message_lock); + while(!vehicle_message_q_.empty()) + { + v_message = next_vehicle_message(); + + s_message = get_simple_message(v_message); + { + std::lock_guard subscribed_signals_lock(get_subscribed_signals_mutex()); + std::map& s = get_subscribed_signals(); + if(s.find(std::string(s_message.name)) != s.end() && afb_event_is_valid(s[std::string(s_message.name)])) + { + jo = json_object_new_object(); + jsonify_simple(s_message, jo); + if(afb_event_push(s[std::string(s_message.name)], jo) == 0) + on_no_clients(std::string(s_message.name)); + } + } + } + } +} + +/// @brief Will initialize threads that will decode +/// and push subscribed events. +void can_bus_t::start_threads() +{ + is_decoding_ = true; + th_decoding_ = std::thread(&can_bus_t::can_decode_message, this); + if(!th_decoding_.joinable()) + is_decoding_ = false; + + is_pushing_ = true; + th_pushing_ = std::thread(&can_bus_t::can_event_push, this); + if(!th_pushing_.joinable()) + is_pushing_ = false; +} + +/// @brief Will stop all threads holded by can_bus_t object +/// which are decoding and pushing then will wait that's +/// they'll finish their job. +void can_bus_t::stop_threads() +{ + is_decoding_ = false; + is_pushing_ = false; +} + +/// @brief Will initialize can_bus_dev_t objects after reading +/// the configuration file passed in the constructor. All CAN buses +/// Initialized here will be added to a vector holding them for +/// inventory and later access. +/// +/// That will initialize CAN socket reading too using a new thread. +/// +/// @return 0 if ok, other if not. +int can_bus_t::init_can_dev() +{ + std::vector devices_name; + int i = 0; + size_t t; + + devices_name = read_conf(); + + if (! devices_name.empty()) + { + t = devices_name.size(); + + for(const auto& device : devices_name) + { + can_bus_t::can_devices_[device] = std::make_shared(device, i); + if (can_bus_t::can_devices_[device]->open() == 0) + { + DEBUG(binder_interface, "Start reading thread"); + NOTICE(binder_interface, "%s device opened and reading", device.c_str()); + can_bus_t::can_devices_[device]->start_reading(*this); + i++; + } + else + { + ERROR(binder_interface, "Can't open device %s", device.c_str()); + return 1; + } + } + + NOTICE(binder_interface, "Initialized %d/%d can bus device(s)", i, (int)t); + return 0; + } + ERROR(binder_interface, "init_can_dev: Error at CAN device initialization. No devices read from configuration file. Did you specify canbus JSON object ?"); + return 1; +} + +/// @brief read the conf_file_ and will parse json objects +/// in it searching for canbus objects devices name. +/// +/// @return Vector of can bus device name string. +std::vector can_bus_t::read_conf() +{ + std::vector ret; + json_object *jo, *canbus; + int n, i; + const char* taxi; + + FILE *fd = fdopen(conf_file_, "r"); + if (fd) + { + std::string fd_conf_content; + std::fseek(fd, 0, SEEK_END); + fd_conf_content.resize(std::ftell(fd)); + std::rewind(fd); + std::fread(&fd_conf_content[0], 1, fd_conf_content.size(), fd); + std::fclose(fd); + + DEBUG(binder_interface, "Configuration file content : %s", fd_conf_content.c_str()); + jo = json_tokener_parse(fd_conf_content.c_str()); + + if (jo == NULL || !json_object_object_get_ex(jo, "canbus", &canbus)) + { + ERROR(binder_interface, "Can't find canbus node in the configuration file. Please review it."); + ret.clear(); + } + else if (json_object_get_type(canbus) != json_type_array) + { + taxi = json_object_get_string(canbus); + DEBUG(binder_interface, "Can bus found: %s", taxi); + ret.push_back(std::string(taxi)); + } + else + { + n = json_object_array_length(canbus); + for (i = 0 ; i < n ; i++) + ret.push_back(json_object_get_string(json_object_array_get_idx(canbus, i))); + } + return ret; + } + ERROR(binder_interface, "Problem at reading the conf file"); + ret.clear(); + return ret; +} + +/// @brief return new_can_message_cv_ member +/// +/// @return return new_can_message_cv_ member +std::condition_variable& can_bus_t::get_new_can_message_cv() +{ + return new_can_message_cv_; +} + +/// @brief return can_message_mutex_ member +/// +/// @return return can_message_mutex_ member +std::mutex& can_bus_t::get_can_message_mutex() +{ + return can_message_mutex_; +} + +/// @brief Return first can_message_t on the queue +/// +/// @return a can_message_t +can_message_t can_bus_t::next_can_message() +{ + can_message_t can_msg; + + if(!can_message_q_.empty()) + { + can_msg = can_message_q_.front(); + can_message_q_.pop(); + DEBUG(binder_interface, "next_can_message: Here is the next can message : id %X, length %X, data %02X%02X%02X%02X%02X%02X%02X%02X", can_msg.get_id(), can_msg.get_length(), + can_msg.get_data()[0], can_msg.get_data()[1], can_msg.get_data()[2], can_msg.get_data()[3], can_msg.get_data()[4], can_msg.get_data()[5], can_msg.get_data()[6], can_msg.get_data()[7]); + return can_msg; + } + + return can_msg; +} + +/// @brief Push a can_message_t into the queue +/// +/// @param[in] can_msg - the const reference can_message_t object to push into the queue +void can_bus_t::push_new_can_message(const can_message_t& can_msg) +{ + can_message_q_.push(can_msg); +} + +/// @brief Return first openxc_VehicleMessage on the queue +/// +/// @return a openxc_VehicleMessage containing a decoded can message +openxc_VehicleMessage can_bus_t::next_vehicle_message() +{ + openxc_VehicleMessage v_msg; + + if(! vehicle_message_q_.empty()) + { + v_msg = vehicle_message_q_.front(); + vehicle_message_q_.pop(); + DEBUG(binder_interface, "next_vehicle_message: next vehicle message poped"); + return v_msg; + } + + return v_msg; +} + +/// @brief Push a openxc_VehicleMessage into the queue +/// +/// @param[in] v_msg - const reference openxc_VehicleMessage object to push into the queue +void can_bus_t::push_new_vehicle_message(const openxc_VehicleMessage& v_msg) +{ + vehicle_message_q_.push(v_msg); +} + +/// @brief Return a map with the can_bus_dev_t initialized +/// +/// @return map can_bus_dev_m_ map +const std::map>& can_bus_t::get_can_devices() const +{ + return can_bus_t::can_devices_; +} + +/// @brief Return the shared pointer on the can_bus_dev_t initialized +/// with device_name "bus" +/// +/// @param[in] bus - CAN bus device name to retrieve. +/// +/// @return A shared pointer on an object can_bus_dev_t +std::shared_ptr can_bus_t::get_can_device(std::string bus) +{ + return can_bus_t::can_devices_[bus]; +} diff --git a/low-can-binding/can/can-bus.hpp b/low-can-binding/can/can-bus.hpp new file mode 100644 index 00000000..eb474769 --- /dev/null +++ b/low-can-binding/can/can-bus.hpp @@ -0,0 +1,94 @@ +/* + * Copyright (C) 2015, 2016, 2017 "IoT.bzh" + * Author "Romain Forlot" + * Author "Loïc Collignon" + * + * 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. + */ + +#pragma once + +#include +#include +#include +#include +#include + +#include "openxc.pb.h" +#include "can-message.hpp" +#include "can-bus-dev.hpp" +#include "../diagnostic/active-diagnostic-request.hpp" + +#include "../low-can-binding.hpp" + +// TODO actual max is 32 but dropped to 24 for memory considerations +#define MAX_ACCEPTANCE_FILTERS 24 +// TODO this takes up a ton of memory +#define MAX_DYNAMIC_MESSAGE_COUNT 12 + +#define CAN_ACTIVE_TIMEOUT_S 30 + +/// @brief Object used to handle decoding and manage event queue to be pushed. +/// +/// This object is also used to initialize can_bus_dev_t object after reading +/// json conf file describing the CAN devices to use. Thus, those object will read +/// on the device the CAN frame and push them into the can_bus_t can_message_q_ queue. +/// +/// That queue will be later used to be decoded and pushed to subscribers. +class can_bus_t +{ +private: + int conf_file_; ///< configuration file handle used to initialize can_bus_dev_t objects. + + void can_decode_message(); + std::thread th_decoding_; ///< thread that'll handle decoding a can frame + bool is_decoding_ = false; ///< boolean member controling thread while loop + + void can_event_push(); + std::thread th_pushing_; ///< thread that'll handle pushing decoded can frame to subscribers + bool is_pushing_ = false; ///< boolean member controling thread while loop + + std::condition_variable new_can_message_cv_; ///< condition_variable use to wait until there is a new CAN message to read + std::mutex can_message_mutex_; ///< mutex protecting the can_message_q_ queue. + std::queue can_message_q_; ///< queue that'll store can_message_t to decoded + + std::condition_variable new_decoded_can_message_; ///< condition_variable use to wait until there is a new vehicle message to read from the queue vehicle_message_q_ + std::mutex decoded_can_message_mutex_; ///< mutex protecting the vehicle_message_q_ queue. + std::queue vehicle_message_q_; ///< queue that'll store openxc_VehicleMessage to pushed + + static std::map> can_devices_; ///< Can device map containing all can_bus_dev_t objects initialized during init_can_dev function + +public: + can_bus_t(int conf_file); + can_bus_t(can_bus_t&&); + + int init_can_dev(); + std::vector read_conf(); + + void start_threads(); + void stop_threads(); + + int process_can_signals(can_message_t& can_message); + int process_diagnostic_signals(diagnostic_manager_t& manager, const can_message_t& can_message); + + can_message_t next_can_message(); + void push_new_can_message(const can_message_t& can_msg); + std::mutex& get_can_message_mutex(); + std::condition_variable& get_new_can_message_cv(); + + openxc_VehicleMessage next_vehicle_message(); + void push_new_vehicle_message(const openxc_VehicleMessage& v_msg); + + const std::map>& get_can_devices() const; + static std::shared_ptr get_can_device(std::string bus); +}; diff --git a/low-can-binding/can/can-command.hpp b/low-can-binding/can/can-command.hpp new file mode 100644 index 00000000..4cf20cb5 --- /dev/null +++ b/low-can-binding/can/can-command.hpp @@ -0,0 +1,55 @@ +/* + * Copyright (C) 2015, 2016 "IoT.bzh" + * Author "Romain Forlot" + * + * 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. + */ + +#pragma once + +#include "openxc.pb.h" +#include "can-signals.hpp" + +/// +/// @brief The type signature for a function to handle a custom OpenXC command. +/// +/// @param[in] name - the name of the received command. +/// @param[in] value - the value of the received command, in a DynamicField. The actual type +/// may be a number, string or bool. +/// @param[in] event - an optional event from the received command, in a DynamicField. The +/// actual type may be a number, string or bool. +/// @param[in] signals - The list of all signals. +/// @param[in] signalCount - The length of the signals array. +/// +typedef void (*CommandHandler)(const char* name, openxc_DynamicField* value, + openxc_DynamicField* event, can_signal_t* signals, int signalCount); + +/// @struct CanCommand +/// @brief The structure to represent a supported custom OpenXC command. +/// +/// For completely customized CAN commands without a 1-1 mapping between an +/// OpenXC message from the host and a CAN signal, you can define the name of the +/// command and a custom function to handle it in the VI. An example is +/// the "turn_signal_status" command in OpenXC, which has a value of "left" or +/// "right". The vehicle may have separate CAN signals for the left and right +/// turn signals, so you will need to implement a custom command handler to send +/// the correct signals. +/// +/// Command handlers are also useful if you want to trigger multiple CAN messages +/// or signals from a signal OpenXC message. +/// +typedef struct { + const char* generic_name; /*!< generic_name - The name of the command.*/ + CommandHandler handler; /*!< handler - An function to process the received command's data and perform some + * action.*/ +} CanCommand; diff --git a/low-can-binding/can/can-decoder.cpp b/low-can-binding/can/can-decoder.cpp new file mode 100644 index 00000000..8843059d --- /dev/null +++ b/low-can-binding/can/can-decoder.cpp @@ -0,0 +1,233 @@ +/* + * Copyright (C) 2015, 2016 "IoT.bzh" + * Author "Romain Forlot" + * + * 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. + */ + +#include "can-decoder.hpp" + +#include "canutil/read.h" +#include "../utils/openxc-utils.hpp" + +/// @brief Parse the signal's bitfield from the given data and return the raw +/// value. +/// +/// @param[in] signal - The signal to parse from the data. +/// @param[in] message - can_message_t to parse +/// +/// @return Returns the raw value of the signal parsed as a bitfield from the given byte +/// array. +/// +float decoder_t::parseSignalBitfield(can_signal_t& signal, const can_message_t& message) +{ + return bitfield_parse_float(message.get_data(), CAN_MESSAGE_SIZE, + signal.get_bit_position(), signal.get_bit_size(), signal.get_factor(), + signal.get_offset()); +} + +/// @brief Wrap a raw CAN signal value in a DynamicField without modification. +/// +/// This is an implementation of the SignalDecoder type signature, and can be +/// used directly in the can_signal_t.decoder field. +/// +/// @param[in] signal - The details of the signal that contains the state mapping. +/// @param[in] signals - The list of all signals +/// @param[in] value - The numerical value that will be wrapped in a DynamicField. +/// @param[out] send - An output argument that will be set to false if the value should +/// not be sent for any reason. +/// +/// @return Returns a DynamicField with the original, unmodified raw CAN signal value as +/// its numeric value. The 'send' argument will not be modified as this decoder +/// always succeeds. +/// +openxc_DynamicField decoder_t::noopDecoder(can_signal_t& signal, + const std::vector& signals, float value, bool* send) +{ + openxc_DynamicField decoded_value = build_DynamicField(value); + + return decoded_value; +} +/// @brief Coerces a numerical value to a boolean. +/// +/// This is an implementation of the SignalDecoder type signature, and can be +/// used directly in the can_signal_t.decoder field. +/// +/// @param[in] signal - The details of the signal that contains the state mapping. +/// @param[in] signals - The list of all signals +/// @param[in] value - The numerical value that will be converted to a boolean. +/// @param[out] send - An output argument that will be set to false if the value should +/// not be sent for any reason. +/// +/// @return Returns a DynamicField with a boolean value of false if the raw signal value +/// is 0.0, otherwise true. The 'send' argument will not be modified as this +/// decoder always succeeds. +/// +openxc_DynamicField decoder_t::booleanDecoder(can_signal_t& signal, + const std::vector& signals, float value, bool* send) +{ + openxc_DynamicField decoded_value = build_DynamicField(value == 0.0 ? false : true); + + return decoded_value; +} +/// @brief Update the metadata for a signal and the newly received value. +/// +/// This is an implementation of the SignalDecoder type signature, and can be +/// used directly in the can_signal_t.decoder field. +/// +/// This function always flips 'send' to false. +/// +/// @param[in] signal - The details of the signal that contains the state mapping. +/// @param[in] signals - The list of all signals. +/// @param[in] value - The numerical value that will be converted to a boolean. +/// @param[out] send - This output argument will always be set to false, so the caller will +/// know not to publish this value to the pipeline. +/// +/// @return Return value is undefined. +/// +openxc_DynamicField decoder_t::ignoreDecoder(can_signal_t& signal, + const std::vector& signals, float value, bool* send) +{ + if(send) + *send = false; + + openxc_DynamicField decoded_value; + + return decoded_value; +} + +/// @brief Find and return the corresponding string state for a CAN signal's +/// raw integer value. +/// +/// This is an implementation of the SignalDecoder type signature, and can be +/// used directly in the can_signal_t.decoder field. +/// +/// @param[in] signal - The details of the signal that contains the state mapping. +/// @param[in] signals - The list of all signals. +/// @param[in] value - The numerical value that should map to a state. +/// @param[out] send - An output argument that will be set to false if the value should +/// not be sent for any reason. +/// +/// @return Returns a DynamicField with a string value if a matching state is found in +/// the signal. If an equivalent isn't found, send is sent to false and the +/// return value is undefined. +/// +openxc_DynamicField decoder_t::stateDecoder(can_signal_t& signal, + const std::vector& signals, float value, bool* send) +{ + const std::string signal_state = signal.get_states((uint8_t)value); + openxc_DynamicField decoded_value = build_DynamicField(signal_state); + if(signal_state.size() <= 0) + { + *send = false; + ERROR(binder_interface, "stateDecoder: No state found with index: %d", (int)value); + } + return decoded_value; +} + + +/// @brief Parse a signal from a CAN message, apply any required transforations +/// to get a human readable value and public the result to the pipeline. +/// +/// If the can_signal_t has a non-NULL 'decoder' field, the raw CAN signal value +/// will be passed to the decoder before publishing. +/// +/// @param[in] signal - The details of the signal to decode and forward. +/// @param[in] message - The received CAN message that should contain this signal. +/// @param[in] signals - an array of all active signals. +/// +/// The decoder returns an openxc_DynamicField, which may contain a number, +/// string or boolean. +/// +openxc_DynamicField decoder_t::translateSignal(can_signal_t& signal, can_message_t& message, + const std::vector& signals) +{ + float value = decoder_t::parseSignalBitfield(signal, message); + DEBUG(binder_interface, "translateSignal: Decoded message from parseSignalBitfield: %f", value); + + bool send = true; + // Must call the decoders every time, regardless of if we are going to + // decide to send the signal or not. + openxc_DynamicField decoded_value = decoder_t::decodeSignal(signal, + value, signals, &send); + + signal.set_received(true); + signal.set_last_value(value); + return decoded_value; +} + +/// @brief Parse a signal from a CAN message and apply any required +/// transforations to get a human readable value. +/// +/// If the can_signal_t has a non-NULL 'decoder' field, the raw CAN signal value +/// will be passed to the decoder before returning. +/// +/// @param[in] signal - The details of the signal to decode and forward. +/// @param[in] value - The numerical value that will be converted to a boolean. +/// @param[in] signals - an array of all active signals. +/// @param[out] send - An output parameter that will be flipped to false if the value could +/// not be decoded. +/// +/// @return The decoder returns an openxc_DynamicField, which may contain a number, +/// string or boolean. If 'send' is false, the return value is undefined. +/// +openxc_DynamicField decoder_t::decodeSignal( can_signal_t& signal, + float value, const std::vector& signals, bool* send) +{ + SignalDecoder decoder = signal.get_decoder() == nullptr ? + noopDecoder : signal.get_decoder(); + openxc_DynamicField decoded_value = decoder(signal, signals, + value, send); + return decoded_value; +} + +/// @brief Decode a transformed, human readable value from an raw CAN signal +/// already parsed from a CAN message. +/// +/// This is the same as decodeSignal but you must parse the bitfield value of the signal from the CAN +/// message yourself. This is useful if you need that raw value for something +/// else. +/// +/// @param[in] signal - The details of the signal to decode and forward. +/// @param[in] message - Raw CAN message to decode +/// @param[in] signals - an array of all active signals. +/// @param[out] send - An output parameter that will be flipped to false if the value could +/// not be decoded. +/// +openxc_DynamicField decoder_t::decodeSignal( can_signal_t& signal, + const can_message_t& message, const std::vector& signals, bool* send) +{ + float value = parseSignalBitfield(signal, message); + return decodeSignal(signal, value, signals, send); +} + + +/// +/// @brief Decode the payload of an OBD-II PID. +/// +/// This function matches the type signature for a DiagnosticResponseDecoder, so +/// it can be used as the decoder for a DiagnosticRequest. It returns the decoded +/// value of the PID, using the standard formulas (see +/// http://en.wikipedia.org/wiki/OBD-II_PIDs#Mode_01). +/// +/// @param[in] response - the received DiagnosticResponse (the data is in response.payload, +/// a byte array). This is most often used when the byte order is +/// signiticant, i.e. with many OBD-II PID formulas. +/// @param[in] parsed_payload - the entire payload of the response parsed as an int. +/// +/// @return Float decoded value. +/// +float decoder_t::decode_obd2_response(const DiagnosticResponse* response, float parsed_payload) +{ + return diagnostic_decode_obd2_pid(response); +} \ No newline at end of file diff --git a/low-can-binding/can/can-decoder.hpp b/low-can-binding/can/can-decoder.hpp new file mode 100644 index 00000000..ebe1de20 --- /dev/null +++ b/low-can-binding/can/can-decoder.hpp @@ -0,0 +1,49 @@ +/* + * Copyright (C) 2015, 2016 "IoT.bzh" + * Author "Romain Forlot" + * + * 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. + */ + +#pragma once + +#include "can-signals.hpp" +#include "can-message.hpp" +#include "openxc.pb.h" + +class decoder_t +{ +public: + static float parseSignalBitfield(can_signal_t& signal, const can_message_t& message); + + static openxc_DynamicField stateDecoder(can_signal_t& signal, const std::vector& signals, + float value, bool* send); + static openxc_DynamicField booleanDecoder(can_signal_t& signal, const std::vector& signals, + float value, bool* send); + static openxc_DynamicField ignoreDecoder(can_signal_t& signal, const std::vector& signals, + float value, bool* send); + static openxc_DynamicField noopDecoder(can_signal_t& signal, const std::vector& signals, + float value, bool* send); + + static openxc_DynamicField translateSignal(can_signal_t& signal, can_message_t& message, + const std::vector& signals); + + static openxc_DynamicField decodeSignal(can_signal_t& signal, const can_message_t& message, + const std::vector& signals, bool* send); + + static openxc_DynamicField decodeSignal(can_signal_t& signal, float value, + const std::vector& signals, bool* send); + + static float decode_obd2_response(const DiagnosticResponse* response, float parsed_payload); + +}; \ No newline at end of file diff --git a/low-can-binding/can/can-message-definition.cpp b/low-can-binding/can/can-message-definition.cpp new file mode 100644 index 00000000..206d0b0c --- /dev/null +++ b/low-can-binding/can/can-message-definition.cpp @@ -0,0 +1,55 @@ +/* + * Copyright (C) 2015, 2016 "IoT.bzh" + * Author "Romain Forlot" + * + * 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. + */ + +#include "can-message-definition.hpp" + +can_message_definition_t::can_message_definition_t(std::uint8_t message_set_id, const std::string bus) + : message_set_id_{message_set_id}, bus_{bus}, last_value_{CAN_MESSAGE_SIZE} +{} + +can_message_definition_t::can_message_definition_t(std::uint8_t message_set_id, + const std::string bus, + uint32_t id, + frequency_clock_t frequency_clock, + bool force_send_changed) + : message_set_id_{message_set_id}, + bus_{bus}, + id_{id}, + frequency_clock_{frequency_clock}, + force_send_changed_{force_send_changed}, + last_value_{CAN_MESSAGE_SIZE} +{} + +can_message_definition_t::can_message_definition_t(std::uint8_t message_set_id, + const std::string bus, + uint32_t id, + can_message_format_t format, + frequency_clock_t frequency_clock, + bool force_send_changed) + : message_set_id_{message_set_id}, + bus_{bus}, + id_{id}, + format_{format}, + frequency_clock_{frequency_clock}, + force_send_changed_{force_send_changed}, + last_value_{CAN_MESSAGE_SIZE} +{} + +uint32_t can_message_definition_t::get_id() const +{ + return id_; +} \ No newline at end of file diff --git a/low-can-binding/can/can-message-definition.hpp b/low-can-binding/can/can-message-definition.hpp new file mode 100644 index 00000000..98cb2c5d --- /dev/null +++ b/low-can-binding/can/can-message-definition.hpp @@ -0,0 +1,57 @@ +/* + * Copyright (C) 2015, 2016 "IoT.bzh" + * Author "Romain Forlot" + * + * 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. + */ + +/** + * @class can_message_definition_t + * + * @brief The definition of a CAN message. This includes a lot of metadata, so + * to save memory this struct should not be used for storing incoming and + * outgoing CAN messages. + */ + +#pragma once + +#include +#include + +#include "can-bus-dev.hpp" +#include "can-message.hpp" +#include "../utils/timer.hpp" + +class can_message_definition_t +{ +private: + std::uint8_t message_set_id_; + std::string bus_; /*!< bus_ - Address of CAN bus device. */ + uint32_t id_; /*!< id_ - The ID of the message.*/ + can_message_format_t format_; /*!< format_ - the format of the message's ID.*/ + frequency_clock_t frequency_clock_; /*!< clock_ - an optional frequency clock to control the output of this + * message, if sent raw, or simply to mark the max frequency for custom + * handlers to retrieve.*/ + bool force_send_changed_; /*!< force_send_changed_ - If true, regardless of the frequency, it will send CAN + * message if it has changed when using raw passthrough.*/ + std::vector last_value_; /*!< last_value_ - The last received value of the message. Defaults to undefined. + * This is required for the forceSendChanged functionality, as the stack + * needs to compare an incoming CAN message with the previous frame.*/ + +public: + can_message_definition_t(std::uint8_t message_set_id, const std::string bus); + can_message_definition_t(std::uint8_t message_set_id, const std::string bus, uint32_t id, frequency_clock_t frequency_clock, bool force_send_changed); + can_message_definition_t(std::uint8_t message_set_id, const std::string bus, uint32_t id, can_message_format_t format, frequency_clock_t frequency_clock, bool force_send_changed); + + uint32_t get_id() const; +}; diff --git a/low-can-binding/can/can-message-set.cpp b/low-can-binding/can/can-message-set.cpp new file mode 100644 index 00000000..a9f8cf23 --- /dev/null +++ b/low-can-binding/can/can-message-set.cpp @@ -0,0 +1,37 @@ +/* + * Copyright (C) 2015, 2016, 2017 "IoT.bzh" + * Author "Romain Forlot" + * Author "Loïc Collignon" + * + * 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. + */ + +#include "can-message-set.hpp" + +can_message_set_t::can_message_set_t( + uint8_t index, + const std::string& name, + uint8_t can_bus_count, + unsigned short can_message_count, + unsigned short can_signal_count, + unsigned short can_command_count, + unsigned short obd2_signal_count) + : index_{index} + , name_{name} + , can_bus_count_{can_bus_count} + , can_message_count_{can_message_count} + , can_signal_count_{can_signal_count} + , can_command_count_{can_command_count} + , obd2_signal_count_{obd2_signal_count} +{ +} diff --git a/low-can-binding/can/can-message-set.hpp b/low-can-binding/can/can-message-set.hpp new file mode 100644 index 00000000..94e2d8d5 --- /dev/null +++ b/low-can-binding/can/can-message-set.hpp @@ -0,0 +1,47 @@ +/* + * Copyright (C) 2015, 2016, 2017 "IoT.bzh" + * Author "Romain Forlot" + * Author "Loïc Collignon" + * + * 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. + */ + +#pragma once + +#include +#include + +/// @brief A parent wrapper for a particular set of CAN messages and associated +/// CAN buses(e.g. a vehicle or program). +class can_message_set_t +{ +private: + uint8_t index_; /// < A numerical ID for the message set, ideally the index in an array for fast lookup + const std::string name_; /// < The name of the message set. + uint8_t can_bus_count_; /// < The number of CAN buses defined for this message set. + uint16_t can_message_count_; /// < The number of CAN messages (across all buses) defined for this message set. + uint16_t can_signal_count_; /// < The number of CAN signals (across all messages) defined for this message set. + uint16_t can_command_count_; /// < The number of CanCommmands defined for this message set. + uint16_t obd2_signal_count_; /// < The number of obd2 signals defined for this message set. + +public: + can_message_set_t( + uint8_t index, + const std::string& name, + uint8_t can_bus_count, + short unsigned int can_message_count, + short unsigned int can_signal_count, + short unsigned int can_command_count, + short unsigned int obd2_signal_count); + +}; diff --git a/low-can-binding/can/can-message.cpp b/low-can-binding/can/can-message.cpp new file mode 100644 index 00000000..f61de67e --- /dev/null +++ b/low-can-binding/can/can-message.cpp @@ -0,0 +1,264 @@ +/* + * Copyright (C) 2015, 2016 "IoT.bzh" + * Author "Romain Forlot" + * + * 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. + */ + +#include "can-message.hpp" + +#include + +#include "../low-can-binding.hpp" + +/// +/// @brief Class constructor +/// +/// Constructor about can_message_t class. +/// +can_message_t::can_message_t() + : maxdlen_{0}, id_{0}, length_{0}, format_{can_message_format_t::ERROR}, rtr_flag_{false}, flags_{0} +{} + +can_message_t::can_message_t(uint8_t maxdlen, + uint32_t id, + uint8_t length, + can_message_format_t format, + bool rtr_flag, + uint8_t flags, + std::vector data) + : maxdlen_{maxdlen}, + id_{id}, + length_{length}, + format_{format}, + rtr_flag_{rtr_flag}, + flags_{flags}, + data_{data} +{} + +/// +/// @brief Retrieve id_ member value. +/// +/// @return id_ class member +/// +uint32_t can_message_t::get_id() const +{ + return id_; +} + +/// +/// @brief Retrieve RTR flag member. +/// +/// @return rtr_flags_ class member +/// +bool can_message_t::get_rtr_flag_() const +{ + return rtr_flag_; +} + +/// +/// @brief Retrieve format_ member value. +/// +/// @return format_ class member +/// +can_message_format_t can_message_t::get_format() const +{ + if (format_ != can_message_format_t::STANDARD || format_ != can_message_format_t::EXTENDED) + return can_message_format_t::ERROR; + return format_; +} + +/// +/// @brief Retrieve flags_ member value. +/// +/// @return flags_ class member +/// +uint8_t can_message_t::get_flags() const +{ + return flags_; +} + +/// +/// @brief Retrieve data_ member value. +/// +/// @return pointer to the first element +/// of class member data_ +/// +const uint8_t* can_message_t::get_data() const +{ + return data_.data(); +} + +/// +/// @brief Retrieve length_ member value. +/// +/// @return length_ class member +/// +uint8_t can_message_t::get_length() const +{ + return length_; +} + +/// +/// @brief Control whether the object is correctly initialized +/// to be sent over the CAN bus +/// +/// @return true if object correctly initialized and false if not. +/// +bool can_message_t::is_correct_to_send() +{ + if (id_ != 0 && length_ != 0 && format_ != can_message_format_t::ERROR) + { + int i; + for(i=0;i data; + + switch(nbytes) + { + case CANFD_MTU: + DEBUG(binder_interface, "set_max_data_length: Got an CAN FD frame"); + maxdlen = CANFD_MAX_DLEN; + break; + case CAN_MTU: + DEBUG(binder_interface, "set_max_data_length: Got a legacy CAN frame"); + maxdlen = CAN_MAX_DLEN; + break; + default: + ERROR(binder_interface, "set_max_data_length: unsupported CAN frame"); + break; + } + + if (frame.can_id & CAN_ERR_FLAG) + format = can_message_format_t::ERROR; + else if (frame.can_id & CAN_EFF_FLAG) + format = can_message_format_t::EXTENDED; + else + format = can_message_format_t::STANDARD; + + switch(format) + { + case can_message_format_t::STANDARD: + id = frame.can_id & CAN_SFF_MASK; + break; + case can_message_format_t::EXTENDED: + id = frame.can_id & CAN_EFF_MASK; + break; + case can_message_format_t::ERROR: + id = frame.can_id & (CAN_ERR_MASK|CAN_ERR_FLAG); + break; + default: + ERROR(binder_interface, "ERROR: Can set id, not a compatible format or format not set prior to set id."); + break; + } + + /* Overwrite length_ if RTR flags is detected. + * standard CAN frames may have RTR enabled. There are no ERR frames with RTR */ + if (frame.can_id & CAN_RTR_FLAG) + { + rtr_flag = true; + if(frame.len && frame.len <= CAN_MAX_DLC) + { + if(rtr_flag) + length = frame.len& 0xF; + else + { + length = (frame.len > maxdlen) ? maxdlen : frame.len; + } + } + } + else + { + length = (frame.len > maxdlen) ? maxdlen : frame.len; + + /* Flags field only present for CAN FD frames*/ + if(maxdlen == CANFD_MAX_DLEN) + flags = frame.flags & 0xF; + + if (data.capacity() < maxdlen) + data.reserve(maxdlen); + int i; + + data.clear(); + /* maxdlen_ is now set at CAN_MAX_DLEN or CANFD_MAX_DLEN, respectively 8 and 64 bytes*/ + for(i=0;i + * + * 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. + */ + +#pragma once + +#include +#include +#include +#include + +#include "../utils/timer.hpp" +#include "can-message-set.hpp" + +#define CAN_MESSAGE_SIZE 8 + +class can_bus_dev_t; + +/** + * @enum can_message_format_t + * @brief The ID format for a CAN message. + */ +enum class can_message_format_t { + STANDARD, /*!< STANDARD - standard 11-bit CAN arbitration ID. */ + EXTENDED, /*!< EXTENDED - an extended frame, with a 29-bit arbitration ID. */ + ERROR, /*!< ERROR - ERROR code used at initialization to signify that it isn't usable'*/ +}; + +/** + * @class can_message_t + * + * @brief A compact representation of a single CAN message, meant to be used in in/out + * buffers. + */ +class can_message_t { +private: + uint8_t maxdlen_; /*!< maxdlen_ - Max data length deduce from number of bytes read from the socket.*/ + uint32_t id_; /*!< id_ - The ID of the message. */ + uint8_t length_; /*!< length_ - the length of the data array (max 8). */ + can_message_format_t format_; /*!< format_ - the format of the message's ID.*/ + bool rtr_flag_; /*!< rtr_flag_ - Telling if the frame has RTR flag positionned. Then frame hasn't data field*/ + uint8_t flags_; /*!< flags_ - flags of a CAN FD frame. Needed if we catch FD frames.*/ + std::vector data_; /*!< data_ - The message's data field with a size of 8 which is the standard about CAN bus messages.*/ + +public: + can_message_t(); + can_message_t(uint8_t maxdlen, uint32_t id, uint8_t length, can_message_format_t format, bool rtr_flag_, uint8_t flags, std::vector data); + + uint32_t get_id() const; + bool get_rtr_flag_() const; + can_message_format_t get_format() const; + uint8_t get_flags() const; + const uint8_t* get_data() const; + uint8_t get_length() const; + + void set_format(const can_message_format_t new_format); + + bool is_correct_to_send(); + +static can_message_t convert_from_canfd_frame(const struct canfd_frame& frame, size_t nbytes); + canfd_frame convert_to_canfd_frame(); +}; diff --git a/low-can-binding/can/can-signals.cpp b/low-can-binding/can/can-signals.cpp new file mode 100644 index 00000000..6211fa1d --- /dev/null +++ b/low-can-binding/can/can-signals.cpp @@ -0,0 +1,186 @@ +/* + * Copyright (C) 2015, 2016 "IoT.bzh" + * Author "Romain Forlot" + * + * 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. + */ + +#include + +#include "can-signals.hpp" + +#include "../configuration.hpp" +#include "../utils/signals.hpp" +#include "can-decoder.hpp" +#include "../diagnostic/diagnostic-message.hpp" + +std::string can_signal_t::prefix_ = "messages"; + +can_signal_t::can_signal_t(std::uint8_t message_set_id, + std::uint8_t message_id, + std::string generic_name, + uint8_t bit_position, + uint8_t bit_size, + float factor, + float offset, + float min_value, + float max_value, + frequency_clock_t frequency, + bool send_same, + bool force_send_changed, + std::map states, + bool writable, + SignalDecoder decoder, + SignalEncoder encoder, + bool received) + : message_set_id_{ message_set_id } + , message_id_{ message_id } + , generic_name_{ generic_name } + , bit_position_{ bit_position } + , bit_size_{ bit_size } + , factor_{ factor } + , offset_{ offset } + , min_value_{min_value} + , max_value_{max_value} + , frequency_{frequency} + , send_same_{send_same} + , force_send_changed_{force_send_changed} + , states_{states} + , writable_{writable} + , decoder_{decoder} + , encoder_{encoder} + , received_{received} + , last_value_{.0f} +{} + + +const can_message_definition_t& can_signal_t::get_message() const +{ + return configuration_t::instance().get_can_message_definition(message_set_id_, message_id_); +} + +const std::string& can_signal_t::get_generic_name() const +{ + return generic_name_; +} + +const std::string can_signal_t::get_name() const +{ + return prefix_ + "." + generic_name_; +} + +const std::string& can_signal_t::get_prefix() const +{ + return prefix_; +} + +uint8_t can_signal_t::get_bit_position() const +{ + return bit_position_; +} + +uint8_t can_signal_t::get_bit_size() const +{ + return bit_size_; +} + +float can_signal_t::get_factor() const +{ + return factor_; +} + +float can_signal_t::get_offset() const +{ + return offset_; +} + +float can_signal_t::get_min_value() const +{ + return min_value_; +} + +float can_signal_t::get_max_value() const +{ + return max_value_; +} + +frequency_clock_t& can_signal_t::get_frequency() +{ + return frequency_; +} + +bool can_signal_t::get_send_same() const +{ + return send_same_; +} + +bool can_signal_t::get_force_send_changed() const +{ + return force_send_changed_; +} + +const std::map& can_signal_t::get_states() const +{ + return states_; +} + +const std::string can_signal_t::get_states(uint8_t value) +{ + if (value < states_.size()) + return states_[value]; + return std::string(); +} + +size_t can_signal_t::get_state_count() const +{ + return states_.size(); +} + +bool can_signal_t::get_writable() const +{ + return writable_; +} + +SignalDecoder& can_signal_t::get_decoder() +{ + return decoder_; +} + +SignalEncoder& can_signal_t::get_encoder() +{ + return encoder_; +} + +bool can_signal_t::get_received() const +{ + return received_; +} +float can_signal_t::get_last_value() const +{ + return last_value_; +} + +void can_signal_t::set_prefix(std::string val) +{ + prefix_ = val; +} + +void can_signal_t::set_received(bool r) +{ + received_ = r; +} + +void can_signal_t::set_last_value(float val) +{ + last_value_ = val; +} diff --git a/low-can-binding/can/can-signals.hpp b/low-can-binding/can/can-signals.hpp new file mode 100644 index 00000000..34ebeebd --- /dev/null +++ b/low-can-binding/can/can-signals.hpp @@ -0,0 +1,158 @@ +/// +/// Copyright (C) 2015, 2016 "IoT.bzh" +/// Author "Romain Forlot" +/// +/// 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. +/// + +#pragma once + +#include +#include +#include +#include +#include + +#include "openxc.pb.h" +#include "../utils/timer.hpp" +#include "can-bus.hpp" +#include "can-message.hpp" +#include "can-message-definition.hpp" +#include "../diagnostic/diagnostic-message.hpp" + +extern "C" +{ + #include + #include +} + +#define MESSAGE_SET_ID 0 + +class can_signal_t; + +/// +/// @brief The type signature for a CAN signal decoder. +/// +/// A SignalDecoder transforms a raw floating point CAN signal into a number, +/// string or boolean. +/// +/// @param[in] signal - The CAN signal that we are decoding. +/// @param[in] signals - The list of all signals. +/// @param[in] signalCount - The length of the signals array. +/// @param[in] value - The CAN signal parsed from the message as a raw floating point +/// value. +/// @param[out] send - An output parameter. If the decoding failed or the CAN signal should +/// not send for some other reason, this should be flipped to false. +/// +/// @return a decoded value in an openxc_DynamicField struct. +/// +typedef openxc_DynamicField (*SignalDecoder)(can_signal_t& signal, + const std::vector& signals, float value, bool* send); + +/// +/// @brief: The type signature for a CAN signal encoder. +/// +/// A SignalEncoder transforms a number, string or boolean into a raw floating +/// point value that fits in the CAN signal. +/// +/// @param[in] signal - The CAN signal to encode. +/// @param[in] value - The dynamic field to encode. +/// @param[out] send - An output parameter. If the encoding failed or the CAN signal should +/// not be encoded for some other reason, this will be flipped to false. +/// +typedef uint64_t (*SignalEncoder)(can_signal_t* signal, + openxc_DynamicField* value, bool* send); + +class can_signal_t +{ +private: + std::uint8_t message_set_id_; + std::uint8_t message_id_; + std::string generic_name_; /*!< generic_name_ - The name of the signal to be output.*/ + static std::string prefix_; /*!< prefix_ - generic_name_ will be prefixed with it. It has to reflect the used protocol. + * which make easier to sort message when the come in.*/ + uint8_t bit_position_; /*!< bitPosition_ - The starting bit of the signal in its CAN message (assuming + * non-inverted bit numbering, i.e. the most significant bit of + * each byte is 0) */ + uint8_t bit_size_; /*!< bitSize_ - The width of the bit field in the CAN message. */ + float factor_; /*!< factor_ - The final value will be multiplied by this factor. Use 1 if you + * don't need a factor. */ + float offset_; /*!< offset_ - The final value will be added to this offset. Use 0 if you + * don't need an offset. */ + float min_value_; /*!< min_value_ - The minimum value for the processed signal.*/ + float max_value_; /*!< max_value_ - The maximum value for the processed signal. */ + frequency_clock_t frequency_; /*!< frequency_ - A frequency_clock_t struct to control the maximum frequency to + * process and send this signal. To process every value, set the + * clock's frequency to 0. */ + bool send_same_; /*!< send_same_ - If true, will re-send even if the value hasn't changed.*/ + bool force_send_changed_; /*!< force_send_changed_ - If true, regardless of the frequency, it will send the + * value if it has changed. */ + std::map states_; /*!< states_ - A map of CAN signal state describing the mapping + * between numerical and string values for valid states. */ + bool writable_; /*!< writable - True if the signal is allowed to be written from the USB host + * back to CAN. Defaults to false.*/ + SignalDecoder decoder_; /*!< decoder_ - An optional function to decode a signal from the bus to a human + * readable value. If NULL, the default numerical decoder is used. */ + SignalEncoder encoder_; /*!< encoder_ - An optional function to encode a signal value to be written to + * CAN into a byte array. If NULL, the default numerical encoder + * is used. */ + bool received_; /*!< received_ - True if this signal has ever been received.*/ + float last_value_; /*!< lastValue_ - The last received value of the signal. If 'received' is false, + * this value is undefined. */ + +public: + can_signal_t( + std::uint8_t message_set_id, + std::uint8_t message_id, + std::string generic_name, + uint8_t bit_position, + uint8_t bit_size, + float factor, + float offset, + float min_value, + float max_value, + frequency_clock_t frequency, + bool send_same, + bool force_send_changed, + std::map states, + bool writable, + SignalDecoder decoder, + SignalEncoder encoder, + bool received); + + const can_message_definition_t& get_message() const; + const std::string& get_generic_name() const; + const std::string get_name() const; + const std::string& get_prefix() const; + uint8_t get_bit_position() const; + uint8_t get_bit_size() const; + float get_factor() const; + float get_offset() const; + float get_min_value() const; + float get_max_value() const; + frequency_clock_t& get_frequency(); + bool get_send_same() const; + bool get_force_send_changed() const; + const std::map& get_states() const; + const std::string get_states(uint8_t value); + size_t get_state_count() const; + bool get_writable() const; + SignalDecoder& get_decoder(); + SignalEncoder& get_encoder(); + bool get_received() const; + float get_last_value() const; + + void set_prefix(std::string val); + void set_received(bool r); + void set_last_value(float val); +}; \ No newline at end of file diff --git a/low-can-binding/configuration-generated.cpp b/low-can-binding/configuration-generated.cpp new file mode 100644 index 00000000..2e965703 --- /dev/null +++ b/low-can-binding/configuration-generated.cpp @@ -0,0 +1,350 @@ +#include "configuration.hpp" +#include "can/can-decoder.hpp" + +configuration_t::configuration_t() + : can_message_set_{{0, "example", 0, 1, 5, 0, 20}} + , can_message_definition_ + { + { + can_message_definition_t(0, "can0", 0x620, can_message_format_t::STANDARD, frequency_clock_t(0.00000f), true) + } + } + , can_signals_ + { + { + { + 0, + 0, + "doors.coffer.open", + 88, + 1, + 0.00000f, + 0, + 0, + 0, + frequency_clock_t(0.00000f), + true, + false, + { + }, + false, + decoder_t::booleanDecoder, + nullptr, + false + }, + { + 0, + 0, + "doors.driver.open", + 78, + 1, + 0.00000f, + 0, + 0, + 0, + frequency_clock_t(0.00000f), + true, + false, + { + }, + false, + decoder_t::booleanDecoder, + nullptr, + false + }, + { + 0, + 0, + "doors.passenger.open", + 79, + 1, + 0.00000f, + 0, + 0, + 0, + frequency_clock_t(0.00000f), + true, + false, + { + }, + false, + decoder_t::booleanDecoder, + nullptr, + false + }, + { + 0, + 0, + "doors.rearleft.open", + 86, + 1, + 0.00000f, + 0, + 0, + 0, + frequency_clock_t(0.00000f), + true, + false, + { + }, + false, + decoder_t::booleanDecoder, + nullptr, + false + }, + { + 0, + 0, + "doors.rearright.open", + 85, + 4, + 0.00000f, + 0, + 0, + 0, + frequency_clock_t(0.00000f), + true, + false, + { + }, + false, + decoder_t::booleanDecoder, + nullptr, + false + } + } + } + , diagnostic_messages_ + { + { + { + 4, + "engine.load", + 0, + 0, + UNIT::INVALID, + 5.00000f, + decoder_t::decode_obd2_response, + nullptr, + true + }, + { + 5, + "engine.coolant.temperature", + 0, + 0, + UNIT::INVALID, + 1.00000f, + decoder_t::decode_obd2_response, + nullptr, + true + }, + { + 10, + "fuel.pressure", + 0, + 0, + UNIT::INVALID, + 1.00000f, + decoder_t::decode_obd2_response, + nullptr, + true + }, + { + 11, + "intake.manifold.pressure", + 0, + 0, + UNIT::INVALID, + 1.00000f, + decoder_t::decode_obd2_response, + nullptr, + true + }, + { + 12, + "engine.speed", + 0, + 0, + UNIT::INVALID, + 5.00000f, + decoder_t::decode_obd2_response, + nullptr, + true + }, + { + 13, + "vehicle.speed", + 0, + 0, + UNIT::INVALID, + 5.00000f, + decoder_t::decode_obd2_response, + nullptr, + true + }, + { + 15, + "intake.air.temperature", + 0, + 0, + UNIT::INVALID, + 1.00000f, + decoder_t::decode_obd2_response, + nullptr, + true + }, + { + 16, + "mass.airflow", + 0, + 0, + UNIT::INVALID, + 5.00000f, + decoder_t::decode_obd2_response, + nullptr, + true + }, + { + 17, + "throttle.position", + 0, + 0, + UNIT::INVALID, + 5.00000f, + decoder_t::decode_obd2_response, + nullptr, + true + }, + { + 31, + "running.time", + 0, + 0, + UNIT::INVALID, + 1.00000f, + decoder_t::decode_obd2_response, + nullptr, + true + }, + { + 45, + "EGR.error", + 0, + 0, + UNIT::INVALID, + 0.00000f, + decoder_t::decode_obd2_response, + nullptr, + true + }, + { + 47, + "fuel.level", + 0, + 0, + UNIT::INVALID, + 1.00000f, + decoder_t::decode_obd2_response, + nullptr, + true + }, + { + 51, + "barometric.pressure", + 0, + 0, + UNIT::INVALID, + 1.00000f, + decoder_t::decode_obd2_response, + nullptr, + true + }, + { + 76, + "commanded.throttle.position", + 0, + 0, + UNIT::INVALID, + 1.00000f, + decoder_t::decode_obd2_response, + nullptr, + true + }, + { + 82, + "ethanol.fuel.percentage", + 0, + 0, + UNIT::INVALID, + 1.00000f, + decoder_t::decode_obd2_response, + nullptr, + true + }, + { + 90, + "accelerator.pedal.position", + 0, + 0, + UNIT::INVALID, + 5.00000f, + decoder_t::decode_obd2_response, + nullptr, + true + }, + { + 91, + "hybrid.battery-pack.remaining.life", + 0, + 0, + UNIT::INVALID, + 5.00000f, + decoder_t::decode_obd2_response, + nullptr, + true + }, + { + 92, + "engine.oil.temperature", + 0, + 0, + UNIT::INVALID, + 1.00000f, + decoder_t::decode_obd2_response, + nullptr, + true + }, + { + 94, + "engine.fuel.rate", + 0, + 0, + UNIT::INVALID, + 1.00000f, + decoder_t::decode_obd2_response, + nullptr, + true + }, + { + 99, + "engine.torque", + 0, + 0, + UNIT::INVALID, + 1.00000f, + decoder_t::decode_obd2_response, + nullptr, + true + } + } + } +{ +} + +const std::string configuration_t::get_diagnostic_bus() const +{ + return "can0"; +} + + diff --git a/low-can-binding/configuration.cpp b/low-can-binding/configuration.cpp new file mode 100644 index 00000000..8a50cbc4 --- /dev/null +++ b/low-can-binding/configuration.cpp @@ -0,0 +1,156 @@ +/* + * Copyright (C) 2015, 2016 "IoT.bzh" + * Author "Romain Forlot" + * + * 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. + */ + +#include "configuration.hpp" + +#include "utils/signals.hpp" +#include "utils/openxc-utils.hpp" + +/// @brief Return singleton instance of configuration object. +configuration_t& configuration_t::instance() +{ + static configuration_t config; + return config; +} + +can_bus_t& configuration_t::get_can_bus_manager() +{ + return can_bus_manager_; +} + +const std::map>& configuration_t::get_can_bus_devices() +{ + return can_bus_manager_.get_can_devices(); +} + +diagnostic_manager_t& configuration_t::get_diagnostic_manager() +{ + return diagnostic_manager_; +} + +uint8_t configuration_t::get_active_message_set() const +{ + return active_message_set_; +} + +const std::vector& configuration_t::get_can_message_set() +{ + return can_message_set_; +} + +std::vector& configuration_t::get_can_signals() +{ + return can_signals_[active_message_set_]; +} + +std::vector& configuration_t::get_diagnostic_messages() +{ + return diagnostic_messages_[active_message_set_]; +} + +const std::vector& configuration_t::get_can_message_definition() +{ + return can_message_definition_[active_message_set_]; +} + +const can_message_definition_t& configuration_t::get_can_message_definition(std::uint8_t message_set_id, std::uint8_t message_id) +{ + return can_message_definition_[message_set_id][message_id]; +} + +uint32_t configuration_t::get_signal_id(diagnostic_message_t& sig) const +{ + return sig.get_pid(); +} + +uint32_t configuration_t::get_signal_id(can_signal_t& sig) const +{ + return sig.get_message().get_id(); +} + +void configuration_t::set_active_message_set(uint8_t id) +{ + active_message_set_ = id; +} + +/// @brief return diagnostic messages name found searching through diagnostic messages list. +/// +/// @param[in] key - can contain numeric or string value in order to search against +/// can signals or obd2 signals name. +/// @param[out] found_signals - Vector of signals name found. +/// +void configuration_t::find_diagnostic_messages(const openxc_DynamicField &key, std::vector& found_signals) +{ + switch(key.type) + { + case openxc_DynamicField_Type::openxc_DynamicField_Type_STRING: + lookup_signals_by_name(key.string_value, diagnostic_messages_[active_message_set_], found_signals); + break; + case openxc_DynamicField_Type::openxc_DynamicField_Type_NUM: + lookup_signals_by_id(key.numeric_value, diagnostic_messages_[active_message_set_], found_signals); + break; + default: + ERROR(binder_interface, "find_diagnostic_messages: wrong openxc_DynamicField specified. Use openxc_DynamicField_Type_NUM or openxc_DynamicField_Type_STRING type only."); + break; + } + DEBUG(binder_interface, "find_diagnostic_messages: Found %d signal(s)", (int)found_signals.size()); +} + +diagnostic_message_t* configuration_t::get_diagnostic_message(std::string message_name) const +{ + std::vector found; + configuration_t::instance().find_diagnostic_messages(build_DynamicField(message_name), found); + if(! found.empty()) + return found.front(); + return nullptr; +} + +DiagnosticRequest* configuration_t::get_request_from_diagnostic_message(diagnostic_message_t* diag_msg) const +{ + return new DiagnosticRequest(diag_msg->build_diagnostic_request()); +} + +DiagnosticRequest* configuration_t::get_request_from_diagnostic_message(std::string message_name) const +{ + diagnostic_message_t* diag_msg = get_diagnostic_message(message_name); + if( diag_msg != nullptr) + return new DiagnosticRequest(diag_msg->build_diagnostic_request()); + return nullptr; +} + +/// @brief return signals name found searching through CAN signals list. +/// +/// @param[in] key - can contain numeric or string value in order to search against +/// can signals or obd2 signals name. +/// @param[out] found_signals - provided vector to fill with pointer to matched signals. +/// +void configuration_t::find_can_signals(const openxc_DynamicField& key, std::vector& found_signals) +{ + switch(key.type) + { + case openxc_DynamicField_Type::openxc_DynamicField_Type_STRING: + lookup_signals_by_name(std::string(key.string_value), can_signals_[active_message_set_], found_signals); + break; + case openxc_DynamicField_Type::openxc_DynamicField_Type_NUM: + lookup_signals_by_id(key.numeric_value, can_signals_[active_message_set_], found_signals); + break; + default: + ERROR(binder_interface, "find_can_signals: wrong openxc_DynamicField specified. Use openxc_DynamicField_Type_NUM or openxc_DynamicField_Type_STRING type only."); + break; + } + DEBUG(binder_interface, "find_can_signals: Found %d signal(s)", (int)found_signals.size()); +} diff --git a/low-can-binding/configuration.hpp b/low-can-binding/configuration.hpp new file mode 100644 index 00000000..017b148d --- /dev/null +++ b/low-can-binding/configuration.hpp @@ -0,0 +1,120 @@ +/* + * Copyright (C) 2015, 2016 "IoT.bzh" + * Author "Romain Forlot" + * + * 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. + */ + +#pragma once + +#include +#include +#include +#include + +#include "can/can-bus.hpp" +#include "can/can-signals.hpp" +#include "can/can-message.hpp" +#include "diagnostic/diagnostic-manager.hpp" + +#include "low-can-binding.hpp" + +/// +/// @brief Class representing a configuration attached to the binding. +/// +/// It regroups all needed objects instance from other class +/// that will be used along the binding life. It gets a global vision +/// on which signals are implemented for that binding. +/// Here, it is only the definition of the class with predefined accessors +/// methods used in the binding. +/// +/// It will be the reference point to needed objects. +/// +class configuration_t +{ + private: + can_bus_t can_bus_manager_ = can_bus_t( + afb_daemon_rootdir_open_locale( + binder_interface->daemon, "etc/can_buses.json", O_RDONLY, NULL)); ///< instanciate the CAN bus + ///< This will read the configuration file and initialize all CAN devices specified in it. + diagnostic_manager_t diagnostic_manager_; ///< Diagnostic manager use to manage diagnostic message communication. + uint8_t active_message_set_ = 0; ///< Which is the active message set ? Default to 0. + + std::vector can_message_set_; + std::vector> can_message_definition_; + std::vector> can_signals_; + std::vector> diagnostic_messages_; + + configuration_t(); ///< Private constructor with implementation generated by the AGL generator. + + public: + static configuration_t& instance(); + + can_bus_t& get_can_bus_manager(); + + const std::map>& get_can_bus_devices(); + + const std::string get_diagnostic_bus() const; + + diagnostic_manager_t& get_diagnostic_manager() ; + + uint8_t get_active_message_set() const; + + const std::vector& get_can_message_set(); + + std::vector& get_can_signals(); + + std::vector& get_diagnostic_messages(); + + const std::vector& get_signals_prefix() const; + + const std::vector& get_can_message_definition(); + const can_message_definition_t& get_can_message_definition(std::uint8_t message_set_id, std::uint8_t message_id); + + uint32_t get_signal_id(diagnostic_message_t& sig) const; + + uint32_t get_signal_id(can_signal_t& sig) const; + + void set_active_message_set(uint8_t id); + + void find_diagnostic_messages(const openxc_DynamicField &key, std::vector& found_signals); + diagnostic_message_t* get_diagnostic_message(std::string message_name) const; + DiagnosticRequest* get_request_from_diagnostic_message(diagnostic_message_t* diag_msg) const; + DiagnosticRequest* get_request_from_diagnostic_message(std::string message_name) const; + + void find_can_signals(const openxc_DynamicField &key, std::vector& found_signals); + +/* + /// TODO: implement this function as method into can_bus class + /// @brief Pre initialize actions made before CAN bus initialization + /// @param[in] bus A CanBus struct defining the bus's metadata + /// @param[in] writable Configure the controller in a writable mode. If false, it will be configured as "listen only" and will not allow writes or even CAN ACKs. + /// @param[in] buses An array of all CAN buses. + void pre_initialize(can_bus_dev_t* bus, bool writable, can_bus_dev_t* buses, const int busCount); + /// TODO: implement this function as method into can_bus class + /// @brief Post-initialize actions made after CAN bus initialization + /// @param[in] bus A CanBus struct defining the bus's metadata + /// @param[in] writable Configure the controller in a writable mode. If false, it will be configured as "listen only" and will not allow writes or even CAN ACKs. + /// @param[in] buses An array of all CAN buses. + void post_initialize(can_bus_dev_t* bus, bool writable, can_bus_dev_t* buses, const int busCount); + /// TODO: implement this function as method into can_bus class + /// @brief Check if the device is connected to an active CAN bus, i.e. it's received a message in the recent past. + /// @return true if a message was received on the CAN bus within CAN_ACTIVE_TIMEOUT_S seconds. + void logBusStatistics(can_bus_dev_t* buses, const int busCount); + /// TODO: implement this function as method into can_bus class + /// @brief Log transfer statistics about all active CAN buses to the debug log. + /// @param[in] buses An array of active CAN buses. + bool isBusActive(can_bus_dev_t* bus); + */ +}; + diff --git a/low-can-binding/diagnostic/active-diagnostic-request.cpp b/low-can-binding/diagnostic/active-diagnostic-request.cpp new file mode 100644 index 00000000..7ddf1d51 --- /dev/null +++ b/low-can-binding/diagnostic/active-diagnostic-request.cpp @@ -0,0 +1,194 @@ +/* + * Copyright (C) 2015, 2016 "IoT.bzh" + * Author "Romain Forlot" + * + * 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. + */ + +#include +#include + +#include "active-diagnostic-request.hpp" + +#include "../configuration.hpp" + +#define ERROR_PID 0xFF + +std::string active_diagnostic_request_t::prefix_ = "diagnostic_messages"; + +bool active_diagnostic_request_t::operator==(const active_diagnostic_request_t& b) +{ + return (bus_ == b.bus_ && id_ == b.id_ && handle_ == b.handle_); +} + +active_diagnostic_request_t& active_diagnostic_request_t::operator=(const active_diagnostic_request_t& adr) +{ + if (this != &adr) + { + bus_ = adr.bus_; + id_ = adr.id_; + handle_ = adr.handle_; + name_ = adr.name_; + decoder_ = adr.decoder_; + callback_ = adr.callback_; + recurring_ = adr.recurring_; + wait_for_multiple_responses_ = adr.wait_for_multiple_responses_; + in_flight_ = adr.in_flight_; + frequency_clock_ = adr.frequency_clock_; + timeout_clock_ = adr.timeout_clock_; + } + + return *this; +} + +active_diagnostic_request_t::active_diagnostic_request_t() + : bus_{nullptr}, id_{0}, handle_{nullptr}, name_{""}, + decoder_{nullptr}, callback_{nullptr}, recurring_{false}, wait_for_multiple_responses_{false}, + in_flight_{false}, frequency_clock_{frequency_clock_t()}, timeout_clock_{frequency_clock_t()} +{} + +active_diagnostic_request_t::active_diagnostic_request_t(const std::string& bus, DiagnosticRequest* request, + const std::string& name, bool wait_for_multiple_responses, const DiagnosticResponseDecoder decoder, + const DiagnosticResponseCallback callback, float frequencyHz) + : bus_{bus}, id_{request->arbitration_id}, handle_{nullptr}, name_{name}, + decoder_{decoder}, callback_{callback}, recurring_{frequencyHz ? true : false}, wait_for_multiple_responses_{wait_for_multiple_responses}, + in_flight_{false}, frequency_clock_{frequency_clock_t(frequencyHz)}, timeout_clock_{frequency_clock_t(10)} +{} + +uint32_t active_diagnostic_request_t::get_id() const +{ + return id_; +} + +const std::shared_ptr active_diagnostic_request_t::get_can_bus_dev() const +{ + return can_bus_t::get_can_device(bus_); +} + +uint16_t active_diagnostic_request_t::get_pid() const +{ + if (handle_->request.has_pid) + return handle_->request.pid; + return ERROR_PID; +} + +DiagnosticRequestHandle* active_diagnostic_request_t::get_handle() +{ + return handle_; +} + +const std::string active_diagnostic_request_t::get_name() const +{ + return name_; +} + +std::string& active_diagnostic_request_t::get_prefix() +{ + return active_diagnostic_request_t::prefix_; +} + +DiagnosticResponseDecoder& active_diagnostic_request_t::get_decoder() +{ + return decoder_; +} + +DiagnosticResponseCallback& active_diagnostic_request_t::get_callback() +{ + return callback_; +} + +bool active_diagnostic_request_t::get_recurring() const +{ + return recurring_; +} + +bool active_diagnostic_request_t::get_in_flight() const +{ + return in_flight_; +} + +frequency_clock_t& active_diagnostic_request_t::get_frequency_clock() +{ + return frequency_clock_; +} + +frequency_clock_t& active_diagnostic_request_t::get_timeout_clock() +{ + return timeout_clock_; +} + +void active_diagnostic_request_t::set_handle(DiagnosticShims& shims, DiagnosticRequest* request) +{ + handle_ = new DiagnosticRequestHandle(generate_diagnostic_request(&shims, request, nullptr)); +} + +void active_diagnostic_request_t::set_in_flight(bool val) +{ + in_flight_ = val; +} + +/// +/// @brief Check if requested signal name is a diagnostic message. If the name +/// begin with the diagnostic message prefix then true else false. +/// +/// @param[in] name - A signal name. +/// +/// @return true if name began with the diagnostic message prefix else false. +/// +bool active_diagnostic_request_t::is_diagnostic_signal(const std::string& name) +{ + const std::string p = active_diagnostic_request_t::prefix_ + "*"; + if(::fnmatch(p.c_str(), name.c_str(), FNM_CASEFOLD) == 0) + return true; + return false; +} + +/// @brief Check is the request should be sent or not +/// +/// @return true if the request is not running or recurring nor completed, +/// or it's recurring, its clock elapsed +/// so it's time to send another one. +bool active_diagnostic_request_t::should_send() +{ + return !in_flight_ && ( (!recurring_ && !request_completed()) || + (recurring_ && frequency_clock_.elapsed(true)) ); +} + +/// @brief check if the timeout clock has elapsed +/// +/// @return true if elapsed, so it is a timeout, else false. +bool active_diagnostic_request_t::timed_out() +{ + // don't use staggered start with the timeout clock + return timeout_clock_.elapsed(false); +} + +/// @brief Returns true if a sufficient response has been received for a +/// diagnostic request. +/// +/// This is true when at least one response has been received and the request is +/// configured to not wait for multiple responses. Functional broadcast requests +/// may often wish to wait the full 100ms for modules to respond. +bool active_diagnostic_request_t::response_received() const +{ + return !wait_for_multiple_responses_ && + handle_->completed; +} + +/// @brief Returns true if the request has timed out waiting for a response, +/// or a sufficient number of responses has been received. +bool active_diagnostic_request_t::request_completed() +{ + return response_received() || + (timed_out() && diagnostic_request_sent(handle_)); +} diff --git a/low-can-binding/diagnostic/active-diagnostic-request.hpp b/low-can-binding/diagnostic/active-diagnostic-request.hpp new file mode 100644 index 00000000..247eeb17 --- /dev/null +++ b/low-can-binding/diagnostic/active-diagnostic-request.hpp @@ -0,0 +1,122 @@ +/* + * Copyright (C) 2015, 2016 "IoT.bzh" + * Author "Romain Forlot" + * + * 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. + */ + +#pragma once + +#include +#include + +#include "uds/uds.h" +#include "uds/uds_types.h" +#include "../utils/timer.hpp" +#include "../can/can-bus-dev.hpp" + +class active_diagnostic_request_t; +class diagnostic_manager_t; + +/// @brief The signature for an optional function that can apply the neccessary +/// formula to translate the binary payload into meaningful data. +/// +/// @param[in] response - the received DiagnosticResponse (the data is in response.payload, +/// a byte array). This is most often used when the byte order is signiticant, i.e. with many OBD-II PID formulas. +/// @param[in] parsed_payload - the entire payload of the response parsed as an int. +/// +/// @return float value after decoding. +/// +typedef float (*DiagnosticResponseDecoder)(const DiagnosticResponse* response, + float parsed_payload); + +/// @brief: The signature for an optional function to handle a new diagnostic +/// response. +/// +/// @param[in] request - The original diagnostic request. +/// @param[in] response - The response object that was just received. +/// @param[in] parsed_payload - The payload of the response, parsed as a float. +/// +typedef void (*DiagnosticResponseCallback)(const active_diagnostic_request_t* request, + const DiagnosticResponse* response, float parsed_payload); + +/// +/// @brief An active diagnostic request, either recurring or one-time. +/// +/// Will host a diagnostic_message_t class members to describe an on going +/// diagnostic request on the CAN bus. Diagnostic message will be converted to +/// a DiagnosticRequest using ad-hoc method build_diagnostic_request from diagnostic message. +/// Then missing member, that can not be hosted into a DiagnosticRequest struct, will be passed +/// as argument when adding the request to (non)-recurrent vector. Argument will be used to instanciate +/// an active_diagnostic_request_t object before sending it. +/// +class active_diagnostic_request_t { +private: + std::string bus_; ///< bus_ - The CAN bus this request should be made on, or is currently in flight-on + uint32_t id_; ///< id_ - The arbitration ID (aka message ID) for the request. + DiagnosticRequestHandle* handle_; ///< handle_ - A handle for the request to keep track of it between + ///< sending the frames of the request and receiving all frames of the response. + std::string name_; ///< name_ - Human readable name, to be used when publishing received responses. + ///< TODO: If the name is NULL, the published output will use the raw OBD-II response format. + static std::string prefix_; ///< prefix_ - It has to reflect the JSON object which it comes from. It makes easier sorting + ///< incoming CAN messages. + DiagnosticResponseDecoder decoder_; ///< decoder_ - An optional DiagnosticResponseDecoder to parse the payload of responses + ///< to this request. If the decoder is NULL, the output will include the raw payload + ///< instead of a parsed value. + DiagnosticResponseCallback callback_; ///< callback_ - An optional DiagnosticResponseCallback to be notified whenever a + ///< response is received for this request. + bool recurring_; ///< bool recurring_ - If true, this is a recurring request and it will remain as active until explicitly cancelled. + ///< The frequencyClock attribute controls how often a recurrin request is made. + bool wait_for_multiple_responses_; ///< wait_for_multiple_responses_ - False by default, when any response is received for a request + ///< it will be removed from the active list. If true, the request will remain active until the timeout + ///< clock expires, to allow it to receive multiple response (e.g. to a functional broadcast request). + bool in_flight_; ///< in_flight_ - True if the request has been sent and we are waiting for a response. + frequency_clock_t frequency_clock_; ///< frequency_clock_ - A frequency_clock_t object to control the send rate for a + ///< recurring request. If the request is not reecurring, this attribute is not used. + frequency_clock_t timeout_clock_; ///< timeout_clock_ - A frequency_clock_t object to monitor how long it's been since + ///< this request was sent. +public: + bool operator==(const active_diagnostic_request_t& b); + active_diagnostic_request_t& operator=(const active_diagnostic_request_t& adr); + + active_diagnostic_request_t(); + active_diagnostic_request_t(active_diagnostic_request_t&&) = default; + active_diagnostic_request_t(const std::string& bus, DiagnosticRequest* request, + const std::string& name, bool wait_for_multiple_responses, + const DiagnosticResponseDecoder decoder, + const DiagnosticResponseCallback callback, float frequencyHz); + + uint32_t get_id() const; + const std::shared_ptr get_can_bus_dev() const; + DiagnosticRequestHandle* get_handle(); + uint16_t get_pid() const; + const std::string get_name() const; + static std::string& get_prefix(); + DiagnosticResponseDecoder& get_decoder(); + DiagnosticResponseCallback& get_callback(); + bool get_recurring() const; + bool get_in_flight() const; + frequency_clock_t& get_frequency_clock(); + frequency_clock_t& get_timeout_clock(); + + void set_handle(DiagnosticShims& shims, DiagnosticRequest* request); + void set_in_flight(bool val); + + static bool is_diagnostic_signal(const std::string& name); + + bool should_send(); + + bool timed_out(); + bool response_received() const; + bool request_completed(); +}; diff --git a/low-can-binding/diagnostic/diagnostic-manager.cpp b/low-can-binding/diagnostic/diagnostic-manager.cpp new file mode 100644 index 00000000..e3a78d0f --- /dev/null +++ b/low-can-binding/diagnostic/diagnostic-manager.cpp @@ -0,0 +1,618 @@ +/* + * Copyright (C) 2015, 2016 "IoT.bzh" + * Author "Romain Forlot" + * + * 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. + */ + +#include +#include + +#include "diagnostic-manager.hpp" + +#include "../utils/openxc-utils.hpp" +#include "../configuration.hpp" + +#define MAX_RECURRING_DIAGNOSTIC_FREQUENCY_HZ 10 +#define MAX_SIMULTANEOUS_DIAG_REQUESTS 50 +// There are only 8 slots of in flight diagnostic requests +#define MAX_SIMULTANEOUS_IN_FLIGHT_REQUESTS 8 +#define TIMERFD_ACCURACY 0 +#define MICRO 1000000 + +diagnostic_manager_t::diagnostic_manager_t() + : initialized_{false} +{} + +/// @brief Diagnostic manager isn't initialized at launch but after +/// CAN bus devices initialization. For the moment, it is only possible +/// to have 1 diagnostic bus which are the first bus declared in the JSON +/// description file. Configuration instance will return it. +/// +/// this will initialize DiagnosticShims and cancel all active requests +/// if there are any. +bool diagnostic_manager_t::initialize() +{ + // Mandatory to set the bus before intialize shims. + bus_ = configuration_t::instance().get_diagnostic_bus(); + + init_diagnostic_shims(); + reset(); + + initialized_ = true; + DEBUG(binder_interface, "initialize: Diagnostic Manager initialized"); + return initialized_; +} + +/// @brief initialize shims used by UDS lib and set initialized_ to true. +/// It is needed before used the diagnostic manager fully because shims are +/// required by most member functions. +void diagnostic_manager_t::init_diagnostic_shims() +{ + shims_ = diagnostic_init_shims(shims_logger, shims_send, NULL); + DEBUG(binder_interface, "init_diagnostic_shims: Shims initialized"); +} + +/// @brief Force cleanup all active requests. +void diagnostic_manager_t::reset() +{ + DEBUG(binder_interface, "Clearing existing diagnostic requests"); + cleanup_active_requests(true); +} + +/// @brief send function use by diagnostic library. Only one bus used for now +/// so diagnostic request is sent using the default diagnostic bus not matter of +/// which is specified in the diagnostic message definition. +/// +/// @param[in] arbitration_id - CAN arbitration ID to use when send message. OBD2 broadcast ID +/// is 0x7DF by example. +/// @param[in] data - The data payload for the message. NULL is valid if size is also 0. +/// @param[in] size - The size of the data payload, in bytes. +/// +/// @return true if the CAN message was sent successfully. +bool diagnostic_manager_t::shims_send(const uint32_t arbitration_id, const uint8_t* data, const uint8_t size) +{ + std::shared_ptr can_bus_dev = can_bus_t::get_can_device(configuration_t::instance().get_diagnostic_manager().bus_); + if(can_bus_dev != nullptr) + return can_bus_dev->shims_send(arbitration_id, data, size); + ERROR(binder_interface, "shims_send: Can not retrieve diagnostic bus: %s", configuration_t::instance().get_diagnostic_manager().bus_.c_str()); + return false; +} + +/// @brief The type signature for an optional logging function, if the user +/// wishes to provide one. It should print, store or otherwise display the +/// message. +/// +/// message - A format string to log using the given parameters. +/// ... (vargs) - the parameters for the format string. +/// +void diagnostic_manager_t::shims_logger(const char* format, ...) +{ + va_list args; + va_start(args, format); + + char buffer[256]; + vsnprintf(buffer, 256, format, args); + + DEBUG(binder_interface, "shims_logger: %s", buffer); +} + +/// @brief The type signature for a... OpenXC TODO: not used yet. +void diagnostic_manager_t::shims_timer() +{} + +std::shared_ptr diagnostic_manager_t::get_can_bus_dev() +{ + return can_bus_t::get_can_device(bus_); +} + +/// @brief Return diagnostic manager shims member. +DiagnosticShims& diagnostic_manager_t::get_shims() +{ + return shims_; +} + +/// @brief Search for a specific active diagnostic request in the provided requests list +/// and erase it from the vector. This is useful at unsubscription to clean up the list otherwize +/// all received CAN messages will be passed to DiagnosticRequestHandle of all active diagnostic request +/// contained in the vector but no event if connected to, so we will decode uneeded request. +/// +/// @param[in] entry - a pointer of an active_diagnostic_request instance to clean up +/// @param[in] requests_list - a vector where to make the search and cleaning. +void diagnostic_manager_t::find_and_erase(active_diagnostic_request_t* entry, std::vector& requests_list) +{ + auto i = std::find(requests_list.begin(), requests_list.end(), entry); + if ( i != requests_list.end()) + requests_list.erase(i); +} + +// @brief TODO: implement cancel_request if needed... Don't know. +void diagnostic_manager_t::cancel_request(active_diagnostic_request_t* entry) +{ + + /* TODO: implement acceptance filters. + if(entry.arbitration_id_ == OBD2_FUNCTIONAL_BROADCAST_ID) { + for(uint32_t filter = OBD2_FUNCTIONAL_RESPONSE_START; + filter < OBD2_FUNCTIONAL_RESPONSE_START + + OBD2_FUNCTIONAL_RESPONSE_COUNT; + filter++) { + removeAcceptanceFilter(entry.bus_, filter, + CanMessageFormat::STANDARD, getCanBuses(), + getCanBusCount()); + } + } else { + removeAcceptanceFilter(entry.bus_, + entry.arbitration_id_ + + DIAGNOSTIC_RESPONSE_ARBITRATION_ID_OFFSET, + CanMessageFormat::STANDARD, getCanBuses(), getCanBusCount()); + }*/ +} + +/// @brief Cleanup a specific request if it isn't running and get complete. As it is almost +/// impossible to get that state for a recurring request without waiting for that, you can +/// force the cleaning operation. +/// +/// @param[in] entry - the request to clean +/// @param[in] force - Force the cleaning or not ? +void diagnostic_manager_t::cleanup_request(active_diagnostic_request_t* entry, bool force) +{ + if((force || (entry != nullptr && entry->get_in_flight() && entry->request_completed()))) + { + entry->set_in_flight(false); + + char request_string[128] = {0}; + diagnostic_request_to_string(&entry->get_handle()->request, + request_string, sizeof(request_string)); + if(force && entry->get_recurring()) + { + find_and_erase(entry, recurring_requests_); + cancel_request(entry); + DEBUG(binder_interface, "cleanup_request: Cancelling completed, recurring request: %s", request_string); + } + else + { + DEBUG(binder_interface, "cleanup_request: Cancelling completed, non-recurring request: %s", request_string); + find_and_erase(entry, non_recurring_requests_); + cancel_request(entry); + } + } +} + +/// @brief Clean up all requests lists, recurring and not recurring. +/// +/// @param[in] force - Force the cleaning or not ? If true, that will do +/// the same effect as a call to reset(). +void diagnostic_manager_t::cleanup_active_requests(bool force) +{ + for(auto& entry : non_recurring_requests_) + if (entry != nullptr) + cleanup_request(entry, force); + + for(auto& entry : recurring_requests_) + if (entry != nullptr) + cleanup_request(entry, force); +} + +/// @brief Will return the active_diagnostic_request_t pointer for theDiagnosticRequest or nullptr if +/// not found. +/// +/// @param[in] request - Search key, method will go through recurring list to see if it find that request +/// holded by the DiagnosticHandle member. +active_diagnostic_request_t* diagnostic_manager_t::find_recurring_request(const DiagnosticRequest* request) +{ + for (auto& entry : recurring_requests_) + { + if(entry != nullptr) + { + if(diagnostic_request_equals(&entry->get_handle()->request, request)) + { + return entry; + break; + } + } + } + return nullptr; +} + +/// @brief Add and send a new one-time diagnostic request. +/// +/// A one-time (aka non-recurring) request can existing in parallel with a +/// recurring request for the same PID or mode, that's not a problem. +/// +/// For an example, see the docs for addRecurringRequest. This function is very +/// similar but leaves out the frequencyHz parameter. +/// +/// @param[in] request - The parameters for the request. +/// @param[in] name - Human readable name this response, to be used when +/// publishing received responses. TODO: If the name is NULL, the published output +/// will use the raw OBD-II response format. +/// @param[in] wait_for_multiple_responses - If false, When any response is received +/// for this request it will be removed from the active list. If true, the +/// request will remain active until the timeout clock expires, to allow it +/// to receive multiple response. Functional broadcast requests will always +/// waint for the timeout, regardless of this parameter. +/// @param[in] decoder - An optional DiagnosticResponseDecoder to parse the payload of +/// responses to this request. If the decoder is NULL, the output will +/// include the raw payload instead of a parsed value. +/// @param[in] callback - An optional DiagnosticResponseCallback to be notified whenever a +/// response is received for this request. +/// +/// @return true if the request was added successfully. Returns false if there +/// wasn't a free active request entry, if the frequency was too high or if the +/// CAN acceptance filters could not be configured, +bool diagnostic_manager_t::add_request(DiagnosticRequest* request, const std::string name, + bool wait_for_multiple_responses, const DiagnosticResponseDecoder decoder, + const DiagnosticResponseCallback callback) +{ + cleanup_active_requests(false); + + bool added = true; + + if (non_recurring_requests_.size() <= MAX_SIMULTANEOUS_DIAG_REQUESTS) + { + // TODO: implement Acceptance Filter + // if(updateRequiredAcceptanceFilters(bus, request)) { + active_diagnostic_request_t* entry = new active_diagnostic_request_t(bus_, request, name, + wait_for_multiple_responses, decoder, callback, 0); + entry->set_handle(shims_, request); + + char request_string[128] = {0}; + diagnostic_request_to_string(&entry->get_handle()->request, request_string, + sizeof(request_string)); + + find_and_erase(entry, non_recurring_requests_); + DEBUG(binder_interface, "Added one-time diagnostic request on bus %s: %s", + bus_.c_str(), request_string); + + non_recurring_requests_.push_back(entry); + } + else + { + WARNING(binder_interface, "There isn't enough request entry. Vector exhausted %d/%d", (int)non_recurring_requests_.size(), MAX_SIMULTANEOUS_DIAG_REQUESTS); + non_recurring_requests_.resize(MAX_SIMULTANEOUS_DIAG_REQUESTS); + added = false; + } + return added; +} + +bool diagnostic_manager_t::validate_optional_request_attributes(float frequencyHz) +{ + if(frequencyHz > MAX_RECURRING_DIAGNOSTIC_FREQUENCY_HZ) { + DEBUG(binder_interface, "Requested recurring diagnostic frequency %lf is higher than maximum of %d", + frequencyHz, MAX_RECURRING_DIAGNOSTIC_FREQUENCY_HZ); + return false; + } + return true; +} + +/// @brief Add and send a new recurring diagnostic request. +/// +/// At most one recurring request can be active for the same arbitration ID, mode +/// and (if set) PID on the same bus at one time. If you try and call +/// addRecurringRequest with the same key, it will return an error. +/// +/// TODO: This also adds any neccessary CAN acceptance filters so we can receive the +/// response. If the request is to the functional broadcast ID (0x7df) filters +/// are added for all functional addresses (0x7e8 to 0x7f0). +/// +/// Example: +/// +/// // Creating a functional broadcast, mode 1 request for PID 2. +/// DiagnosticRequest request = { +/// arbitration_id: 0x7df, +/// mode: 1, +/// has_pid: true, +/// pid: 2 +/// }; +/// +/// // Add a recurring request, to be sent at 1Hz, and published with the +/// // name "my_pid_request" +/// addRecurringRequest(&getConfiguration()->diagnosticsManager, +/// canBus, +/// &request, +/// "my_pid_request", +/// false, +/// NULL, +/// NULL, +/// 1); +/// +/// @param[in] request - The parameters for the request. +/// @param[in] name - An optional human readable name this response, to be used when +/// publishing received responses. If the name is NULL, the published output +/// will use the raw OBD-II response format. +/// @param[in] wait_for_multiple_responses - If false, When any response is received +/// for this request it will be removed from the active list. If true, the +/// request will remain active until the timeout clock expires, to allow it +/// to receive multiple response. Functional broadcast requests will always +/// waint for the timeout, regardless of this parameter. +/// @param[in] decoder - An optional DiagnosticResponseDecoder to parse the payload of +/// responses to this request. If the decoder is NULL, the output will +/// include the raw payload instead of a parsed value. +/// @param[in] callback - An optional DiagnosticResponseCallback to be notified whenever a +/// response is received for this request. +/// @param[in] frequencyHz - The frequency (in Hz) to send the request. A frequency above +/// MAX_RECURRING_DIAGNOSTIC_FREQUENCY_HZ is not allowed, and will make this +/// function return false. +/// +/// @return true if the request was added successfully. Returns false if there +/// was too much already running requests, if the frequency was too high TODO:or if the +/// CAN acceptance filters could not be configured, +/// +bool diagnostic_manager_t::add_recurring_request(DiagnosticRequest* request, const char* name, + bool wait_for_multiple_responses, const DiagnosticResponseDecoder decoder, + const DiagnosticResponseCallback callback, float frequencyHz) +{ + if(!validate_optional_request_attributes(frequencyHz)) + return false; + + cleanup_active_requests(false); + + bool added = true; + if(find_recurring_request(request) == nullptr) + { + if(recurring_requests_.size() <= MAX_SIMULTANEOUS_DIAG_REQUESTS) + { + sd_event_source *source; + // TODO: implement Acceptance Filter + //if(updateRequiredAcceptanceFilters(bus, request)) { + active_diagnostic_request_t* entry = new active_diagnostic_request_t(bus_, request, name, + wait_for_multiple_responses, decoder, callback, frequencyHz); + entry->set_handle(shims_, request); + + //start_diagnostic_request(&shims_, entry->get_handle()); + //char request_string[128] = {0}; + //diagnostic_request_to_string(&entry->get_handle()->request, request_string, + // sizeof(request_string)); + + uint64_t usec; + sd_event_now(afb_daemon_get_event_loop(binder_interface->daemon), CLOCK_BOOTTIME, &usec); + if(recurring_requests_.size() > 0) + { + DEBUG(binder_interface, "add_recurring_request: Added 100ms to usec to stagger sending requests"); + usec += 100000; + } + + DEBUG(binder_interface, "add_recurring_request: Added recurring diagnostic request (freq: %f) on bus %s at %ld. Event loop state: %d", + frequencyHz, + bus_.c_str(), + usec, + sd_event_get_state(afb_daemon_get_event_loop(binder_interface->daemon))); + + if(sd_event_add_time(afb_daemon_get_event_loop(binder_interface->daemon), &source, + CLOCK_BOOTTIME, usec, TIMERFD_ACCURACY, send_request, request) < 0) + { + ERROR(binder_interface, "add_recurring_request: Request fails to be schedule through event loop"); + added = false; + } + recurring_requests_.push_back(entry); + } + else + { + WARNING(binder_interface, "add_recurring_request: There isn't enough request entry. Vector exhausted %d/%d", (int)recurring_requests_.size(), MAX_SIMULTANEOUS_DIAG_REQUESTS); + recurring_requests_.resize(MAX_SIMULTANEOUS_DIAG_REQUESTS); + added = false; + } + } + else + { + DEBUG(binder_interface, "add_recurring_request: Can't add request, one already exists with same key"); + added = false; + } + return added; +} + +/// @brief Returns true if there are two active requests running for the same arbitration ID. +bool diagnostic_manager_t::conflicting(active_diagnostic_request_t* request, active_diagnostic_request_t* candidate) const +{ + return (candidate->get_in_flight() && candidate != request && + candidate->get_can_bus_dev() == request->get_can_bus_dev() && + candidate->get_id() == request->get_id()); +} + + +/// @brief Returns true if there are no other active requests to the same arbitration ID +/// and if there aren't more than 8 requests in flight at the same time. +bool diagnostic_manager_t::clear_to_send(active_diagnostic_request_t* request) const +{ + int total_in_flight = 0; + for ( auto entry : non_recurring_requests_) + { + if(conflicting(request, entry)) + return false; + if(entry->get_in_flight()) + total_in_flight++; + } + + for ( auto entry : recurring_requests_) + { + if(conflicting(request, entry)) + return false; + if(entry->get_in_flight()) + total_in_flight++; + } + + if(total_in_flight > MAX_SIMULTANEOUS_IN_FLIGHT_REQUESTS) + return false; + return true; +} + +int diagnostic_manager_t::reschedule_request(sd_event_source *s, uint64_t usec, active_diagnostic_request_t* adr) +{ + usec = usec + (uint64_t)(adr->get_frequency_clock().frequency_to_period()); + DEBUG(binder_interface, "send_request: Event loop state: %d. usec: %ld", sd_event_get_state(afb_daemon_get_event_loop(binder_interface->daemon)), usec); + if(sd_event_source_set_time(s, usec) >= 0) + if(sd_event_source_set_enabled(s, SD_EVENT_ON) >= 0) + return 0; + sd_event_source_unref(s); + return -1; +} + +/// @brief Systemd timer event callback use to send CAN messages at regular interval. Depending +/// on the diagnostic message frequency. +/// +/// This should be called from systemd binder event loop and the event is created on add_recurring_request +/// +/// @param[in] s - Systemd event source pointer used to reschedule the new iteration. +/// @param[in] usec - previous call timestamp in microseconds. +/// @param[in] userdata - the DiagnosticRequest struct, use to retrieve the active request from the list. +/// +/// @return positive integer if sent and rescheduled or negative value if something wrong. If an error occurs +/// event will be disabled. +int diagnostic_manager_t::send_request(sd_event_source *s, uint64_t usec, void *userdata) +{ + diagnostic_manager_t& dm = configuration_t::instance().get_diagnostic_manager(); + DiagnosticRequest* request = (DiagnosticRequest*)userdata; + active_diagnostic_request_t* adr = dm.find_recurring_request(request); + + dm.cleanup_active_requests(false); + if(adr != nullptr && adr->get_can_bus_dev() == dm.get_can_bus_dev() && adr->should_send() && + dm.clear_to_send(adr)) + { + adr->get_frequency_clock().tick(); + start_diagnostic_request(&dm.shims_, adr->get_handle()); + if(adr->get_handle()->completed && !adr->get_handle()->success) + { + ERROR(binder_interface, "send_request: Fatal error sending diagnostic request"); + sd_event_source_unref(s); + return -1; + } + + adr->get_timeout_clock().tick(); + adr->set_in_flight(true); + } + + if(adr != nullptr && adr->get_recurring()) + { + return dm.reschedule_request(s, usec, adr); + } + + sd_event_source_unref(s); + NOTICE(binder_interface, "send_request: Request doesn't exist anymore. Canceling.'"); + return -2; +} + +/// @brief Will decode the diagnostic response and build the final openxc_VehicleMessage to return. +/// +/// @param[in] adr - A pointer to an active diagnostic request holding a valid diagnostic handle +/// @param[in] response - The response to decode from which the Vehicle message will be built and returned +/// +/// @return A filled openxc_VehicleMessage or a zeroed struct if there is an error. +openxc_VehicleMessage diagnostic_manager_t::relay_diagnostic_response(active_diagnostic_request_t* adr, const DiagnosticResponse& response) +{ + openxc_VehicleMessage message = build_VehicleMessage(); + float value = (float)diagnostic_payload_to_integer(&response); + if(adr->get_decoder() != nullptr) + { + value = adr->get_decoder()(&response, value); + } + + if((response.success && strnlen(adr->get_name().c_str(), adr->get_name().size())) > 0) + { + // If name, include 'value' instead of payload, and leave of response + // details. + message = build_VehicleMessage(build_SimpleMessage(adr->get_name(), build_DynamicField(value))); + } + else + { + // If no name, send full details of response but still include 'value' + // instead of 'payload' if they provided a decoder. The one case you + // can't get is the full detailed response with 'value'. We could add + // another parameter for that but it's onerous to carry that around. + message = build_VehicleMessage(adr, response, value); + } + + // If not success but completed then the pid isn't supported + if(!response.success) + { + std::vector found_signals; + configuration_t::instance().find_diagnostic_messages( build_DynamicField(adr->get_name()), found_signals ); + found_signals.front()->set_supported(false); + cleanup_request(adr, true); + NOTICE(binder_interface, "relay_diagnostic_response: PID not supported or ill formed. Please unsubscribe from it. Error code : %d", response.negative_response_code); + message = build_VehicleMessage(build_SimpleMessage(adr->get_name(), build_DynamicField("This PID isn't supported by your vehicle."))); + } + + if(adr->get_callback() != nullptr) + { + adr->get_callback()(adr, &response, value); + } + + return message; +} + +/// @brief Will take the CAN message and pass it to the receive functions that will process +/// diagnostic handle for each active diagnostic request then depending on the result we will +/// return pass the diagnostic response to decode it. +/// +/// @param[in] entry - A pointer to an active diagnostic request holding a valid diagnostic handle +/// @param[in] cm - A raw CAN message. +/// +/// @return A pointer to a filled openxc_VehicleMessage or a nullptr if nothing has been found. +openxc_VehicleMessage diagnostic_manager_t::relay_diagnostic_handle(active_diagnostic_request_t* entry, const can_message_t& cm) +{ + DiagnosticResponse response = diagnostic_receive_can_frame(&shims_, entry->get_handle(), cm.get_id(), cm.get_data(), cm.get_length()); + if(response.completed && entry->get_handle()->completed) + { + if(entry->get_handle()->success) + return relay_diagnostic_response(entry, response); + } + else if(!response.completed && response.multi_frame) + { + // Reset the timeout clock while completing the multi-frame receive + entry->get_timeout_clock().tick(); + } + + return build_VehicleMessage(); +} + +/// @brief Find the active diagnostic request with the correct DiagnosticRequestHandle +/// member that will understand the CAN message using diagnostic_receive_can_frame function +/// from UDS-C library. Then decode it with an ad-hoc method. +/// +/// @param[in] cm - Raw CAN message received +/// +/// @return VehicleMessage with decoded value. +openxc_VehicleMessage diagnostic_manager_t::find_and_decode_adr(const can_message_t& cm) +{ + openxc_VehicleMessage vehicle_message = build_VehicleMessage(); + + for ( auto entry : non_recurring_requests_) + { + vehicle_message = relay_diagnostic_handle(entry, cm); + if (is_valid(vehicle_message)) + return vehicle_message; + } + + for ( auto entry : recurring_requests_) + { + vehicle_message = relay_diagnostic_handle(entry, cm); + if (is_valid(vehicle_message)) + return vehicle_message; + } + + return vehicle_message; +} + +/// @brief Tell if the CAN message received is a diagnostic response. +/// Request broadcast ID use 0x7DF and assigned ID goes from 0x7E0 to Ox7E7. That allows up to 8 ECU to respond +/// at the same time. The response is the assigned ID + 0x8, so response ID can goes from 0x7E8 to 0x7EF. +/// +/// @param[in] cm - CAN message received from the socket. +/// +/// @return True if the active diagnostic request match the response. +bool diagnostic_manager_t::is_diagnostic_response(const can_message_t& cm) +{ + if (cm.get_id() >= 0x7e8 && cm.get_id() <= 0x7ef) + return true; + return false; +} diff --git a/low-can-binding/diagnostic/diagnostic-manager.hpp b/low-can-binding/diagnostic/diagnostic-manager.hpp new file mode 100644 index 00000000..3edb2b12 --- /dev/null +++ b/low-can-binding/diagnostic/diagnostic-manager.hpp @@ -0,0 +1,99 @@ +/* + * Copyright (C) 2015, 2016 "IoT.bzh" + * Author "Romain Forlot" + * + * 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. + */ + +#pragma once + +#include +#include +#include + +#include "uds/uds.h" +#include "openxc.pb.h" +#include "../can/can-bus.hpp" +#include "active-diagnostic-request.hpp" + +/// Each CAN bus needs its own set of shim functions, so this should +/// match the maximum CAN controller count. +/// +#define MAX_SHIM_COUNT can_bus_t.get_can_devices().size() +#define DIAGNOSTIC_RESPONSE_ARBITRATION_ID_OFFSET 0x8 + +class active_diagnostic_request_t; + +/// +/// @brief The core structure for running the diagnostics module by the binding. +/// +/// This stores details about the active requests and shims required to connect +/// the diagnostics library to the CAN device. +/// +class diagnostic_manager_t { +protected: + static bool shims_send(const uint32_t arbitration_id, const uint8_t* data, const uint8_t size); + static void shims_logger(const char* m, ...); + static void shims_timer(); + +private: + DiagnosticShims shims_; /*!< shims_ - Shim functions for each CAN bus that plug the diagnostics + * library (uds-c) into the VI's CAN peripheral.*/ + std::string bus_; /*!< bus_ - A pointer to the CAN bus that should be used for all standard OBD-II requests, if the bus is not + * explicitly spcified in the request. Default to the first bus CAN at initialization.*/ + std::vector recurring_requests_; /*!< recurringRequests - A list of active recurring diagnostic requests.*/ + std::vector non_recurring_requests_; /*!< nonrecurringRequests - A list of active one-time diagnostic requests. When a + * response is received for a non-recurring request or it times out, it is removed*/ + bool initialized_; /*!< * initialized - True if the DiagnosticsManager has been initialized with shims. It will interface with the uds-c lib*/ + + void init_diagnostic_shims(); + void reset(); +public: + diagnostic_manager_t(); + + bool initialize(); + + std::shared_ptr get_can_bus_dev(); + DiagnosticShims& get_shims(); + + void find_and_erase(active_diagnostic_request_t* entry, std::vector& requests_list); + void cancel_request(active_diagnostic_request_t* entry); + void cleanup_request(active_diagnostic_request_t* entry, bool force); + void cleanup_active_requests(bool force); + active_diagnostic_request_t* find_recurring_request(const DiagnosticRequest* request); + + void checkSupportedPids(const active_diagnostic_request_t& request, + const DiagnosticResponse& response, float parsedPayload); + + // Subscription parts + bool add_request(DiagnosticRequest* request, const std::string name, + bool waitForMultipleResponses, const DiagnosticResponseDecoder decoder, + const DiagnosticResponseCallback callback); + bool validate_optional_request_attributes(float frequencyHz); + bool add_recurring_request(DiagnosticRequest* request, const char* name, + bool waitForMultipleResponses, const DiagnosticResponseDecoder decoder, + const DiagnosticResponseCallback callback, float frequencyHz); + + // Sendig requests part + bool conflicting(active_diagnostic_request_t* request, active_diagnostic_request_t* candidate) const; + bool clear_to_send(active_diagnostic_request_t* request) const; + int reschedule_request(sd_event_source *s, uint64_t usec, active_diagnostic_request_t* adr); + static int send_request(sd_event_source *s, uint64_t usec, void *userdata); + + // Decoding part + openxc_VehicleMessage relay_diagnostic_response(active_diagnostic_request_t* adr, const DiagnosticResponse& response); + openxc_VehicleMessage relay_diagnostic_handle(active_diagnostic_request_t* entry, const can_message_t& cm); + openxc_VehicleMessage find_and_decode_adr(const can_message_t& cm); + bool is_diagnostic_response(const can_message_t& cm); + +}; diff --git a/low-can-binding/diagnostic/diagnostic-message.cpp b/low-can-binding/diagnostic/diagnostic-message.cpp new file mode 100644 index 00000000..6f615574 --- /dev/null +++ b/low-can-binding/diagnostic/diagnostic-message.cpp @@ -0,0 +1,108 @@ +/* + * Copyright (C) 2015, 2016 "IoT.bzh" + * Author "Romain Forlot" + * + * 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. + */ +#include + +#include "diagnostic-message.hpp" + +#include "../configuration.hpp" +#include "../utils/signals.hpp" + +const char *UNIT_NAMES[10] = { + "POURCENT", + "DEGREES_CELSIUS", + "KPA", + "RPM", + "GRAMS_SEC", + "SECONDS", + "KM", + "KM_H", + "PA", + "NM" +}; + +diagnostic_message_t::diagnostic_message_t(uint8_t pid, const std::string generic_name, const int min, + const int max, enum UNIT unit, float frequency, DiagnosticResponseDecoder decoder, + DiagnosticResponseCallback callback, bool supported) + : pid_{pid}, generic_name_{generic_name}, min_{min}, max_{max}, unit_{unit}, + frequency_{frequency}, decoder_{decoder}, callback_{callback}, supported_{supported} +{} + +uint32_t diagnostic_message_t::get_pid() +{ + return (uint32_t)pid_; +} + +const std::string& diagnostic_message_t::get_generic_name() const +{ + return generic_name_; +} + +const std::string diagnostic_message_t::get_name() const +{ + return active_diagnostic_request_t::get_prefix() + "." + generic_name_; +} + +float diagnostic_message_t::get_frequency() const +{ + return frequency_; +} + +DiagnosticResponseDecoder diagnostic_message_t::get_decoder() const +{ + return decoder_; +} +DiagnosticResponseCallback diagnostic_message_t::get_callback() const +{ + return callback_; +} + +bool diagnostic_message_t::get_supported() const +{ + return supported_; +} + +void diagnostic_message_t::set_supported(bool value) +{ + supported_ = value; +} + +/// +/// @brief Build a DiagnosticRequest struct to be passed +/// to diagnostic manager instance. +/// +const DiagnosticRequest diagnostic_message_t::build_diagnostic_request() +{ + return {/*arbitration_id: */OBD2_FUNCTIONAL_BROADCAST_ID, + /*mode: */0x1, + /*has_pid: */true, + /*pid: */pid_, + /*pid_length: */0, + /*payload[]: */{0}, + /*payload_length: */0, + /*no_frame_padding: */false, + /*DiagnosticRequestType: */DiagnosticRequestType::DIAGNOSTIC_REQUEST_TYPE_PID }; +} + +/// +/// @brief Check if a request is an OBD-II PID request. +/// +/// @return true if the request is a mode 1 request and it has a 1 byte PID. +/// +bool diagnostic_message_t::is_obd2_request(const DiagnosticRequest* request) +{ + return request->mode == 0x1 && request->has_pid && request->pid < 0xff; +} diff --git a/low-can-binding/diagnostic/diagnostic-message.hpp b/low-can-binding/diagnostic/diagnostic-message.hpp new file mode 100644 index 00000000..064904d2 --- /dev/null +++ b/low-can-binding/diagnostic/diagnostic-message.hpp @@ -0,0 +1,79 @@ +/* + * Copyright (C) 2015, 2016 "IoT.bzh" + * Author "Romain Forlot" + * + * 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. + */ + +#pragma once + +#include +#include + +#include "uds/uds.h" +#include "../can/can-message.hpp" +#include "active-diagnostic-request.hpp" + +enum UNIT { + POURCENT, + DEGREES_CELSIUS, + KPA, + RPM, + GRAMS_SEC, + SECONDS, + KM, + KM_H, + PA, + NM, + INVALID +}; + +/// +/// @brief - A representation of an OBD-II PID. +/// +class diagnostic_message_t { + private: + uint8_t pid_; /*!< pid_ - The 1 byte PID.*/ + std::string generic_name_; /*!< generic_name_ - A human readable name to use for this PID when published.*/ + int min_; /*!< min_ - Minimum value that can take this pid */ + int max_; /*!< max_ - Maximum value that can take this pid */ + enum UNIT unit_; /*!< unit_ : Which unit system is used by that pid. See enum UNIT above.*/ + float frequency_; /*!< frequency_ - The frequency to request this PID if supported by the vehicle when automatic, recurring OBD-II requests are enabled.*/ + DiagnosticResponseDecoder decoder_; /*!< decoder_ - An optional DiagnosticResponseDecoder to parse the payload of responses + * to this request. If the decoder is NULL, the output will include the raw payload + * instead of a parsed value.*/ + DiagnosticResponseCallback callback_; /*!< callback_ - An optional DiagnosticResponseCallback to be notified whenever a + * response is received for this request.*/ + + bool supported_; /*!< supported_ - boolean indicating whether this pid is supported by the vehicle or not.*/ + + public: + const char* generic_name = generic_name_.c_str(); + diagnostic_message_t(uint8_t pid, const std::string generic_name, const int min, const int max, enum UNIT unit, float frequency, + DiagnosticResponseDecoder decoder, DiagnosticResponseCallback callback, bool supported); + + uint32_t get_pid(); + const std::string& get_generic_name() const; + const std::string get_name() const; + float get_frequency() const; + DiagnosticResponseDecoder get_decoder() const; + DiagnosticResponseCallback get_callback() const; + bool get_supported() const; + + void set_supported(bool value); + + const DiagnosticRequest build_diagnostic_request(); + + bool is_obd2_response(const can_message_t& can_message); + bool is_obd2_request(const DiagnosticRequest *request); +}; diff --git a/low-can-binding/libs/bitfield-c b/low-can-binding/libs/bitfield-c new file mode 160000 index 00000000..a34745ec --- /dev/null +++ b/low-can-binding/libs/bitfield-c @@ -0,0 +1 @@ +Subproject commit a34745ec93ae0a1d4f1b640dba8fb6702331a8e9 diff --git a/low-can-binding/libs/isotp-c b/low-can-binding/libs/isotp-c new file mode 160000 index 00000000..ee24440b --- /dev/null +++ b/low-can-binding/libs/isotp-c @@ -0,0 +1 @@ +Subproject commit ee24440b7c123ab1b0317e57be33e837a1cb51f1 diff --git a/low-can-binding/libs/nanopb b/low-can-binding/libs/nanopb new file mode 160000 index 00000000..651bdc45 --- /dev/null +++ b/low-can-binding/libs/nanopb @@ -0,0 +1 @@ +Subproject commit 651bdc45f2180b17c132470ff1a3a515dbffaa78 diff --git a/low-can-binding/libs/openxc-message-format b/low-can-binding/libs/openxc-message-format new file mode 160000 index 00000000..d9f54f97 --- /dev/null +++ b/low-can-binding/libs/openxc-message-format @@ -0,0 +1 @@ +Subproject commit d9f54f97578429773421abce98d5f6579717afcc diff --git a/low-can-binding/libs/uds-c b/low-can-binding/libs/uds-c new file mode 160000 index 00000000..ca20db3d --- /dev/null +++ b/low-can-binding/libs/uds-c @@ -0,0 +1 @@ +Subproject commit ca20db3dd978871bbb9f01f3c862b510c03d1dc4 diff --git a/low-can-binding/low-can-binding.cpp b/low-can-binding/low-can-binding.cpp new file mode 100644 index 00000000..07b3f1ea --- /dev/null +++ b/low-can-binding/low-can-binding.cpp @@ -0,0 +1,279 @@ +/* + * Copyright (C) 2015, 2016 "IoT.bzh" + * Author "Romain Forlot" + * Author "Loic Collignon" + * + * 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. + */ + +#include "low-can-binding.hpp" + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "openxc.pb.h" +#include "configuration.hpp" +#include "can/can-bus.hpp" +#include "can/can-signals.hpp" +#include "can/can-message.hpp" +#include "utils/timer.hpp" +#include "utils/signals.hpp" +#include "diagnostic/diagnostic-message.hpp" +#include "utils/openxc-utils.hpp" + +extern "C" +{ + #include +}; + +// Interface between the daemon and the binding +const struct afb_binding_interface *binder_interface; + +void on_no_clients(std::string message) +{ + DiagnosticRequest* diag_req = configuration_t::instance().get_request_from_diagnostic_message(message); + if(diag_req != nullptr) + { + active_diagnostic_request_t* adr = configuration_t::instance().get_diagnostic_manager().find_recurring_request(diag_req); + if( adr != nullptr) + configuration_t::instance().get_diagnostic_manager().cleanup_request(adr, true); + } +} + +///****************************************************************************** +/// +/// Subscription and unsubscription +/// +///*******************************************************************************/ + +static int make_subscription_unsubscription(struct afb_req request, const std::string& sig_name, std::map& s, bool subscribe) +{ + /* Make the subscription or unsubscription to the event */ + if (((subscribe ? afb_req_subscribe : afb_req_unsubscribe)(request, s[sig_name])) < 0) + { + ERROR(binder_interface, "make_subscription_unsubscription: Operation goes wrong for signal: %s", sig_name.c_str()); + return 0; + } + return 1; +} + +static int create_event_handle(const std::string& sig_name, std::map& s) +{ + s[sig_name] = afb_daemon_make_event(binder_interface->daemon, sig_name.c_str()); + if (!afb_event_is_valid(s[sig_name])) + { + ERROR(binder_interface, "create_event_handle: Can't create an event for %s, something goes wrong.", sig_name.c_str()); + return 0; + } + return 1; +} + +static int subscribe_unsubscribe_signal(struct afb_req request, bool subscribe, const std::string& sig) +{ + int ret; + + std::lock_guard subscribed_signals_lock(get_subscribed_signals_mutex()); + std::map& s = get_subscribed_signals(); + if (s.find(sig) != s.end()) + { + if (!afb_event_is_valid(s[sig]) && !subscribe) + { + NOTICE(binder_interface, "subscribe_unsubscribe_signal: Event isn't valid, it can't be unsubscribed."); + ret = -1; + } + /*else + { + // Event it isn't valid annymore, recreate it + ret = create_event_handle(sig, s); + }*/ + } + else + { + /* Event doesn't exist , so let's create it */ + struct afb_event empty_event = {nullptr, nullptr}; + subscribed_signals[sig] = empty_event; + ret = create_event_handle(sig, s); + } + + /* Check whether or not the event handler has been correctly created and + * make the subscription/unsubscription operation is so. + */ + if (ret <= 0) + return ret; + return make_subscription_unsubscription(request, sig, s, subscribe); +} + +/// +/// @fn static int subscribe_unsubscribe_signals(struct afb_req request, bool subscribe, const std::vector& signals) +/// @brief subscribe to all signals in the vector signals +/// +/// @param[in] afb_req request : contain original request use to subscribe or unsubscribe +/// @param[in] subscribe boolean value used to chose between a subscription operation or an unsubscription +/// @param[in] can_signal_t vector with can_signal_t to subscribe +/// +/// @return Number of correctly subscribed signal +/// +static int subscribe_unsubscribe_signals(struct afb_req request, bool subscribe, const std::vector& signals) +{ + int rets = 0; + + //TODO: Implement way to dynamically call the right function no matter + // how much signals types we have. + + for(const std::string& sig : signals) + { + int ret; + if (active_diagnostic_request_t::is_diagnostic_signal(sig)) + { + diagnostic_message_t* diag_msg = configuration_t::instance().get_diagnostic_message(sig); + DiagnosticRequest* diag_req = configuration_t::instance().get_request_from_diagnostic_message(diag_msg); + + // If the requested diagnostic message isn't supported by the car then unssubcribe. + // no matter what we want, worse case will be a fail unsubscription but at least we don't + // poll a PID for nothing. + if(diag_msg->get_supported() && subscribe) + { + float frequency = diag_msg->get_frequency(); + subscribe = configuration_t::instance().get_diagnostic_manager().add_recurring_request( + diag_req, sig.c_str(), false, diag_msg->get_decoder(), diag_msg->get_callback(), (float)frequency); + //TODO: Adding callback requesting ignition status: diag_req, sig.c_str(), false, diagnostic_message_t::decode_obd2_response, diagnostic_message_t::check_ignition_status, frequency); + } + else + { + configuration_t::instance().get_diagnostic_manager().cleanup_request( + configuration_t::instance().get_diagnostic_manager().find_recurring_request(diag_req), true); + WARNING(binder_interface, "Signal: %s isn't supported. Canceling operation.", sig.c_str()); + return -1; + } + } + + ret = subscribe_unsubscribe_signal(request, subscribe, sig); + if(ret <= 0) + return ret; + rets++; + + DEBUG(binder_interface, "Signal: %s subscribed", sig.c_str()); + } + return rets; +} + +static int subscribe_unsubscribe_name(struct afb_req request, bool subscribe, const char *name) +{ + std::vector signals; + int ret = 0; + + openxc_DynamicField search_key = build_DynamicField(std::string(name)); + signals = find_signals(search_key); + if (signals.empty()) + ret = 0; + + ret = subscribe_unsubscribe_signals(request, subscribe, signals); + NOTICE(binder_interface, "Subscribed/unsubscribe correctly to %d/%d signal(s).", ret, (int)signals.size()); + + return ret; +} + +static void subscribe_unsubscribe(struct afb_req request, bool subscribe) +{ + int ok, i, n; + struct json_object *args, *a, *x; + + /* makes the subscription/unsubscription */ + args = afb_req_json(request); + if (args == NULL || !json_object_object_get_ex(args, "event", &a)) { + ok = subscribe_unsubscribe_name(request, subscribe, "*"); + } else if (json_object_get_type(a) != json_type_array) { + ok = subscribe_unsubscribe_name(request, subscribe, json_object_get_string(a)); + } else { + n = json_object_array_length(a); + ok = 0; + for (i = 0 ; i < n ; i++) { + x = json_object_array_get_idx(a, i); + if (subscribe_unsubscribe_name(request, subscribe, json_object_get_string(x))) + ok++; + } + ok = (ok == n); + } + + /* send the report */ + if (ok) + afb_req_success(request, NULL, NULL); + else + afb_req_fail(request, "error", NULL); +} + +extern "C" +{ + static void subscribe(struct afb_req request) + { + subscribe_unsubscribe(request, true); + } + + static void unsubscribe(struct afb_req request) + { + subscribe_unsubscribe(request, false); + } + + static const struct afb_verb_desc_v1 verbs[]= + { + { .name= "subscribe", .session= AFB_SESSION_NONE, .callback= subscribe, .info= "subscribe to notification of CAN bus messages." }, + { .name= "unsubscribe", .session= AFB_SESSION_NONE, .callback= unsubscribe, .info= "unsubscribe a previous subscription." } + }; + + static const struct afb_binding binding_desc { + AFB_BINDING_VERSION_1, + { + "Low level CAN bus service", + "low-can", + verbs + } + }; + + const struct afb_binding *afbBindingV1Register (const struct afb_binding_interface *itf) + { + binder_interface = itf; + + return &binding_desc; + } + + /// @brief Initialize the binding. + /// + /// @param[in] service Structure which represent the Application Framework Binder. + /// + /// @return Exit code, zero if success. + int afbBindingV1ServiceInit(struct afb_service service) + { + can_bus_t& can_bus_manager = configuration_t::instance().get_can_bus_manager(); + + /// Initialize CAN socket + if(can_bus_manager.init_can_dev() == 0) + { + can_bus_manager.start_threads(); + + /// Initialize Diagnostic manager that will handle obd2 requests. + /// We pass by default the first CAN bus device to its Initialization. + /// TODO: be able to choose the CAN bus device that will be use as Diagnostic bus. + if(configuration_t::instance().get_diagnostic_manager().initialize()) + return 0; + } + + ERROR(binder_interface, "There was something wrong with CAN device Initialization. Check your config file maybe"); + return 1; + } +}; diff --git a/low-can-binding/low-can-binding.hpp b/low-can-binding/low-can-binding.hpp new file mode 100644 index 00000000..ed5741d8 --- /dev/null +++ b/low-can-binding/low-can-binding.hpp @@ -0,0 +1,33 @@ +/* + * Copyright (C) 2015, 2016 "IoT.bzh" + * Author "Romain Forlot" + * Author "Loic Collignon" + * + * 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. + */ + +#pragma once + +#include +#include + +extern "C" +{ + #include +}; + +extern "C" struct afb_binding_interface; + +extern const struct afb_binding_interface *binder_interface; + +void on_no_clients(std::string message); \ No newline at end of file diff --git a/low-can-binding/packaging/wgt/config.xml b/low-can-binding/packaging/wgt/config.xml new file mode 100644 index 00000000..d735ce2b --- /dev/null +++ b/low-can-binding/packaging/wgt/config.xml @@ -0,0 +1,11 @@ + + + @PROJECT_NAME@ + + + This is a demo application used to control and dialog with HVAC system + Romain Forlot <romain.forlot@iot.bzh> + APL 2.0 + + + diff --git a/low-can-binding/packaging/wgt/etc/can_buses.json b/low-can-binding/packaging/wgt/etc/can_buses.json new file mode 100644 index 00000000..c4292df2 --- /dev/null +++ b/low-can-binding/packaging/wgt/etc/can_buses.json @@ -0,0 +1,3 @@ +{ + "canbus": "can0" +} diff --git a/low-can-binding/packaging/wgt/icon.png b/low-can-binding/packaging/wgt/icon.png new file mode 100644 index 00000000..9bd6a6e4 Binary files /dev/null and b/low-can-binding/packaging/wgt/icon.png differ diff --git a/low-can-binding/subCMakeLists.txt b/low-can-binding/subCMakeLists.txt new file mode 100644 index 00000000..23869eff --- /dev/null +++ b/low-can-binding/subCMakeLists.txt @@ -0,0 +1,135 @@ +########################################################################### +# Copyright 2016 IoT.bzh +# +# author: José Bollo +# author: Stéphane Desneux +# +# 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. +########################################################################### + +include(GNUInstallDirs) + +set(TARGET "root@192.168.1.206") +set(PROJECT_VERSION "0.1") +set(PROJECT_ICON "icon.png") +set(PROJECT_LIBDIR "libs") + +set(CMAKE_BUILD_TYPE Debug) + +########################################################################### + +link_libraries(-Wl,--as-needed -Wl,--gc-sections) + +add_compile_options(-Wall -Wextra -Wconversion) +add_compile_options(-Wno-unused-parameter) # frankly not using a parameter does it care? +add_compile_options(-Werror=maybe-uninitialized) +add_compile_options(-Werror=implicit-function-declaration) +add_compile_options(-ffunction-sections -fdata-sections) +add_compile_options(-Wl,--as-needed -Wl,--gc-sections) +add_compile_options(-fPIC) +add_compile_options(-D_REENTRANT) + +set(CMAKE_C_FLAGS_PROFILING "-g -O0 -pg -Wp,-U_FORTIFY_SOURCE") +set(CMAKE_C_FLAGS_DEBUG "-g -O0 -ggdb -Wp,-U_FORTIFY_SOURCE") +set(CMAKE_C_FLAGS_RELEASE "-g -O0 -Wall -Werror") +set(CMAKE_C_FLAGS_CCOV "-g -O0 --coverage") + +set(CMAKE_CXX_FLAGS_PROFILING "-g -O0 -std=c++11 -pg -Wp,-U_FORTIFY_SOURCE") +set(CMAKE_CXX_FLAGS_DEBUG "-g -O0 -std=c++11 -ggdb -Wp,-U_FORTIFY_SOURCE") +set(CMAKE_CXX_FLAGS_RELEASE "-g -O2 -std=c++11") +set(CMAKE_CXX_FLAGS_CCOV "-g -O2 -std=c++11 --coverage") + +########################################################################### + +include(FindPkgConfig) + +pkg_check_modules(EXTRAS REQUIRED json-c libsystemd afb-daemon) +add_compile_options(${EXTRAS_CFLAGS}) +add_compile_options(${EXTRAS_CXXFLAGS}) + +# Needed to compile openxc-message-format library. +# +# The reason you need to do this is that some of your messages contain tag +# numbers or field sizes that are larger than what can fit in the default +# 8 bit descriptors. +add_definitions(-DPB_FIELD_16BIT) + +# Needed extra directories to hit the required headers files. +include_directories(${EXTRAS_INCLUDE_DIRS} ${PROJECT_SOURCE_DIR} ${PROJECT_LIBDIR}/openxc-message-format/gen/cpp ${PROJECT_LIBDIR}/nanopb/ ${PROJECT_LIBDIR}/uds-c/src ${PROJECT_LIBDIR}/bitfield-c/src ${PROJECT_LIBDIR}/isotp-c/src) +link_libraries(${EXTRAS_LIBRARIES}) +########################################################################### +# the library used by the binding : openxc, bitfield, uds, isotp + +# Bindings to compile +# -------------------- +file(GLOB filelist "${PROJECT_LIBDIR}/*") +foreach(filename ${filelist}) + if(IS_DIRECTORY ${filename}) + message(STATUS "${filename}") + file(GLOB_RECURSE c_list "*.[chpx]") + string(REGEX REPLACE "^.*\/(.*)$" "\\1" LIB_NAME ${filename}) + add_library(${LIB_NAME} STATIC ${c_list}) + endif(IS_DIRECTORY ${filename}) +endforeach() + +#add_library(bitfield STATIC ${PROJECT_LIBDIR}/bitfield-c/src/bitfield/8byte.c ${PROJECT_LIBDIR}/bitfield-c/src/bitfield/bitarray.c ${PROJECT_LIBDIR}/bitfield-c/src/bitfield/bitfield.c ${PROJECT_LIBDIR}/bitfield-c/src/canutil/read.c ${PROJECT_LIBDIR}/bitfield-c/src/canutil/write.c) +#add_library(isotp STATIC ${PROJECT_LIBDIR}/isotp-c/src/isotp/isotp.c ${PROJECT_LIBDIR}/isotp-c/src/isotp/receive.c ${PROJECT_LIBDIR}/isotp-c/src/isotp/send.c) +#add_library(uds STATIC ${PROJECT_LIBDIR}/uds-c/src/uds/extras.c ${PROJECT_LIBDIR}/uds-c/src/uds/uds.c) +#add_library(openxc STATIC ${PROJECT_LIBDIR}/openxc-message-format/gen/cpp/openxc.pb.c ${PROJECT_LIBDIR}/nanopb/pb_encode.c ${PROJECT_LIBDIR}/nanopb/pb_decode.c ${PROJECT_LIBDIR}/nanopb/pb_common.c) +########################################################################### +# the binding for afb + +message(STATUS "Creation of ${PROJECT_NAME} binding for AFB-DAEMON") +########################################################################### +add_library(${PROJECT_NAME} MODULE ${PROJECT_NAME}.cpp configuration.cpp configuration-generated.cpp + can/can-bus.cpp can/can-bus-dev.cpp can/can-message-set.cpp can/can-message-definition.cpp can/can-message.cpp can/can-signals.cpp can/can-decoder.cpp + diagnostic/diagnostic-message.cpp diagnostic/diagnostic-manager.cpp diagnostic/active-diagnostic-request.cpp + utils/signals.cpp utils/openxc-utils.cpp utils/timer.cpp utils/socket.cpp) +target_link_libraries(${PROJECT_NAME} pthread bitfield-c uds-c isotp-c openxc-message-format) + +set_target_properties(${PROJECT_NAME} PROPERTIES + PREFIX "" + LINK_FLAGS "-Wl,--version-script=${CMAKE_CURRENT_SOURCE_DIR}/export.map" +) + +########################################################################### +# WGT packaging + +message(STATUS "Creation of ${PROJECT_NAME}.wgt package for AppFW") +########################################################################### +configure_file(config.xml.in config.xml) +configure_file(can_buses.json.in can_buses.json) + +add_custom_command( + OUTPUT ${PROJECT_NAME}.wgt + DEPENDS ${PROJECT_NAME} bitfield isotp uds openxc config.xml.in can_buses.json.in + COMMAND rm -rf package + COMMAND mkdir -p package/${PROJECT_LIBDIR} package/htdocs package/etc + COMMAND cp config.xml package/ + COMMAND cp can_buses.json package/etc + COMMAND cp ${CMAKE_CURRENT_SOURCE_DIR}/${PROJECT_ICON} package/icon.png + COMMAND cp ${PROJECT_NAME}.so package/libs + COMMAND wgtpkg-pack -f -o ${PROJECT_NAME}.wgt package +) +add_custom_target(widget ALL DEPENDS ${PROJECT_NAME}.wgt) + +########################################################################### +# WGT install + +#message(STATUS "Creation of ${PROJECT_NAME}.wgt package for AppFW") +########################################################################### +install(CODE "execute_process( + COMMAND scp -r src/${PROJECT_NAME}.wgt ${CMAKE_SOURCE_DIR} ${TARGET}:/tmp)" + CODE "execute_process( + COMMAND ssh ${TARGET} \"/usr/bin/afm-util remove ${PROJECT_NAME}@${PROJECT_VERSION} && /usr/bin/afm-util install /tmp/${PROJECT_NAME}.wgt\")" + ) diff --git a/low-can-binding/utils/config-parser.cpp b/low-can-binding/utils/config-parser.cpp new file mode 100644 index 00000000..e73b0f94 --- /dev/null +++ b/low-can-binding/utils/config-parser.cpp @@ -0,0 +1,84 @@ +/* + * Copyright (C) 2015, 2016 ,2017 "IoT.bzh" + * Author "Romain Forlot" + * + * 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. + */ + +namespace utils +{ + config_parser_t::config_parser_t(int conf_file) + : conf_file_{conf_file}, devices_name{} + {} + + /// @brief read the conf_file_ and will parse json objects + /// in it searching for canbus objects devices name. + /// + /// @return Vector of can bus device name string. + void can_bus_t::read_conf() + { + FILE *fd = fdopen(conf_file_, "r"); + if (fd) + { + std::fseek(fd, 0, SEEK_END); + config_content_.resize(std::ftell(fd)); + std::rewind(fd); + std::fread(&config_content_[0], 1, config_content_.size(), fd); + std::fclose(fd); + + DEBUG(binder_interface, "Configuration file content : %s", config_content_.c_str()); + } + ERROR(binder_interface, "Problem at reading the conf file"); + } + + void parse_devices_name() + { + json_object *jo, *canbus; + const char* taxi; + + jo = json_tokener_parse(config_content_.c_str()); + + if (jo == NULL || !json_object_object_get_ex(jo, "canbus", &canbus)) + { + ERROR(binder_interface, "Can't find canbus node in the configuration file. Please review it."); + devices_name_.clear(); + } + else if (json_object_get_type(canbus) != json_type_array) + { + taxi = json_object_get_string(canbus); + DEBUG(binder_interface, "Can bus found: %s", taxi); + devices_name_.push_back(std::string(taxi)); + } + else + { + int n, i; + n = json_object_array_length(canbus); + for (i = 0 ; i < n ; i++) + devices_name_.push_back(json_object_get_string(json_object_array_get_idx(canbus, i))); + } + } + + /// @brief Public method to access devices_name_ vector. If vector size equal 0 + /// then it will parses the configuration file content to fill it. It could be empty even + /// after parsing if content file just don't have a correct "canbus" directive so you + /// have to test the returned value. + /// + /// @return A const vector with string of linux CAN devices. + const std::vector& get_devices_name() + { + if(devices_name_.empty()) + parse_devices_name(); + + return devices_name_; + } +} \ No newline at end of file diff --git a/low-can-binding/utils/config-parser.hpp b/low-can-binding/utils/config-parser.hpp new file mode 100644 index 00000000..e6bd9d22 --- /dev/null +++ b/low-can-binding/utils/config-parser.hpp @@ -0,0 +1,43 @@ +/* + * Copyright (C) 2015, 2016 ,2017 "IoT.bzh" + * Author "Romain Forlot" + * + * 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. + */ + +#pragma once + +#include +#include +#include +#include + +#include + +namespace utils +{ + class config_parser_t + { + private: + int conf_file_; /*!< conf_file_ - file that handle the binding configuration file */ + std::string config_content_; /*!< config_content_ - String that contains the content of config file */ + std::vector devices_name_; /*!< devices_name - Found devices name after reading configuration file */ + + void parse_devices_name(); + public: + config_parser_t(int conf_file); + + void read_conf(); + std::vector get_devices_name(); + }; +} diff --git a/low-can-binding/utils/openxc-utils.cpp b/low-can-binding/utils/openxc-utils.cpp new file mode 100644 index 00000000..52b49d29 --- /dev/null +++ b/low-can-binding/utils/openxc-utils.cpp @@ -0,0 +1,282 @@ +/* + * Copyright (C) 2015, 2016 "IoT.bzh" + * Author "Romain Forlot" + * Author "Loic Collignon" + * + * 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. + */ + +#include "openxc-utils.hpp" + +#include "../configuration.hpp" + +/// +/// @brief Build a specific VehicleMessage containing a DiagnosticResponse. +/// +/// @param[in] request - Original request use to retrieve decoder and callback +/// @param[in] response - Response to the request that will be decoded if decoder set +/// and put into the DiagnosticResponse of the VehicleMessage. +/// @param[in] parsed_value - raw parsed value of the payload from CAN message +/// +/// @return a vehicle message including simple message that will be convert into +/// a JSON object before being pushed to the subscribers +/// +openxc_VehicleMessage build_VehicleMessage(active_diagnostic_request_t* request, const DiagnosticResponse& response, float parsed_value) +{ + openxc_VehicleMessage message; + + message.has_type = true; + message.type = openxc_VehicleMessage_Type::openxc_VehicleMessage_Type_DIAGNOSTIC; + message.has_diagnostic_response = true; + message.diagnostic_response.has_bus = true; + message.diagnostic_response.bus = configuration_t::instance().get_diagnostic_manager().get_can_bus_dev()->get_address(); + message.diagnostic_response.has_message_id = true; + + if(request->get_id() != OBD2_FUNCTIONAL_BROADCAST_ID) + { + message.diagnostic_response.message_id = response.arbitration_id + - DIAGNOSTIC_RESPONSE_ARBITRATION_ID_OFFSET; + } + else + { + // must preserve responding arb ID for responses to functional broadcast + // requests, as they are the actual module address and not just arb ID + + // 8. + message.diagnostic_response.message_id = response.arbitration_id; + } + + message.diagnostic_response.has_mode = true; + message.diagnostic_response.mode = response.mode; + message.diagnostic_response.has_pid = response.has_pid; + if(message.diagnostic_response.has_pid) + message.diagnostic_response.pid = response.pid; + message.diagnostic_response.has_success = true; + message.diagnostic_response.success = response.success; + message.diagnostic_response.has_negative_response_code = !response.success; + message.diagnostic_response.negative_response_code = + response.negative_response_code; + + if(response.payload_length > 0) + { + if(request->get_decoder() != nullptr) + { + message.diagnostic_response.has_value = true; + message.diagnostic_response.value = parsed_value; + } + else + { + message.diagnostic_response.has_payload = true; + ::memcpy(message.diagnostic_response.payload.bytes, response.payload, + response.payload_length); + message.diagnostic_response.payload.size = response.payload_length; + } + } + + return message; +} + +/// +/// @brief Build a specific VehicleMessage containing a SimpleMessage. +/// +/// @param[in] message - simple message to include into openxc_VehicleMessage +/// +/// @return a vehicle message including simple message that will be convert into +/// a JSON object before being pushed to the subscribers +/// +openxc_VehicleMessage build_VehicleMessage(const openxc_SimpleMessage& message) +{ + openxc_VehicleMessage v; + + v.has_type = true, + v.type = openxc_VehicleMessage_Type::openxc_VehicleMessage_Type_SIMPLE; + v.has_simple_message = true; + v.simple_message = message; + v.has_timestamp = true; + v.timestamp = system_time_ms(); + + return v; +} + +/// +/// @brief Build an empty VehicleMessage that isn't usable by at least the struct +/// is initialized for the most part and can be use to check a false return value. +/// +/// @return A VehicleMessage with all boolean value to false. +/// +openxc_VehicleMessage build_VehicleMessage() +{ + openxc_VehicleMessage v; + + ::memset(&v, 0, sizeof(openxc_VehicleMessage)); + return v; +} + +bool is_valid(const openxc_VehicleMessage& v) +{ + if (v.has_type == false && + v.has_can_message == false && + v.has_simple_message == false && + v.has_diagnostic_response == false && + v.has_control_command == false && + v.has_command_response == false && + v.has_timestamp == false) + return false; + return true; +} + +/// +/// @brief Build an openxc_SimpleMessage associating a name to an openxc_DynamicField +/// +/// @param[in] name - const string reference name to assign to the created SimpleMessage +/// this will set has_name member to true and assign name to the name member. Maximum size for name is +/// set to 100 char. +/// @param[in] value - const reference with DynamicField to assign to SimpleMessage +/// value. +/// +/// @return an openxc_SimpleMessage struct initialized with name and value provided. +/// +openxc_SimpleMessage build_SimpleMessage(const std::string& name, const openxc_DynamicField& value) +{ + openxc_SimpleMessage s; + + s.has_name = true; + ::strncpy(s.name, name.c_str(), 100); + s.has_value = true; + s.value = value; + + return s; +} + +/// +/// @brief Build an openxc_DynamicField with a string value +/// +/// @param[in] value - const string reference value to assign to builded +/// openxc_DynamicField. +/// +/// @return openxc_DynamicField initialized with a string value. +/// +openxc_DynamicField build_DynamicField(const std::string& value) +{ + openxc_DynamicField d; + d.has_type = true; + d.type = openxc_DynamicField_Type_STRING; + + d.has_string_value = true; + d.has_numeric_value = false; + d.has_boolean_value = false; + ::strncpy(d.string_value, value.c_str(), 100); + + return d; +} + +/// +/// @fn openxc_DynamicField build_DynamicField(double value); +/// +/// @brief Build an openxc_DynamicField with a double value +/// +/// @param[in] value - double value to assign to builded openxc_DynamicField. +/// +/// @return openxc_DynamicField initialized with a double value. +/// +openxc_DynamicField build_DynamicField(double value) +{ + openxc_DynamicField d; + d.has_type = true; + d.type = openxc_DynamicField_Type_NUM; + + d.has_string_value = false; + d.has_numeric_value = true; + d.has_boolean_value = false; + d.numeric_value = value; + + return d; +} + +/// +/// @brief Build an openxc_DynamicField with a boolean value +/// +/// @param[in] value - boolean value to assign to builded openxc_DynamicField. +/// +/// @return openxc_DynamicField initialized with a boolean value. +/// +openxc_DynamicField build_DynamicField(bool value) +{ + openxc_DynamicField d; + d.has_type = true; + d.type = openxc_DynamicField_Type_BOOL; + + d.has_string_value = false; + d.has_numeric_value = false; + d.has_boolean_value = true; + d.boolean_value = value; + + return d; +} + +/// +/// @brief Extract the simple message value from an openxc_VehicleMessage +/// and return it. If there isn't SimpleMessage in the VehicleMessage then +/// returned value will be a SimpleMessage with all field set at false. +/// DynamicField from SimpleMessage will be boolean DynamicField set to false too. +/// +/// @param[in] v_msg - const reference to openxc_VehicleMessage +/// +/// @return A simpleMessage from the provided VehicleMessage. +/// +openxc_SimpleMessage get_simple_message(const openxc_VehicleMessage& v_msg) +{ + if (v_msg.has_simple_message) + return v_msg.simple_message; + + openxc_SimpleMessage s_msg = { false, "", false, build_DynamicField(false), false, build_DynamicField(false)}; + return s_msg; +} + +/// +/// @brief Make a JSON object from a DynamicField +/// +/// @param[in] field - openxc_DynamicField struct to convert into +/// a json object. +/// @param[out] value - pointer to the object to set up. +/// +void jsonify_DynamicField(const openxc_DynamicField& field, json_object* value) +{ + if(field.has_numeric_value) + json_object_object_add(value, "value", json_object_new_double(field.numeric_value)); + else if(field.has_boolean_value) + json_object_object_add(value, "value", json_object_new_boolean(field.boolean_value)); + else if(field.has_string_value) + json_object_object_add(value, "value", json_object_new_string(field.string_value)); +} + +/// +/// @brief Make a JSON object from a SimpleMessage +/// +/// @param[in] s_msg - const reference to an openxc_SimpleMessage +/// struct to convert into a json object. +/// @param[out] json - pointer with the DynamicField converted into json object +/// +/// @return True if SimpleMessage has been transformed into json object +/// and false if not. In such case, a json object is returned { "error": "error msg"} +/// +bool jsonify_simple(const openxc_SimpleMessage& s_msg, json_object* json) +{ + if(s_msg.has_name) + { + json_object_object_add(json, "name", json_object_new_string(s_msg.name)); + jsonify_DynamicField(s_msg.value, json); + return true; + } + json_object_object_add(json, "error", json_object_new_string("openxc_SimpleMessage doesn't have name'")); + return false; +} \ No newline at end of file diff --git a/low-can-binding/utils/openxc-utils.hpp b/low-can-binding/utils/openxc-utils.hpp new file mode 100644 index 00000000..d36b359b --- /dev/null +++ b/low-can-binding/utils/openxc-utils.hpp @@ -0,0 +1,42 @@ +/* + * Copyright (C) 2015, 2016 "IoT.bzh" + * Author "Romain Forlot" + * Author "Loic Collignon" + * + * 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. + */ + +#pragma once + +#include +#include +#include + +#include "openxc.pb.h" +#include "../diagnostic/active-diagnostic-request.hpp" + +openxc_VehicleMessage build_VehicleMessage(active_diagnostic_request_t* request, const DiagnosticResponse& response, float parsed_value); +openxc_VehicleMessage build_VehicleMessage(const openxc_SimpleMessage& message); +openxc_VehicleMessage build_VehicleMessage(); +bool is_valid(const openxc_VehicleMessage& v); + +openxc_SimpleMessage build_SimpleMessage(const std::string& name, const openxc_DynamicField& value); +openxc_DynamicField build_DynamicField(const std::string& value); +openxc_DynamicField build_DynamicField(double value); +openxc_DynamicField build_DynamicField(bool value); + +openxc_SimpleMessage get_simple_message(const openxc_VehicleMessage& v_msg); + +void jsonify_DynamicField(const openxc_DynamicField& field, json_object* value); + +bool jsonify_simple(const openxc_SimpleMessage& s_msg, json_object* json); \ No newline at end of file diff --git a/low-can-binding/utils/signals.cpp b/low-can-binding/utils/signals.cpp new file mode 100644 index 00000000..2e14a98f --- /dev/null +++ b/low-can-binding/utils/signals.cpp @@ -0,0 +1,76 @@ +/* + * Copyright (C) 2015, 2016 "IoT.bzh" + * Author "Romain Forlot" + * + * 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. + */ + +#include "signals.hpp" + +/// +/// @brief Can signal event map making access to afb_event +/// externaly to an openxc existing structure. +/// +/// Event map is making relation between can_signal_t generic name +/// and the afb_event struct used by application framework to pushed +/// to the subscriber. +/// +std::map subscribed_signals; + +/// +/// @brief Mutex allowing safe manipulation on subscribed_signals map. +/// To ensure that the map object isn't modified when we read it, you +/// have to set this mutex before use subscribed_signals map object. +/// +std::mutex subscribed_signals_mutex; + +std::mutex& get_subscribed_signals_mutex() +{ + return subscribed_signals_mutex; +} + +std::map& get_subscribed_signals() +{ + return subscribed_signals; +} + +/// +/// @fn std::vector find_signals(const openxc_DynamicField &key) +/// @brief return signals name found searching through CAN_signals and OBD2 pid +/// +/// @param[in] key : can contain numeric or string value in order to search against +/// can signals or obd2 signals name. +/// +/// @return Vector of signals name found. +/// +std::vector find_signals(const openxc_DynamicField &key) +{ + std::vector found_signals_name; + + switch(key.type) + { + case openxc_DynamicField_Type::openxc_DynamicField_Type_STRING: + lookup_signals_by_name(key.string_value, configuration_t::instance().get_can_signals(), found_signals_name); + lookup_signals_by_name(key.string_value, configuration_t::instance().get_diagnostic_messages(), found_signals_name); + break; + case openxc_DynamicField_Type::openxc_DynamicField_Type_NUM: + lookup_signals_by_id(key.numeric_value, configuration_t::instance().get_can_signals(), found_signals_name); + lookup_signals_by_id(key.numeric_value, configuration_t::instance().get_diagnostic_messages(), found_signals_name); + break; + default: + ERROR(binder_interface, "find_signals: wrong openxc_DynamicField specified. Use openxc_DynamicField_Type_NUM or openxc_DynamicField_Type_STRING type only."); + break; + } + DEBUG(binder_interface, "find_signals: Found %d signal(s)", (int)found_signals_name.size()); + return found_signals_name; +} diff --git a/low-can-binding/utils/signals.hpp b/low-can-binding/utils/signals.hpp new file mode 100644 index 00000000..e9417569 --- /dev/null +++ b/low-can-binding/utils/signals.hpp @@ -0,0 +1,90 @@ +/* + * Copyright (C) 2015, 2016 "IoT.bzh" + * Author "Romain Forlot" + * + * 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. + */ + +#pragma once + +#include +#include +#include + +#include "openxc.pb.h" +#include "../configuration.hpp" +#include "../can/can-signals.hpp" +#include "../diagnostic/diagnostic-message.hpp" + +#include "../low-can-binding.hpp" + +extern std::mutex subscribed_signals_mutex; +std::mutex& get_subscribed_signals_mutex(); + +/** + * @brief return the subscribed_signals map. + * + * return Map of subscribed signals. + */ +extern std::map subscribed_signals; +std::map& get_subscribed_signals(); + +template +void lookup_signals_by_name(const std::string& key, std::vector& signals, std::vector& found_signals) +{ + for(T& s : signals) + { + if(::fnmatch(key.c_str(), s.get_generic_name().c_str(), FNM_CASEFOLD) == 0) + found_signals.push_back(&s); + if(::fnmatch(key.c_str(), s.get_name().c_str(), FNM_CASEFOLD) == 0) + found_signals.push_back(&s); + } +} + +template +void lookup_signals_by_name(const std::string& key, std::vector& signals, std::vector& found_signals_name) +{ + for(T& s : signals) + { + if(::fnmatch(key.c_str(), s.get_generic_name().c_str(), FNM_CASEFOLD) == 0) + found_signals_name.push_back(s.get_name()); + if(::fnmatch(key.c_str(), s.get_name().c_str(), FNM_CASEFOLD) == 0) + found_signals_name.push_back(s.get_name()); + } +} + +template +void lookup_signals_by_id(const double key, std::vector& signals, std::vector& found_signals) +{ + for(T& s : signals) + { + if(configuration_t::instance().get_signal_id(s) == key) + { + found_signals.push_back(&s); + } + } +} + +template +void lookup_signals_by_id(const double key, std::vector& signals, std::vector& found_signals_name) +{ + for(T& s : signals) + { + if(configuration_t::instance().get_signal_id(s) == key) + { + found_signals_name.push_back(s.get_name()); + } + } +} + +std::vector find_signals(const openxc_DynamicField &key); diff --git a/low-can-binding/utils/socket.cpp b/low-can-binding/utils/socket.cpp new file mode 100644 index 00000000..e75e27f2 --- /dev/null +++ b/low-can-binding/utils/socket.cpp @@ -0,0 +1,89 @@ +/* + * Copyright (C) 2015, 2016 ,2017 "IoT.bzh" + * Author "Romain Forlot" + * Author "Loïc Collignon" + * 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. + */ + +#include +#include "socket.hpp" + +namespace utils +{ + /// @brief Construct a default, invalid, socket. + socket_t::socket_t() + : socket_{INVALID_SOCKET} + { + } + + /// @brief Construct a socket by moving an existing one. + socket_t::socket_t(socket_t&& s) + : socket_{s.socket_} + { + s.socket_ = INVALID_SOCKET; + } + + /// @brief Destruct the socket. + socket_t::~socket_t() + { + if(socket_ != INVALID_SOCKET) + ::close(socket_); + } + + /// @brief Test if socket is valid. + /// @return true if valid, false otherwise. + socket_t::operator bool() const + { + return socket_ != INVALID_SOCKET; + } + + /// @brief Open the socket. + /// @param[in] domain Specifies the communications domain in which a socket is to be created. + /// @param[in] type Specifies the type of socket to be created. + /// @param[in] protocol Specifies a particular protocol to be used with the socket. Specifying a protocol of 0 causes socket() to use an unspecified default protocol appropriate for the requested socket type. + /// @return Upon successful completion, shall return a non-negative integer, the socket file descriptor. Otherwise, a value of -1 shall be returned and errno set to indicate the error. + int socket_t::open(int domain, int type, int protocol) + { + close(); + socket_ = ::socket(domain, type, protocol); + return socket_; + } + + /// @brief Close the socket. + /// @return 0 if success. + int socket_t::close() + { + return socket_ != INVALID_SOCKET ? ::close(socket_) : 0; + } + + /// @brief Set socket option. + /// @return 0 if success. + int socket_t::setopt(int level, int optname, const void* optval, socklen_t optlen) + { + return socket_ != INVALID_SOCKET ? ::setsockopt(socket_, level, optname, optval, optlen) : 0; + } + + /// @brief Bind the socket. + /// @return 0 if success. + int socket_t::bind(const struct sockaddr* addr, socklen_t len) + { + return socket_ != INVALID_SOCKET ? ::bind(socket_, addr, len) : 0; + } + + /// @brief Get the file descriptor. + /// @return The socket's file descriptor + int socket_t::socket() const + { + return socket_; + } +} diff --git a/low-can-binding/utils/socket.hpp b/low-can-binding/utils/socket.hpp new file mode 100644 index 00000000..b42eee6a --- /dev/null +++ b/low-can-binding/utils/socket.hpp @@ -0,0 +1,46 @@ +#pragma once + +/* + * Copyright (C) 2015, 2016 ,2017 "IoT.bzh" + * Author "Romain Forlot" + * Author "Loïc Collignon" + * 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. + */ + +#include + +#define INVALID_SOCKET -1 + +namespace utils +{ + class socket_t + { + public: + socket_t(); + socket_t(const socket_t&) = delete; + socket_t(socket_t&&); + ~socket_t(); + + explicit operator bool() const; + + int open(int domain, int type, int protocol); + int close(); + int setopt(int level, int optname, const void* optval, socklen_t optlen); + int socket() const; + int bind(const struct sockaddr* addr, socklen_t len); + + private: + int socket_; + }; +} + diff --git a/low-can-binding/utils/timer.cpp b/low-can-binding/utils/timer.cpp new file mode 100644 index 00000000..a35a3e9f --- /dev/null +++ b/low-can-binding/utils/timer.cpp @@ -0,0 +1,102 @@ +/* + * Copyright (C) 2015, 2016 "IoT.bzh" + * Author "Romain Forlot" + * + * 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. + */ + +#include +#include + +#include "timer.hpp" + +long long int system_time_us() +{ + struct timespec t_usec; + long long int timestamp_usec; + + if(!::clock_gettime(CLOCK_MONOTONIC, &t_usec)) + timestamp_usec = (t_usec.tv_nsec / 1000ll) + (t_usec.tv_sec* 1000000ll); + return timestamp_usec; +} + +long long int system_time_ms() +{ + struct timespec t_msec; + long long int timestamp_msec; + + if(!::clock_gettime(CLOCK_MONOTONIC, &t_msec)) + timestamp_msec = (t_msec.tv_nsec / 1000000ll) + (t_msec.tv_sec* 1000ll); + return timestamp_msec; +} + +long long int system_time_s() +{ + struct timespec t_sec; + long long int timestamp_sec; + + if(!::clock_gettime(CLOCK_MONOTONIC, &t_sec)) + timestamp_sec = t_sec.tv_sec; + return timestamp_sec; +} + +frequency_clock_t::frequency_clock_t() + : unit_{1000000}, frequency_{10.0}, last_tick_{0}, time_function_{nullptr} +{} + + +frequency_clock_t::frequency_clock_t(float frequency) + : unit_{1000000}, frequency_{frequency}, last_tick_{0}, time_function_{nullptr} +{} + +/// @brief Return the period in ms given the frequency in hertz. +/// @param[in] frequency - Frequency to convert, in hertz +float frequency_clock_t::frequency_to_period() +{ + return 1 / frequency_ * unit_; +} + +bool frequency_clock_t::started() +{ + return last_tick_ != 0; +} + +time_function_t frequency_clock_t::get_time_function() +{ + return time_function_ != nullptr ? time_function_ : system_time_us; +} + +bool frequency_clock_t::elapsed(bool stagger) +{ + float period = frequency_to_period(); + float elapsed_time = 0; + if(!started() && stagger) + last_tick_ = get_time_function()() - (rand() % int(period)); + + // Make sure it ticks the the first call + elapsed_time = !started() ? period : get_time_function()() - last_tick_; + + return frequency_ == 0 || elapsed_time >= period; +} + +float frequency_clock_t::get_frequency() const +{ + return frequency_; +} + +/// @brief Force the clock to tick, regardless of it its time has actually +/// elapsed. +void frequency_clock_t::tick() +{ + last_tick_ = get_time_function()(); +} \ No newline at end of file diff --git a/low-can-binding/utils/timer.hpp b/low-can-binding/utils/timer.hpp new file mode 100644 index 00000000..f5659044 --- /dev/null +++ b/low-can-binding/utils/timer.hpp @@ -0,0 +1,53 @@ +/* + * Copyright (C) 2015, 2016 "IoT.bzh" + * Author "Romain Forlot" + * + * 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. + */ + +#pragma once + +/// @brief return epoch in milliseconds +/// +/// @return long long int epoch in milliseconds +typedef long long int (*time_function_t)(); + +long long int system_time_us(); +long long int system_time_ms(); +long long int system_time_s(); + + +/// @brief A frequency counting clock. +/// Utility class allowing some time function. +class frequency_clock_t +{ +private: + float unit_; ///< unit_ - multiplicator to make operation to be in the right unit (milli, micro, nano, etc) + float frequency_; ///< the clock frequency in Hz. + unsigned long last_tick_; ///< the last time (in milliseconds since startup) that the clock ticked. + time_function_t time_function_; ///< a function returning current time + +public: + frequency_clock_t(); + frequency_clock_t(float frequency); + frequency_clock_t(float frequency, unsigned long last_tick, time_function_t time_function); + + float get_frequency() const; + + float frequency_to_period(); + bool started(); + time_function_t get_time_function(); + bool elapsed(bool stagger); + + void tick(); +}; \ No newline at end of file diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt deleted file mode 100644 index 4c4132b9..00000000 --- a/src/CMakeLists.txt +++ /dev/null @@ -1,123 +0,0 @@ -########################################################################### -# Copyright 2016 IoT.bzh -# -# author: José Bollo -# author: Stéphane Desneux -# -# 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. -########################################################################### - -include(GNUInstallDirs) - -set(TARGET "root@192.168.1.206") -set(PROJECT_VERSION "0.1") -set(PROJECT_ICON "icon.png") -set(PROJECT_LIBDIR "libs") - -set(CMAKE_BUILD_TYPE Debug) - -########################################################################### - -link_libraries(-Wl,--as-needed -Wl,--gc-sections) - -add_compile_options(-Wall -Wextra -Wconversion) -add_compile_options(-Wno-unused-parameter) # frankly not using a parameter does it care? -add_compile_options(-Werror=maybe-uninitialized) -add_compile_options(-Werror=implicit-function-declaration) -add_compile_options(-ffunction-sections -fdata-sections) -add_compile_options(-Wl,--as-needed -Wl,--gc-sections) -add_compile_options(-fPIC) -add_compile_options(-D_REENTRANT) - -set(CMAKE_C_FLAGS_PROFILING "-g -O0 -pg -Wp,-U_FORTIFY_SOURCE") -set(CMAKE_C_FLAGS_DEBUG "-g -O0 -ggdb -Wp,-U_FORTIFY_SOURCE") -set(CMAKE_C_FLAGS_RELEASE "-g -O0 -Wall -Werror") -set(CMAKE_C_FLAGS_CCOV "-g -O0 --coverage") - -set(CMAKE_CXX_FLAGS_PROFILING "-g -O0 -std=c++11 -pg -Wp,-U_FORTIFY_SOURCE") -set(CMAKE_CXX_FLAGS_DEBUG "-g -O0 -std=c++11 -ggdb -Wp,-U_FORTIFY_SOURCE") -set(CMAKE_CXX_FLAGS_RELEASE "-g -O2 -std=c++11") -set(CMAKE_CXX_FLAGS_CCOV "-g -O2 -std=c++11 --coverage") - -########################################################################### - -include(FindPkgConfig) - -pkg_check_modules(EXTRAS REQUIRED json-c libsystemd afb-daemon) -add_compile_options(${EXTRAS_CFLAGS}) -add_compile_options(${EXTRAS_CXXFLAGS}) - -# Needed to compile openxc-message-format library. -# -# The reason you need to do this is that some of your messages contain tag -# numbers or field sizes that are larger than what can fit in the default -# 8 bit descriptors. -add_definitions(-DPB_FIELD_16BIT) - -# Needed extra directories to hit the required headers files. -include_directories(${EXTRAS_INCLUDE_DIRS} ${PROJECT_SOURCE_DIR} ${PROJECT_LIBDIR}/openxc-message-format/gen/cpp ${PROJECT_LIBDIR}/nanopb/ ${PROJECT_LIBDIR}/uds-c/src ${PROJECT_LIBDIR}/bitfield-c/src ${PROJECT_LIBDIR}/isotp-c/src) -link_libraries(${EXTRAS_LIBRARIES}) -########################################################################### -# the library used by the binding : openxc, bitfield, uds, isotp - -add_library(bitfield STATIC ${PROJECT_LIBDIR}/bitfield-c/src/bitfield/8byte.c ${PROJECT_LIBDIR}/bitfield-c/src/bitfield/bitarray.c ${PROJECT_LIBDIR}/bitfield-c/src/bitfield/bitfield.c ${PROJECT_LIBDIR}/bitfield-c/src/canutil/read.c ${PROJECT_LIBDIR}/bitfield-c/src/canutil/write.c) -add_library(isotp STATIC ${PROJECT_LIBDIR}/isotp-c/src/isotp/isotp.c ${PROJECT_LIBDIR}/isotp-c/src/isotp/receive.c ${PROJECT_LIBDIR}/isotp-c/src/isotp/send.c) -add_library(uds STATIC ${PROJECT_LIBDIR}/uds-c/src/uds/extras.c ${PROJECT_LIBDIR}/uds-c/src/uds/uds.c) -add_library(openxc STATIC ${PROJECT_LIBDIR}/openxc-message-format/gen/cpp/openxc.pb.c ${PROJECT_LIBDIR}/nanopb/pb_encode.c ${PROJECT_LIBDIR}/nanopb/pb_decode.c ${PROJECT_LIBDIR}/nanopb/pb_common.c) -########################################################################### -# the binding for afb - -message(STATUS "Creation of ${PROJECT_NAME} binding for AFB-DAEMON") -########################################################################### -add_library(${PROJECT_NAME} MODULE ${PROJECT_NAME}.cpp configuration.cpp configuration-generated.cpp - can/can-bus.cpp can/can-bus-dev.cpp can/can-message-set.cpp can/can-message-definition.cpp can/can-message.cpp can/can-signals.cpp can/can-decoder.cpp - diagnostic/diagnostic-message.cpp diagnostic/diagnostic-manager.cpp diagnostic/active-diagnostic-request.cpp - utils/signals.cpp utils/openxc-utils.cpp utils/timer.cpp utils/socket.cpp) -target_link_libraries(${PROJECT_NAME} pthread bitfield uds isotp openxc) - -set_target_properties(${PROJECT_NAME} PROPERTIES - PREFIX "" - LINK_FLAGS "-Wl,--version-script=${CMAKE_CURRENT_SOURCE_DIR}/export.map" -) - -########################################################################### -# WGT packaging - -message(STATUS "Creation of ${PROJECT_NAME}.wgt package for AppFW") -########################################################################### -configure_file(config.xml.in config.xml) -configure_file(can_buses.json.in can_buses.json) - -add_custom_command( - OUTPUT ${PROJECT_NAME}.wgt - DEPENDS ${PROJECT_NAME} bitfield isotp uds openxc config.xml.in can_buses.json.in - COMMAND rm -rf package - COMMAND mkdir -p package/${PROJECT_LIBDIR} package/htdocs package/etc - COMMAND cp config.xml package/ - COMMAND cp can_buses.json package/etc - COMMAND cp ${CMAKE_CURRENT_SOURCE_DIR}/${PROJECT_ICON} package/icon.png - COMMAND cp ${PROJECT_NAME}.so package/libs - COMMAND wgtpkg-pack -f -o ${PROJECT_NAME}.wgt package -) -add_custom_target(widget ALL DEPENDS ${PROJECT_NAME}.wgt) - -########################################################################### -# WGT install - -#message(STATUS "Creation of ${PROJECT_NAME}.wgt package for AppFW") -########################################################################### -install(CODE "execute_process( - COMMAND scp -r src/${PROJECT_NAME}.wgt ${CMAKE_SOURCE_DIR} ${TARGET}:/tmp)" - CODE "execute_process( - COMMAND ssh ${TARGET} \"/usr/bin/afm-util remove ${PROJECT_NAME}@${PROJECT_VERSION} && /usr/bin/afm-util install /tmp/${PROJECT_NAME}.wgt\")" - ) diff --git a/src/can/can-bus-dev.cpp b/src/can/can-bus-dev.cpp deleted file mode 100644 index fb76498f..00000000 --- a/src/can/can-bus-dev.cpp +++ /dev/null @@ -1,255 +0,0 @@ -/* -* Copyright (C) 2015, 2016, 2017 "IoT.bzh" -* Author "Romain Forlot" -* Author "Loïc Collignon" -* -* 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. -*/ - -#include -#include -#include -#include -#include -#include -#include - -#include "can-bus-dev.hpp" - -#include "can-bus.hpp" -#include "can-message.hpp" -#include "../low-can-binding.hpp" - -/// @brief Class constructor -/// -/// @param[in] dev_name - String representing the device name into the linux /dev tree -/// @param[in] address - integer identifier of the bus, set using init_can_dev from can_bus_t. -can_bus_dev_t::can_bus_dev_t(const std::string& dev_name, int32_t address) - : device_name_{dev_name}, address_{address} -{} - -std::string can_bus_dev_t::get_device_name() const -{ - return device_name_; -} - -uint32_t can_bus_dev_t::get_address() const -{ - return address_; -} - -/// @brief Open the can socket and returning it -/// -/// We try to open CAN socket and apply the following options -/// timestamp received messages and pass the socket to FD mode. -/// -/// @return -1 if something wrong. -int can_bus_dev_t::open() -{ - const int canfd_on = 1; - const int timestamp_on = 1; - struct ifreq ifr; - struct timeval timeout; - - DEBUG(binder_interface, "open: CAN Handler socket : %d", can_socket_.socket()); - if (can_socket_) - return 0; - - can_socket_.open(PF_CAN, SOCK_RAW, CAN_RAW); - if (can_socket_) - { - DEBUG(binder_interface, "open: CAN Handler socket correctly initialized : %d", can_socket_.socket()); - - // Set timeout for read - can_socket_.setopt(SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout, sizeof(timeout)); - - // Set timestamp for receveid frame - if (can_socket_.setopt(SOL_SOCKET, SO_TIMESTAMP, ×tamp_on, sizeof(timestamp_on)) < 0) - WARNING(binder_interface, "open: setsockopt SO_TIMESTAMP error: %s", ::strerror(errno)); - DEBUG(binder_interface, "open: Switch CAN Handler socket to use fd mode"); - - // try to switch the socket into CAN_FD mode - if (can_socket_.setopt(SOL_CAN_RAW, CAN_RAW_FD_FRAMES, &canfd_on, sizeof(canfd_on)) < 0) - { - NOTICE(binder_interface, "open: Can not switch into CAN Extended frame format."); - is_fdmode_on_ = false; - } - else - { - DEBUG(binder_interface, "open: Correctly set up CAN socket to use FD frames."); - is_fdmode_on_ = true; - } - - // Attempts to open a socket to CAN bus - ::strcpy(ifr.ifr_name, device_name_.c_str()); - DEBUG(binder_interface, "open: ifr_name is : %s", ifr.ifr_name); - if(::ioctl(can_socket_.socket(), SIOCGIFINDEX, &ifr) < 0) - { - ERROR(binder_interface, "open: ioctl failed. Error was : %s", strerror(errno)); - } - else - { - txAddress_.can_family = AF_CAN; - txAddress_.can_ifindex = ifr.ifr_ifindex; - - // And bind it to txAddress - DEBUG(binder_interface, "Bind the socket"); - if (can_socket_.bind((struct sockaddr *)&txAddress_, sizeof(txAddress_)) < 0) - ERROR(binder_interface, "Bind failed. %s", strerror(errno)); - else return 0; - } - close(); - } - else ERROR(binder_interface, "open: socket could not be created. Error was : %s", ::strerror(errno)); - return -1; -} - -/// @brief Close the bus. -/// -/// @return interger return value of socket.close() function -int can_bus_dev_t::close() -{ - return can_socket_.close(); -} - -/// @brief Read the can socket and retrieve canfd_frame. -/// -/// Read operation are blocking and we try to read CANFD frame -/// rather than classic CAN frame. CANFD frame are retro compatible. -can_message_t can_bus_dev_t::read() -{ - ssize_t nbytes; - struct canfd_frame cfd; - - // Test that socket is really opened - if (!can_socket_) - { - ERROR(binder_interface, "read: Socket unavailable. Closing thread."); - is_running_ = false; - } - - nbytes = ::read(can_socket_.socket(), &cfd, CANFD_MTU); - - // if we did not fit into CAN sized messages then stop_reading. - if (nbytes != CANFD_MTU && nbytes != CAN_MTU) - { - if (errno == ENETDOWN) - ERROR(binder_interface, "read: %s CAN device down", device_name_.c_str()); - ERROR(binder_interface, "read: Incomplete CAN(FD) frame"); - ::memset(&cfd, 0, sizeof(cfd)); - } - - DEBUG(binder_interface, "read: Found id: %X, length: %X, data %02X%02X%02X%02X%02X%02X%02X%02X", cfd.can_id, cfd.len, - cfd.data[0], cfd.data[1], cfd.data[2], cfd.data[3], cfd.data[4], cfd.data[5], cfd.data[6], cfd.data[7]); - return can_message_t::convert_from_canfd_frame(cfd, nbytes); -} - -/// @brief start reading threads and set flag is_running_ -/// @param[in] can_bus reference can_bus_t. it will be passed to the thread to allow using can_bus_t queue. -void can_bus_dev_t::start_reading(can_bus_t& can_bus) -{ - DEBUG(binder_interface, "Launching reading thread"); - is_running_ = true; - th_reading_ = std::thread(&can_bus_dev_t::can_reader, this, std::ref(can_bus)); - if(!th_reading_.joinable()) - is_running_ = false; -} - -/// @brief stop the reading thread setting flag is_running_ to false and and wait that the thread finish its job. -void can_bus_dev_t::stop_reading() -{ - is_running_ = false; -} - -/// @brief Thread function used to read the can socket. -/// @param[in] can_bus - object to be used to read the can socket -void can_bus_dev_t::can_reader(can_bus_t& can_bus) -{ - while(is_running_) - { - can_message_t msg = read(); - { - std::lock_guard can_message_lock(can_bus.get_can_message_mutex()); - can_bus.push_new_can_message(msg); - } - can_bus.get_new_can_message_cv().notify_one(); - } -} - -/// @brief Send a can message from a can_message_t object. -/// @param[in] can_msg - the can message object to send -/// -/// @return 0 if message snet, -1 if something wrong. -int can_bus_dev_t::send(can_message_t& can_msg) -{ - ssize_t nbytes; - canfd_frame f; - - f = can_msg.convert_to_canfd_frame(); - - if(can_socket_) - { - nbytes = ::sendto(can_socket_.socket(), &f, sizeof(struct canfd_frame), 0, - (struct sockaddr*)&txAddress_, sizeof(txAddress_)); - if (nbytes == -1) - { - ERROR(binder_interface, "send_can_message: Sending CAN frame failed."); - return -1; - } - return (int)nbytes; - } - else - { - ERROR(binder_interface, "send_can_message: socket not initialized. Attempt to reopen can device socket."); - open(); - } - return 0; -} - -/// @brief Static method used to send diagnostic CAN message -/// that follow isotp SendShimsMessage signature. This method is launched -/// from diagnostic manager's' same name method. It will use the diagnostic -/// manager configured CAN bus device to send the CAN message. -/// -/// @param[in] arbitration_id - CAN arbitration id. -/// @param[in] data - CAN message payload to send -/// @param[in] size - size of the data to send -/// -/// @return True if message sent, false if not. -bool can_bus_dev_t::shims_send(const uint32_t arbitration_id, const uint8_t* data, const uint8_t size) -{ - ssize_t nbytes; - canfd_frame f; - - f.can_id = arbitration_id; - f.len = size; - ::memcpy(f.data, data, size); - - if(can_socket_) - { - nbytes = ::sendto(can_socket_.socket(), &f, sizeof(struct canfd_frame), 0, - (struct sockaddr*)&txAddress_, sizeof(txAddress_)); - if (nbytes == -1) - { - ERROR(binder_interface, "send_can_message: Sending CAN frame failed."); - return false; - } - return true; - } - else - { - ERROR(binder_interface, "send_can_message: socket not initialized. Attempt to reopen can device socket."); - open(); - } - return false; -} diff --git a/src/can/can-bus-dev.hpp b/src/can/can-bus-dev.hpp deleted file mode 100644 index a612e7d8..00000000 --- a/src/can/can-bus-dev.hpp +++ /dev/null @@ -1,65 +0,0 @@ -/* - * Copyright (C) 2015, 2016, 2017 "IoT.bzh" - * Author "Romain Forlot" - * Author "Loïc Collignon" - * - * 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. - */ - -#pragma once - -#include -#include -#include -#include - -#include "../utils/socket.hpp" - -class can_bus_t; -class can_message_t; - -/// @brief Object representing a can device. Handle opening, closing and reading on the -/// socket. This is the low level object to be initialized and use by can_bus_t. -class can_bus_dev_t -{ -private: - std::string device_name_; ///< a string identifier identitfying the linux CAN device. - utils::socket_t can_socket_; - - int32_t address_; ///< an identifier used through binding that refer to that device - - bool is_fdmode_on_; ///< boolean telling if whether or not the can socket use fdmode. - struct sockaddr_can txAddress_; /// < internal member using to bind to the socket - - std::thread th_reading_; ///< Thread handling read the socket can device filling can_message_q_ queue of can_bus_t - bool is_running_ = false; ///< boolean telling whether or not reading is running or not - void can_reader(can_bus_t& can_bus); - -public: - can_bus_dev_t(const std::string& dev_name, int32_t address); - - std::string get_device_name() const; - uint32_t get_address() const; - - int open(); - int close(); - - void start_reading(can_bus_t& can_bus); - - void stop_reading(); - - can_message_t read(); - - int send(can_message_t& can_msg); - bool shims_send(const uint32_t arbitration_id, const uint8_t* data, const uint8_t size); -}; diff --git a/src/can/can-bus.cpp b/src/can/can-bus.cpp deleted file mode 100644 index 33f58fd9..00000000 --- a/src/can/can-bus.cpp +++ /dev/null @@ -1,398 +0,0 @@ -/* - * Copyright (C) 2015, 2016 "IoT.bzh" - * Author "Romain Forlot" - * - * 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. - */ - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include "can-bus.hpp" - -#include "can-signals.hpp" -#include "can-decoder.hpp" -#include "../configuration.hpp" -#include "../utils/signals.hpp" -#include "../utils/openxc-utils.hpp" - -extern "C" -{ - #include -} - -/// @brief Class constructor -/// -/// @param[in] conf_file - handle to the json configuration file. -can_bus_t::can_bus_t(int conf_file) - : conf_file_{conf_file} -{ -} - -std::map> can_bus_t::can_devices_; - -/// @brief Will make the decoding operation on a classic CAN message. It will not -/// handle CAN commands nor diagnostic messages that have their own method to get -/// this happens. -/// -/// It will add to the vehicle_message queue the decoded message and tell the event push -/// thread to process it. -/// -/// @param[in] can_message - a single CAN message from the CAN socket read, to be decode. -/// -/// @return How many signals has been decoded. -int can_bus_t::process_can_signals(can_message_t& can_message) -{ - int processed_signals = 0; - std::vector signals; - openxc_DynamicField search_key, decoded_message; - openxc_VehicleMessage vehicle_message; - - // First we have to found which can_signal_t it is - search_key = build_DynamicField((double)can_message.get_id()); - configuration_t::instance().find_can_signals(search_key, signals); - - // Decoding the message ! Don't kill the messenger ! - for(auto& sig : signals) - { - std::lock_guard subscribed_signals_lock(get_subscribed_signals_mutex()); - std::map& s = get_subscribed_signals(); - - // DEBUG message to make easier debugger STL containers... - //DEBUG(binder_interface, "Operator[] key char: %s, event valid? %d", sig.generic_name, afb_event_is_valid(s[sig.generic_name])); - //DEBUG(binder_interface, "Operator[] key string: %s, event valid? %d", sig.generic_name, afb_event_is_valid(s[std::string(sig.generic_name)])); - //DEBUG(binder_interface, "Nb elt matched char: %d", (int)s.count(sig.generic_name)); - //DEBUG(binder_interface, "Nb elt matched string: %d", (int)s.count(std::string(sig.generic_name)); - if( s.find(sig->get_name()) != s.end() && afb_event_is_valid(s[sig->get_name()])) - { - decoded_message = decoder_t::translateSignal(*sig, can_message, configuration_t::instance().get_can_signals()); - - openxc_SimpleMessage s_message = build_SimpleMessage(sig->get_name(), decoded_message); - vehicle_message = build_VehicleMessage(s_message); - - std::lock_guard decoded_can_message_lock(decoded_can_message_mutex_); - push_new_vehicle_message(vehicle_message); - processed_signals++; - } - } - - DEBUG(binder_interface, "process_can_signals: %d/%d CAN signals processed.", processed_signals, (int)signals.size()); - return processed_signals; -} - -/// @brief Will make the decoding operation on a diagnostic CAN message.Then it find the subscribed signal -/// corresponding and will add the vehicle_message to the queue of event to pushed before notifying -/// the event push thread to process it. -/// -/// @param[in] manager - the diagnostic manager object that handle diagnostic communication -/// @param[in] can_message - a single CAN message from the CAN socket read, to be decode. -/// -/// @return How many signals has been decoded. -int can_bus_t::process_diagnostic_signals(diagnostic_manager_t& manager, const can_message_t& can_message) -{ - int processed_signals = 0; - - std::lock_guard subscribed_signals_lock(get_subscribed_signals_mutex()); - std::map& s = get_subscribed_signals(); - - openxc_VehicleMessage vehicle_message = manager.find_and_decode_adr(can_message); - if( (vehicle_message.has_simple_message && vehicle_message.simple_message.has_name) && - (s.find(vehicle_message.simple_message.name) != s.end() && afb_event_is_valid(s[vehicle_message.simple_message.name]))) - { - std::lock_guard decoded_can_message_lock(decoded_can_message_mutex_); - push_new_vehicle_message(vehicle_message); - processed_signals++; - } - - return processed_signals; -} - -/// @brief thread to decoding raw CAN messages. -/// -/// Depending on the nature of message, if arbitration ID matches ID for a diagnostic response -/// then decoding a diagnostic message else use classic CAN signals decoding functions. -/// -/// It will take from the can_message_q_ queue the next can message to process then it search -/// about signal subscribed if there is a valid afb_event for it. We only decode signal for which a -/// subscription has been made. Can message will be decoded using translateSignal that will pass it to the -/// corresponding decoding function if there is one assigned for that signal. If not, it will be the default -/// noopDecoder function that will operate on it. -/// -/// TODO: make diagnostic messages parsing optionnal. -void can_bus_t::can_decode_message() -{ - can_message_t can_message; - - while(is_decoding_) - { - { - std::unique_lock can_message_lock(can_message_mutex_); - new_can_message_cv_.wait(can_message_lock); - while(!can_message_q_.empty()) - { - can_message = next_can_message(); - - if(configuration_t::instance().get_diagnostic_manager().is_diagnostic_response(can_message)) - process_diagnostic_signals(configuration_t::instance().get_diagnostic_manager(), can_message); - else - process_can_signals(can_message); - } - } - new_decoded_can_message_.notify_one(); - } -} - -/// @brief thread to push events to suscribers. It will read subscribed_signals map to look -/// which are events that has to be pushed. -void can_bus_t::can_event_push() -{ - openxc_VehicleMessage v_message; - openxc_SimpleMessage s_message; - json_object* jo; - - while(is_pushing_) - { - std::unique_lock decoded_can_message_lock(decoded_can_message_mutex_); - new_decoded_can_message_.wait(decoded_can_message_lock); - while(!vehicle_message_q_.empty()) - { - v_message = next_vehicle_message(); - - s_message = get_simple_message(v_message); - { - std::lock_guard subscribed_signals_lock(get_subscribed_signals_mutex()); - std::map& s = get_subscribed_signals(); - if(s.find(std::string(s_message.name)) != s.end() && afb_event_is_valid(s[std::string(s_message.name)])) - { - jo = json_object_new_object(); - jsonify_simple(s_message, jo); - if(afb_event_push(s[std::string(s_message.name)], jo) == 0) - on_no_clients(std::string(s_message.name)); - } - } - } - } -} - -/// @brief Will initialize threads that will decode -/// and push subscribed events. -void can_bus_t::start_threads() -{ - is_decoding_ = true; - th_decoding_ = std::thread(&can_bus_t::can_decode_message, this); - if(!th_decoding_.joinable()) - is_decoding_ = false; - - is_pushing_ = true; - th_pushing_ = std::thread(&can_bus_t::can_event_push, this); - if(!th_pushing_.joinable()) - is_pushing_ = false; -} - -/// @brief Will stop all threads holded by can_bus_t object -/// which are decoding and pushing then will wait that's -/// they'll finish their job. -void can_bus_t::stop_threads() -{ - is_decoding_ = false; - is_pushing_ = false; -} - -/// @brief Will initialize can_bus_dev_t objects after reading -/// the configuration file passed in the constructor. All CAN buses -/// Initialized here will be added to a vector holding them for -/// inventory and later access. -/// -/// That will initialize CAN socket reading too using a new thread. -/// -/// @return 0 if ok, other if not. -int can_bus_t::init_can_dev() -{ - std::vector devices_name; - int i = 0; - size_t t; - - devices_name = read_conf(); - - if (! devices_name.empty()) - { - t = devices_name.size(); - - for(const auto& device : devices_name) - { - can_bus_t::can_devices_[device] = std::make_shared(device, i); - if (can_bus_t::can_devices_[device]->open() == 0) - { - DEBUG(binder_interface, "Start reading thread"); - NOTICE(binder_interface, "%s device opened and reading", device.c_str()); - can_bus_t::can_devices_[device]->start_reading(*this); - i++; - } - else - { - ERROR(binder_interface, "Can't open device %s", device.c_str()); - return 1; - } - } - - NOTICE(binder_interface, "Initialized %d/%d can bus device(s)", i, (int)t); - return 0; - } - ERROR(binder_interface, "init_can_dev: Error at CAN device initialization. No devices read from configuration file. Did you specify canbus JSON object ?"); - return 1; -} - -/// @brief read the conf_file_ and will parse json objects -/// in it searching for canbus objects devices name. -/// -/// @return Vector of can bus device name string. -std::vector can_bus_t::read_conf() -{ - std::vector ret; - json_object *jo, *canbus; - int n, i; - const char* taxi; - - FILE *fd = fdopen(conf_file_, "r"); - if (fd) - { - std::string fd_conf_content; - std::fseek(fd, 0, SEEK_END); - fd_conf_content.resize(std::ftell(fd)); - std::rewind(fd); - std::fread(&fd_conf_content[0], 1, fd_conf_content.size(), fd); - std::fclose(fd); - - DEBUG(binder_interface, "Configuration file content : %s", fd_conf_content.c_str()); - jo = json_tokener_parse(fd_conf_content.c_str()); - - if (jo == NULL || !json_object_object_get_ex(jo, "canbus", &canbus)) - { - ERROR(binder_interface, "Can't find canbus node in the configuration file. Please review it."); - ret.clear(); - } - else if (json_object_get_type(canbus) != json_type_array) - { - taxi = json_object_get_string(canbus); - DEBUG(binder_interface, "Can bus found: %s", taxi); - ret.push_back(std::string(taxi)); - } - else - { - n = json_object_array_length(canbus); - for (i = 0 ; i < n ; i++) - ret.push_back(json_object_get_string(json_object_array_get_idx(canbus, i))); - } - return ret; - } - ERROR(binder_interface, "Problem at reading the conf file"); - ret.clear(); - return ret; -} - -/// @brief return new_can_message_cv_ member -/// -/// @return return new_can_message_cv_ member -std::condition_variable& can_bus_t::get_new_can_message_cv() -{ - return new_can_message_cv_; -} - -/// @brief return can_message_mutex_ member -/// -/// @return return can_message_mutex_ member -std::mutex& can_bus_t::get_can_message_mutex() -{ - return can_message_mutex_; -} - -/// @brief Return first can_message_t on the queue -/// -/// @return a can_message_t -can_message_t can_bus_t::next_can_message() -{ - can_message_t can_msg; - - if(!can_message_q_.empty()) - { - can_msg = can_message_q_.front(); - can_message_q_.pop(); - DEBUG(binder_interface, "next_can_message: Here is the next can message : id %X, length %X, data %02X%02X%02X%02X%02X%02X%02X%02X", can_msg.get_id(), can_msg.get_length(), - can_msg.get_data()[0], can_msg.get_data()[1], can_msg.get_data()[2], can_msg.get_data()[3], can_msg.get_data()[4], can_msg.get_data()[5], can_msg.get_data()[6], can_msg.get_data()[7]); - return can_msg; - } - - return can_msg; -} - -/// @brief Push a can_message_t into the queue -/// -/// @param[in] can_msg - the const reference can_message_t object to push into the queue -void can_bus_t::push_new_can_message(const can_message_t& can_msg) -{ - can_message_q_.push(can_msg); -} - -/// @brief Return first openxc_VehicleMessage on the queue -/// -/// @return a openxc_VehicleMessage containing a decoded can message -openxc_VehicleMessage can_bus_t::next_vehicle_message() -{ - openxc_VehicleMessage v_msg; - - if(! vehicle_message_q_.empty()) - { - v_msg = vehicle_message_q_.front(); - vehicle_message_q_.pop(); - DEBUG(binder_interface, "next_vehicle_message: next vehicle message poped"); - return v_msg; - } - - return v_msg; -} - -/// @brief Push a openxc_VehicleMessage into the queue -/// -/// @param[in] v_msg - const reference openxc_VehicleMessage object to push into the queue -void can_bus_t::push_new_vehicle_message(const openxc_VehicleMessage& v_msg) -{ - vehicle_message_q_.push(v_msg); -} - -/// @brief Return a map with the can_bus_dev_t initialized -/// -/// @return map can_bus_dev_m_ map -const std::map>& can_bus_t::get_can_devices() const -{ - return can_bus_t::can_devices_; -} - -/// @brief Return the shared pointer on the can_bus_dev_t initialized -/// with device_name "bus" -/// -/// @param[in] bus - CAN bus device name to retrieve. -/// -/// @return A shared pointer on an object can_bus_dev_t -std::shared_ptr can_bus_t::get_can_device(std::string bus) -{ - return can_bus_t::can_devices_[bus]; -} diff --git a/src/can/can-bus.hpp b/src/can/can-bus.hpp deleted file mode 100644 index eb474769..00000000 --- a/src/can/can-bus.hpp +++ /dev/null @@ -1,94 +0,0 @@ -/* - * Copyright (C) 2015, 2016, 2017 "IoT.bzh" - * Author "Romain Forlot" - * Author "Loïc Collignon" - * - * 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. - */ - -#pragma once - -#include -#include -#include -#include -#include - -#include "openxc.pb.h" -#include "can-message.hpp" -#include "can-bus-dev.hpp" -#include "../diagnostic/active-diagnostic-request.hpp" - -#include "../low-can-binding.hpp" - -// TODO actual max is 32 but dropped to 24 for memory considerations -#define MAX_ACCEPTANCE_FILTERS 24 -// TODO this takes up a ton of memory -#define MAX_DYNAMIC_MESSAGE_COUNT 12 - -#define CAN_ACTIVE_TIMEOUT_S 30 - -/// @brief Object used to handle decoding and manage event queue to be pushed. -/// -/// This object is also used to initialize can_bus_dev_t object after reading -/// json conf file describing the CAN devices to use. Thus, those object will read -/// on the device the CAN frame and push them into the can_bus_t can_message_q_ queue. -/// -/// That queue will be later used to be decoded and pushed to subscribers. -class can_bus_t -{ -private: - int conf_file_; ///< configuration file handle used to initialize can_bus_dev_t objects. - - void can_decode_message(); - std::thread th_decoding_; ///< thread that'll handle decoding a can frame - bool is_decoding_ = false; ///< boolean member controling thread while loop - - void can_event_push(); - std::thread th_pushing_; ///< thread that'll handle pushing decoded can frame to subscribers - bool is_pushing_ = false; ///< boolean member controling thread while loop - - std::condition_variable new_can_message_cv_; ///< condition_variable use to wait until there is a new CAN message to read - std::mutex can_message_mutex_; ///< mutex protecting the can_message_q_ queue. - std::queue can_message_q_; ///< queue that'll store can_message_t to decoded - - std::condition_variable new_decoded_can_message_; ///< condition_variable use to wait until there is a new vehicle message to read from the queue vehicle_message_q_ - std::mutex decoded_can_message_mutex_; ///< mutex protecting the vehicle_message_q_ queue. - std::queue vehicle_message_q_; ///< queue that'll store openxc_VehicleMessage to pushed - - static std::map> can_devices_; ///< Can device map containing all can_bus_dev_t objects initialized during init_can_dev function - -public: - can_bus_t(int conf_file); - can_bus_t(can_bus_t&&); - - int init_can_dev(); - std::vector read_conf(); - - void start_threads(); - void stop_threads(); - - int process_can_signals(can_message_t& can_message); - int process_diagnostic_signals(diagnostic_manager_t& manager, const can_message_t& can_message); - - can_message_t next_can_message(); - void push_new_can_message(const can_message_t& can_msg); - std::mutex& get_can_message_mutex(); - std::condition_variable& get_new_can_message_cv(); - - openxc_VehicleMessage next_vehicle_message(); - void push_new_vehicle_message(const openxc_VehicleMessage& v_msg); - - const std::map>& get_can_devices() const; - static std::shared_ptr get_can_device(std::string bus); -}; diff --git a/src/can/can-command.hpp b/src/can/can-command.hpp deleted file mode 100644 index 4cf20cb5..00000000 --- a/src/can/can-command.hpp +++ /dev/null @@ -1,55 +0,0 @@ -/* - * Copyright (C) 2015, 2016 "IoT.bzh" - * Author "Romain Forlot" - * - * 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. - */ - -#pragma once - -#include "openxc.pb.h" -#include "can-signals.hpp" - -/// -/// @brief The type signature for a function to handle a custom OpenXC command. -/// -/// @param[in] name - the name of the received command. -/// @param[in] value - the value of the received command, in a DynamicField. The actual type -/// may be a number, string or bool. -/// @param[in] event - an optional event from the received command, in a DynamicField. The -/// actual type may be a number, string or bool. -/// @param[in] signals - The list of all signals. -/// @param[in] signalCount - The length of the signals array. -/// -typedef void (*CommandHandler)(const char* name, openxc_DynamicField* value, - openxc_DynamicField* event, can_signal_t* signals, int signalCount); - -/// @struct CanCommand -/// @brief The structure to represent a supported custom OpenXC command. -/// -/// For completely customized CAN commands without a 1-1 mapping between an -/// OpenXC message from the host and a CAN signal, you can define the name of the -/// command and a custom function to handle it in the VI. An example is -/// the "turn_signal_status" command in OpenXC, which has a value of "left" or -/// "right". The vehicle may have separate CAN signals for the left and right -/// turn signals, so you will need to implement a custom command handler to send -/// the correct signals. -/// -/// Command handlers are also useful if you want to trigger multiple CAN messages -/// or signals from a signal OpenXC message. -/// -typedef struct { - const char* generic_name; /*!< generic_name - The name of the command.*/ - CommandHandler handler; /*!< handler - An function to process the received command's data and perform some - * action.*/ -} CanCommand; diff --git a/src/can/can-decoder.cpp b/src/can/can-decoder.cpp deleted file mode 100644 index 8843059d..00000000 --- a/src/can/can-decoder.cpp +++ /dev/null @@ -1,233 +0,0 @@ -/* - * Copyright (C) 2015, 2016 "IoT.bzh" - * Author "Romain Forlot" - * - * 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. - */ - -#include "can-decoder.hpp" - -#include "canutil/read.h" -#include "../utils/openxc-utils.hpp" - -/// @brief Parse the signal's bitfield from the given data and return the raw -/// value. -/// -/// @param[in] signal - The signal to parse from the data. -/// @param[in] message - can_message_t to parse -/// -/// @return Returns the raw value of the signal parsed as a bitfield from the given byte -/// array. -/// -float decoder_t::parseSignalBitfield(can_signal_t& signal, const can_message_t& message) -{ - return bitfield_parse_float(message.get_data(), CAN_MESSAGE_SIZE, - signal.get_bit_position(), signal.get_bit_size(), signal.get_factor(), - signal.get_offset()); -} - -/// @brief Wrap a raw CAN signal value in a DynamicField without modification. -/// -/// This is an implementation of the SignalDecoder type signature, and can be -/// used directly in the can_signal_t.decoder field. -/// -/// @param[in] signal - The details of the signal that contains the state mapping. -/// @param[in] signals - The list of all signals -/// @param[in] value - The numerical value that will be wrapped in a DynamicField. -/// @param[out] send - An output argument that will be set to false if the value should -/// not be sent for any reason. -/// -/// @return Returns a DynamicField with the original, unmodified raw CAN signal value as -/// its numeric value. The 'send' argument will not be modified as this decoder -/// always succeeds. -/// -openxc_DynamicField decoder_t::noopDecoder(can_signal_t& signal, - const std::vector& signals, float value, bool* send) -{ - openxc_DynamicField decoded_value = build_DynamicField(value); - - return decoded_value; -} -/// @brief Coerces a numerical value to a boolean. -/// -/// This is an implementation of the SignalDecoder type signature, and can be -/// used directly in the can_signal_t.decoder field. -/// -/// @param[in] signal - The details of the signal that contains the state mapping. -/// @param[in] signals - The list of all signals -/// @param[in] value - The numerical value that will be converted to a boolean. -/// @param[out] send - An output argument that will be set to false if the value should -/// not be sent for any reason. -/// -/// @return Returns a DynamicField with a boolean value of false if the raw signal value -/// is 0.0, otherwise true. The 'send' argument will not be modified as this -/// decoder always succeeds. -/// -openxc_DynamicField decoder_t::booleanDecoder(can_signal_t& signal, - const std::vector& signals, float value, bool* send) -{ - openxc_DynamicField decoded_value = build_DynamicField(value == 0.0 ? false : true); - - return decoded_value; -} -/// @brief Update the metadata for a signal and the newly received value. -/// -/// This is an implementation of the SignalDecoder type signature, and can be -/// used directly in the can_signal_t.decoder field. -/// -/// This function always flips 'send' to false. -/// -/// @param[in] signal - The details of the signal that contains the state mapping. -/// @param[in] signals - The list of all signals. -/// @param[in] value - The numerical value that will be converted to a boolean. -/// @param[out] send - This output argument will always be set to false, so the caller will -/// know not to publish this value to the pipeline. -/// -/// @return Return value is undefined. -/// -openxc_DynamicField decoder_t::ignoreDecoder(can_signal_t& signal, - const std::vector& signals, float value, bool* send) -{ - if(send) - *send = false; - - openxc_DynamicField decoded_value; - - return decoded_value; -} - -/// @brief Find and return the corresponding string state for a CAN signal's -/// raw integer value. -/// -/// This is an implementation of the SignalDecoder type signature, and can be -/// used directly in the can_signal_t.decoder field. -/// -/// @param[in] signal - The details of the signal that contains the state mapping. -/// @param[in] signals - The list of all signals. -/// @param[in] value - The numerical value that should map to a state. -/// @param[out] send - An output argument that will be set to false if the value should -/// not be sent for any reason. -/// -/// @return Returns a DynamicField with a string value if a matching state is found in -/// the signal. If an equivalent isn't found, send is sent to false and the -/// return value is undefined. -/// -openxc_DynamicField decoder_t::stateDecoder(can_signal_t& signal, - const std::vector& signals, float value, bool* send) -{ - const std::string signal_state = signal.get_states((uint8_t)value); - openxc_DynamicField decoded_value = build_DynamicField(signal_state); - if(signal_state.size() <= 0) - { - *send = false; - ERROR(binder_interface, "stateDecoder: No state found with index: %d", (int)value); - } - return decoded_value; -} - - -/// @brief Parse a signal from a CAN message, apply any required transforations -/// to get a human readable value and public the result to the pipeline. -/// -/// If the can_signal_t has a non-NULL 'decoder' field, the raw CAN signal value -/// will be passed to the decoder before publishing. -/// -/// @param[in] signal - The details of the signal to decode and forward. -/// @param[in] message - The received CAN message that should contain this signal. -/// @param[in] signals - an array of all active signals. -/// -/// The decoder returns an openxc_DynamicField, which may contain a number, -/// string or boolean. -/// -openxc_DynamicField decoder_t::translateSignal(can_signal_t& signal, can_message_t& message, - const std::vector& signals) -{ - float value = decoder_t::parseSignalBitfield(signal, message); - DEBUG(binder_interface, "translateSignal: Decoded message from parseSignalBitfield: %f", value); - - bool send = true; - // Must call the decoders every time, regardless of if we are going to - // decide to send the signal or not. - openxc_DynamicField decoded_value = decoder_t::decodeSignal(signal, - value, signals, &send); - - signal.set_received(true); - signal.set_last_value(value); - return decoded_value; -} - -/// @brief Parse a signal from a CAN message and apply any required -/// transforations to get a human readable value. -/// -/// If the can_signal_t has a non-NULL 'decoder' field, the raw CAN signal value -/// will be passed to the decoder before returning. -/// -/// @param[in] signal - The details of the signal to decode and forward. -/// @param[in] value - The numerical value that will be converted to a boolean. -/// @param[in] signals - an array of all active signals. -/// @param[out] send - An output parameter that will be flipped to false if the value could -/// not be decoded. -/// -/// @return The decoder returns an openxc_DynamicField, which may contain a number, -/// string or boolean. If 'send' is false, the return value is undefined. -/// -openxc_DynamicField decoder_t::decodeSignal( can_signal_t& signal, - float value, const std::vector& signals, bool* send) -{ - SignalDecoder decoder = signal.get_decoder() == nullptr ? - noopDecoder : signal.get_decoder(); - openxc_DynamicField decoded_value = decoder(signal, signals, - value, send); - return decoded_value; -} - -/// @brief Decode a transformed, human readable value from an raw CAN signal -/// already parsed from a CAN message. -/// -/// This is the same as decodeSignal but you must parse the bitfield value of the signal from the CAN -/// message yourself. This is useful if you need that raw value for something -/// else. -/// -/// @param[in] signal - The details of the signal to decode and forward. -/// @param[in] message - Raw CAN message to decode -/// @param[in] signals - an array of all active signals. -/// @param[out] send - An output parameter that will be flipped to false if the value could -/// not be decoded. -/// -openxc_DynamicField decoder_t::decodeSignal( can_signal_t& signal, - const can_message_t& message, const std::vector& signals, bool* send) -{ - float value = parseSignalBitfield(signal, message); - return decodeSignal(signal, value, signals, send); -} - - -/// -/// @brief Decode the payload of an OBD-II PID. -/// -/// This function matches the type signature for a DiagnosticResponseDecoder, so -/// it can be used as the decoder for a DiagnosticRequest. It returns the decoded -/// value of the PID, using the standard formulas (see -/// http://en.wikipedia.org/wiki/OBD-II_PIDs#Mode_01). -/// -/// @param[in] response - the received DiagnosticResponse (the data is in response.payload, -/// a byte array). This is most often used when the byte order is -/// signiticant, i.e. with many OBD-II PID formulas. -/// @param[in] parsed_payload - the entire payload of the response parsed as an int. -/// -/// @return Float decoded value. -/// -float decoder_t::decode_obd2_response(const DiagnosticResponse* response, float parsed_payload) -{ - return diagnostic_decode_obd2_pid(response); -} \ No newline at end of file diff --git a/src/can/can-decoder.hpp b/src/can/can-decoder.hpp deleted file mode 100644 index ebe1de20..00000000 --- a/src/can/can-decoder.hpp +++ /dev/null @@ -1,49 +0,0 @@ -/* - * Copyright (C) 2015, 2016 "IoT.bzh" - * Author "Romain Forlot" - * - * 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. - */ - -#pragma once - -#include "can-signals.hpp" -#include "can-message.hpp" -#include "openxc.pb.h" - -class decoder_t -{ -public: - static float parseSignalBitfield(can_signal_t& signal, const can_message_t& message); - - static openxc_DynamicField stateDecoder(can_signal_t& signal, const std::vector& signals, - float value, bool* send); - static openxc_DynamicField booleanDecoder(can_signal_t& signal, const std::vector& signals, - float value, bool* send); - static openxc_DynamicField ignoreDecoder(can_signal_t& signal, const std::vector& signals, - float value, bool* send); - static openxc_DynamicField noopDecoder(can_signal_t& signal, const std::vector& signals, - float value, bool* send); - - static openxc_DynamicField translateSignal(can_signal_t& signal, can_message_t& message, - const std::vector& signals); - - static openxc_DynamicField decodeSignal(can_signal_t& signal, const can_message_t& message, - const std::vector& signals, bool* send); - - static openxc_DynamicField decodeSignal(can_signal_t& signal, float value, - const std::vector& signals, bool* send); - - static float decode_obd2_response(const DiagnosticResponse* response, float parsed_payload); - -}; \ No newline at end of file diff --git a/src/can/can-message-definition.cpp b/src/can/can-message-definition.cpp deleted file mode 100644 index 206d0b0c..00000000 --- a/src/can/can-message-definition.cpp +++ /dev/null @@ -1,55 +0,0 @@ -/* - * Copyright (C) 2015, 2016 "IoT.bzh" - * Author "Romain Forlot" - * - * 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. - */ - -#include "can-message-definition.hpp" - -can_message_definition_t::can_message_definition_t(std::uint8_t message_set_id, const std::string bus) - : message_set_id_{message_set_id}, bus_{bus}, last_value_{CAN_MESSAGE_SIZE} -{} - -can_message_definition_t::can_message_definition_t(std::uint8_t message_set_id, - const std::string bus, - uint32_t id, - frequency_clock_t frequency_clock, - bool force_send_changed) - : message_set_id_{message_set_id}, - bus_{bus}, - id_{id}, - frequency_clock_{frequency_clock}, - force_send_changed_{force_send_changed}, - last_value_{CAN_MESSAGE_SIZE} -{} - -can_message_definition_t::can_message_definition_t(std::uint8_t message_set_id, - const std::string bus, - uint32_t id, - can_message_format_t format, - frequency_clock_t frequency_clock, - bool force_send_changed) - : message_set_id_{message_set_id}, - bus_{bus}, - id_{id}, - format_{format}, - frequency_clock_{frequency_clock}, - force_send_changed_{force_send_changed}, - last_value_{CAN_MESSAGE_SIZE} -{} - -uint32_t can_message_definition_t::get_id() const -{ - return id_; -} \ No newline at end of file diff --git a/src/can/can-message-definition.hpp b/src/can/can-message-definition.hpp deleted file mode 100644 index 98cb2c5d..00000000 --- a/src/can/can-message-definition.hpp +++ /dev/null @@ -1,57 +0,0 @@ -/* - * Copyright (C) 2015, 2016 "IoT.bzh" - * Author "Romain Forlot" - * - * 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. - */ - -/** - * @class can_message_definition_t - * - * @brief The definition of a CAN message. This includes a lot of metadata, so - * to save memory this struct should not be used for storing incoming and - * outgoing CAN messages. - */ - -#pragma once - -#include -#include - -#include "can-bus-dev.hpp" -#include "can-message.hpp" -#include "../utils/timer.hpp" - -class can_message_definition_t -{ -private: - std::uint8_t message_set_id_; - std::string bus_; /*!< bus_ - Address of CAN bus device. */ - uint32_t id_; /*!< id_ - The ID of the message.*/ - can_message_format_t format_; /*!< format_ - the format of the message's ID.*/ - frequency_clock_t frequency_clock_; /*!< clock_ - an optional frequency clock to control the output of this - * message, if sent raw, or simply to mark the max frequency for custom - * handlers to retrieve.*/ - bool force_send_changed_; /*!< force_send_changed_ - If true, regardless of the frequency, it will send CAN - * message if it has changed when using raw passthrough.*/ - std::vector last_value_; /*!< last_value_ - The last received value of the message. Defaults to undefined. - * This is required for the forceSendChanged functionality, as the stack - * needs to compare an incoming CAN message with the previous frame.*/ - -public: - can_message_definition_t(std::uint8_t message_set_id, const std::string bus); - can_message_definition_t(std::uint8_t message_set_id, const std::string bus, uint32_t id, frequency_clock_t frequency_clock, bool force_send_changed); - can_message_definition_t(std::uint8_t message_set_id, const std::string bus, uint32_t id, can_message_format_t format, frequency_clock_t frequency_clock, bool force_send_changed); - - uint32_t get_id() const; -}; diff --git a/src/can/can-message-set.cpp b/src/can/can-message-set.cpp deleted file mode 100644 index a9f8cf23..00000000 --- a/src/can/can-message-set.cpp +++ /dev/null @@ -1,37 +0,0 @@ -/* - * Copyright (C) 2015, 2016, 2017 "IoT.bzh" - * Author "Romain Forlot" - * Author "Loïc Collignon" - * - * 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. - */ - -#include "can-message-set.hpp" - -can_message_set_t::can_message_set_t( - uint8_t index, - const std::string& name, - uint8_t can_bus_count, - unsigned short can_message_count, - unsigned short can_signal_count, - unsigned short can_command_count, - unsigned short obd2_signal_count) - : index_{index} - , name_{name} - , can_bus_count_{can_bus_count} - , can_message_count_{can_message_count} - , can_signal_count_{can_signal_count} - , can_command_count_{can_command_count} - , obd2_signal_count_{obd2_signal_count} -{ -} diff --git a/src/can/can-message-set.hpp b/src/can/can-message-set.hpp deleted file mode 100644 index 94e2d8d5..00000000 --- a/src/can/can-message-set.hpp +++ /dev/null @@ -1,47 +0,0 @@ -/* - * Copyright (C) 2015, 2016, 2017 "IoT.bzh" - * Author "Romain Forlot" - * Author "Loïc Collignon" - * - * 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. - */ - -#pragma once - -#include -#include - -/// @brief A parent wrapper for a particular set of CAN messages and associated -/// CAN buses(e.g. a vehicle or program). -class can_message_set_t -{ -private: - uint8_t index_; /// < A numerical ID for the message set, ideally the index in an array for fast lookup - const std::string name_; /// < The name of the message set. - uint8_t can_bus_count_; /// < The number of CAN buses defined for this message set. - uint16_t can_message_count_; /// < The number of CAN messages (across all buses) defined for this message set. - uint16_t can_signal_count_; /// < The number of CAN signals (across all messages) defined for this message set. - uint16_t can_command_count_; /// < The number of CanCommmands defined for this message set. - uint16_t obd2_signal_count_; /// < The number of obd2 signals defined for this message set. - -public: - can_message_set_t( - uint8_t index, - const std::string& name, - uint8_t can_bus_count, - short unsigned int can_message_count, - short unsigned int can_signal_count, - short unsigned int can_command_count, - short unsigned int obd2_signal_count); - -}; diff --git a/src/can/can-message.cpp b/src/can/can-message.cpp deleted file mode 100644 index f61de67e..00000000 --- a/src/can/can-message.cpp +++ /dev/null @@ -1,264 +0,0 @@ -/* - * Copyright (C) 2015, 2016 "IoT.bzh" - * Author "Romain Forlot" - * - * 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. - */ - -#include "can-message.hpp" - -#include - -#include "../low-can-binding.hpp" - -/// -/// @brief Class constructor -/// -/// Constructor about can_message_t class. -/// -can_message_t::can_message_t() - : maxdlen_{0}, id_{0}, length_{0}, format_{can_message_format_t::ERROR}, rtr_flag_{false}, flags_{0} -{} - -can_message_t::can_message_t(uint8_t maxdlen, - uint32_t id, - uint8_t length, - can_message_format_t format, - bool rtr_flag, - uint8_t flags, - std::vector data) - : maxdlen_{maxdlen}, - id_{id}, - length_{length}, - format_{format}, - rtr_flag_{rtr_flag}, - flags_{flags}, - data_{data} -{} - -/// -/// @brief Retrieve id_ member value. -/// -/// @return id_ class member -/// -uint32_t can_message_t::get_id() const -{ - return id_; -} - -/// -/// @brief Retrieve RTR flag member. -/// -/// @return rtr_flags_ class member -/// -bool can_message_t::get_rtr_flag_() const -{ - return rtr_flag_; -} - -/// -/// @brief Retrieve format_ member value. -/// -/// @return format_ class member -/// -can_message_format_t can_message_t::get_format() const -{ - if (format_ != can_message_format_t::STANDARD || format_ != can_message_format_t::EXTENDED) - return can_message_format_t::ERROR; - return format_; -} - -/// -/// @brief Retrieve flags_ member value. -/// -/// @return flags_ class member -/// -uint8_t can_message_t::get_flags() const -{ - return flags_; -} - -/// -/// @brief Retrieve data_ member value. -/// -/// @return pointer to the first element -/// of class member data_ -/// -const uint8_t* can_message_t::get_data() const -{ - return data_.data(); -} - -/// -/// @brief Retrieve length_ member value. -/// -/// @return length_ class member -/// -uint8_t can_message_t::get_length() const -{ - return length_; -} - -/// -/// @brief Control whether the object is correctly initialized -/// to be sent over the CAN bus -/// -/// @return true if object correctly initialized and false if not. -/// -bool can_message_t::is_correct_to_send() -{ - if (id_ != 0 && length_ != 0 && format_ != can_message_format_t::ERROR) - { - int i; - for(i=0;i data; - - switch(nbytes) - { - case CANFD_MTU: - DEBUG(binder_interface, "set_max_data_length: Got an CAN FD frame"); - maxdlen = CANFD_MAX_DLEN; - break; - case CAN_MTU: - DEBUG(binder_interface, "set_max_data_length: Got a legacy CAN frame"); - maxdlen = CAN_MAX_DLEN; - break; - default: - ERROR(binder_interface, "set_max_data_length: unsupported CAN frame"); - break; - } - - if (frame.can_id & CAN_ERR_FLAG) - format = can_message_format_t::ERROR; - else if (frame.can_id & CAN_EFF_FLAG) - format = can_message_format_t::EXTENDED; - else - format = can_message_format_t::STANDARD; - - switch(format) - { - case can_message_format_t::STANDARD: - id = frame.can_id & CAN_SFF_MASK; - break; - case can_message_format_t::EXTENDED: - id = frame.can_id & CAN_EFF_MASK; - break; - case can_message_format_t::ERROR: - id = frame.can_id & (CAN_ERR_MASK|CAN_ERR_FLAG); - break; - default: - ERROR(binder_interface, "ERROR: Can set id, not a compatible format or format not set prior to set id."); - break; - } - - /* Overwrite length_ if RTR flags is detected. - * standard CAN frames may have RTR enabled. There are no ERR frames with RTR */ - if (frame.can_id & CAN_RTR_FLAG) - { - rtr_flag = true; - if(frame.len && frame.len <= CAN_MAX_DLC) - { - if(rtr_flag) - length = frame.len& 0xF; - else - { - length = (frame.len > maxdlen) ? maxdlen : frame.len; - } - } - } - else - { - length = (frame.len > maxdlen) ? maxdlen : frame.len; - - /* Flags field only present for CAN FD frames*/ - if(maxdlen == CANFD_MAX_DLEN) - flags = frame.flags & 0xF; - - if (data.capacity() < maxdlen) - data.reserve(maxdlen); - int i; - - data.clear(); - /* maxdlen_ is now set at CAN_MAX_DLEN or CANFD_MAX_DLEN, respectively 8 and 64 bytes*/ - for(i=0;i - * - * 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. - */ - -#pragma once - -#include -#include -#include -#include - -#include "../utils/timer.hpp" -#include "can-message-set.hpp" - -#define CAN_MESSAGE_SIZE 8 - -class can_bus_dev_t; - -/** - * @enum can_message_format_t - * @brief The ID format for a CAN message. - */ -enum class can_message_format_t { - STANDARD, /*!< STANDARD - standard 11-bit CAN arbitration ID. */ - EXTENDED, /*!< EXTENDED - an extended frame, with a 29-bit arbitration ID. */ - ERROR, /*!< ERROR - ERROR code used at initialization to signify that it isn't usable'*/ -}; - -/** - * @class can_message_t - * - * @brief A compact representation of a single CAN message, meant to be used in in/out - * buffers. - */ -class can_message_t { -private: - uint8_t maxdlen_; /*!< maxdlen_ - Max data length deduce from number of bytes read from the socket.*/ - uint32_t id_; /*!< id_ - The ID of the message. */ - uint8_t length_; /*!< length_ - the length of the data array (max 8). */ - can_message_format_t format_; /*!< format_ - the format of the message's ID.*/ - bool rtr_flag_; /*!< rtr_flag_ - Telling if the frame has RTR flag positionned. Then frame hasn't data field*/ - uint8_t flags_; /*!< flags_ - flags of a CAN FD frame. Needed if we catch FD frames.*/ - std::vector data_; /*!< data_ - The message's data field with a size of 8 which is the standard about CAN bus messages.*/ - -public: - can_message_t(); - can_message_t(uint8_t maxdlen, uint32_t id, uint8_t length, can_message_format_t format, bool rtr_flag_, uint8_t flags, std::vector data); - - uint32_t get_id() const; - bool get_rtr_flag_() const; - can_message_format_t get_format() const; - uint8_t get_flags() const; - const uint8_t* get_data() const; - uint8_t get_length() const; - - void set_format(const can_message_format_t new_format); - - bool is_correct_to_send(); - -static can_message_t convert_from_canfd_frame(const struct canfd_frame& frame, size_t nbytes); - canfd_frame convert_to_canfd_frame(); -}; diff --git a/src/can/can-signals.cpp b/src/can/can-signals.cpp deleted file mode 100644 index 6211fa1d..00000000 --- a/src/can/can-signals.cpp +++ /dev/null @@ -1,186 +0,0 @@ -/* - * Copyright (C) 2015, 2016 "IoT.bzh" - * Author "Romain Forlot" - * - * 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. - */ - -#include - -#include "can-signals.hpp" - -#include "../configuration.hpp" -#include "../utils/signals.hpp" -#include "can-decoder.hpp" -#include "../diagnostic/diagnostic-message.hpp" - -std::string can_signal_t::prefix_ = "messages"; - -can_signal_t::can_signal_t(std::uint8_t message_set_id, - std::uint8_t message_id, - std::string generic_name, - uint8_t bit_position, - uint8_t bit_size, - float factor, - float offset, - float min_value, - float max_value, - frequency_clock_t frequency, - bool send_same, - bool force_send_changed, - std::map states, - bool writable, - SignalDecoder decoder, - SignalEncoder encoder, - bool received) - : message_set_id_{ message_set_id } - , message_id_{ message_id } - , generic_name_{ generic_name } - , bit_position_{ bit_position } - , bit_size_{ bit_size } - , factor_{ factor } - , offset_{ offset } - , min_value_{min_value} - , max_value_{max_value} - , frequency_{frequency} - , send_same_{send_same} - , force_send_changed_{force_send_changed} - , states_{states} - , writable_{writable} - , decoder_{decoder} - , encoder_{encoder} - , received_{received} - , last_value_{.0f} -{} - - -const can_message_definition_t& can_signal_t::get_message() const -{ - return configuration_t::instance().get_can_message_definition(message_set_id_, message_id_); -} - -const std::string& can_signal_t::get_generic_name() const -{ - return generic_name_; -} - -const std::string can_signal_t::get_name() const -{ - return prefix_ + "." + generic_name_; -} - -const std::string& can_signal_t::get_prefix() const -{ - return prefix_; -} - -uint8_t can_signal_t::get_bit_position() const -{ - return bit_position_; -} - -uint8_t can_signal_t::get_bit_size() const -{ - return bit_size_; -} - -float can_signal_t::get_factor() const -{ - return factor_; -} - -float can_signal_t::get_offset() const -{ - return offset_; -} - -float can_signal_t::get_min_value() const -{ - return min_value_; -} - -float can_signal_t::get_max_value() const -{ - return max_value_; -} - -frequency_clock_t& can_signal_t::get_frequency() -{ - return frequency_; -} - -bool can_signal_t::get_send_same() const -{ - return send_same_; -} - -bool can_signal_t::get_force_send_changed() const -{ - return force_send_changed_; -} - -const std::map& can_signal_t::get_states() const -{ - return states_; -} - -const std::string can_signal_t::get_states(uint8_t value) -{ - if (value < states_.size()) - return states_[value]; - return std::string(); -} - -size_t can_signal_t::get_state_count() const -{ - return states_.size(); -} - -bool can_signal_t::get_writable() const -{ - return writable_; -} - -SignalDecoder& can_signal_t::get_decoder() -{ - return decoder_; -} - -SignalEncoder& can_signal_t::get_encoder() -{ - return encoder_; -} - -bool can_signal_t::get_received() const -{ - return received_; -} -float can_signal_t::get_last_value() const -{ - return last_value_; -} - -void can_signal_t::set_prefix(std::string val) -{ - prefix_ = val; -} - -void can_signal_t::set_received(bool r) -{ - received_ = r; -} - -void can_signal_t::set_last_value(float val) -{ - last_value_ = val; -} diff --git a/src/can/can-signals.hpp b/src/can/can-signals.hpp deleted file mode 100644 index 34ebeebd..00000000 --- a/src/can/can-signals.hpp +++ /dev/null @@ -1,158 +0,0 @@ -/// -/// Copyright (C) 2015, 2016 "IoT.bzh" -/// Author "Romain Forlot" -/// -/// 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. -/// - -#pragma once - -#include -#include -#include -#include -#include - -#include "openxc.pb.h" -#include "../utils/timer.hpp" -#include "can-bus.hpp" -#include "can-message.hpp" -#include "can-message-definition.hpp" -#include "../diagnostic/diagnostic-message.hpp" - -extern "C" -{ - #include - #include -} - -#define MESSAGE_SET_ID 0 - -class can_signal_t; - -/// -/// @brief The type signature for a CAN signal decoder. -/// -/// A SignalDecoder transforms a raw floating point CAN signal into a number, -/// string or boolean. -/// -/// @param[in] signal - The CAN signal that we are decoding. -/// @param[in] signals - The list of all signals. -/// @param[in] signalCount - The length of the signals array. -/// @param[in] value - The CAN signal parsed from the message as a raw floating point -/// value. -/// @param[out] send - An output parameter. If the decoding failed or the CAN signal should -/// not send for some other reason, this should be flipped to false. -/// -/// @return a decoded value in an openxc_DynamicField struct. -/// -typedef openxc_DynamicField (*SignalDecoder)(can_signal_t& signal, - const std::vector& signals, float value, bool* send); - -/// -/// @brief: The type signature for a CAN signal encoder. -/// -/// A SignalEncoder transforms a number, string or boolean into a raw floating -/// point value that fits in the CAN signal. -/// -/// @param[in] signal - The CAN signal to encode. -/// @param[in] value - The dynamic field to encode. -/// @param[out] send - An output parameter. If the encoding failed or the CAN signal should -/// not be encoded for some other reason, this will be flipped to false. -/// -typedef uint64_t (*SignalEncoder)(can_signal_t* signal, - openxc_DynamicField* value, bool* send); - -class can_signal_t -{ -private: - std::uint8_t message_set_id_; - std::uint8_t message_id_; - std::string generic_name_; /*!< generic_name_ - The name of the signal to be output.*/ - static std::string prefix_; /*!< prefix_ - generic_name_ will be prefixed with it. It has to reflect the used protocol. - * which make easier to sort message when the come in.*/ - uint8_t bit_position_; /*!< bitPosition_ - The starting bit of the signal in its CAN message (assuming - * non-inverted bit numbering, i.e. the most significant bit of - * each byte is 0) */ - uint8_t bit_size_; /*!< bitSize_ - The width of the bit field in the CAN message. */ - float factor_; /*!< factor_ - The final value will be multiplied by this factor. Use 1 if you - * don't need a factor. */ - float offset_; /*!< offset_ - The final value will be added to this offset. Use 0 if you - * don't need an offset. */ - float min_value_; /*!< min_value_ - The minimum value for the processed signal.*/ - float max_value_; /*!< max_value_ - The maximum value for the processed signal. */ - frequency_clock_t frequency_; /*!< frequency_ - A frequency_clock_t struct to control the maximum frequency to - * process and send this signal. To process every value, set the - * clock's frequency to 0. */ - bool send_same_; /*!< send_same_ - If true, will re-send even if the value hasn't changed.*/ - bool force_send_changed_; /*!< force_send_changed_ - If true, regardless of the frequency, it will send the - * value if it has changed. */ - std::map states_; /*!< states_ - A map of CAN signal state describing the mapping - * between numerical and string values for valid states. */ - bool writable_; /*!< writable - True if the signal is allowed to be written from the USB host - * back to CAN. Defaults to false.*/ - SignalDecoder decoder_; /*!< decoder_ - An optional function to decode a signal from the bus to a human - * readable value. If NULL, the default numerical decoder is used. */ - SignalEncoder encoder_; /*!< encoder_ - An optional function to encode a signal value to be written to - * CAN into a byte array. If NULL, the default numerical encoder - * is used. */ - bool received_; /*!< received_ - True if this signal has ever been received.*/ - float last_value_; /*!< lastValue_ - The last received value of the signal. If 'received' is false, - * this value is undefined. */ - -public: - can_signal_t( - std::uint8_t message_set_id, - std::uint8_t message_id, - std::string generic_name, - uint8_t bit_position, - uint8_t bit_size, - float factor, - float offset, - float min_value, - float max_value, - frequency_clock_t frequency, - bool send_same, - bool force_send_changed, - std::map states, - bool writable, - SignalDecoder decoder, - SignalEncoder encoder, - bool received); - - const can_message_definition_t& get_message() const; - const std::string& get_generic_name() const; - const std::string get_name() const; - const std::string& get_prefix() const; - uint8_t get_bit_position() const; - uint8_t get_bit_size() const; - float get_factor() const; - float get_offset() const; - float get_min_value() const; - float get_max_value() const; - frequency_clock_t& get_frequency(); - bool get_send_same() const; - bool get_force_send_changed() const; - const std::map& get_states() const; - const std::string get_states(uint8_t value); - size_t get_state_count() const; - bool get_writable() const; - SignalDecoder& get_decoder(); - SignalEncoder& get_encoder(); - bool get_received() const; - float get_last_value() const; - - void set_prefix(std::string val); - void set_received(bool r); - void set_last_value(float val); -}; \ No newline at end of file diff --git a/src/can_buses.json.in b/src/can_buses.json.in deleted file mode 100644 index c4292df2..00000000 --- a/src/can_buses.json.in +++ /dev/null @@ -1,3 +0,0 @@ -{ - "canbus": "can0" -} diff --git a/src/config.xml.in b/src/config.xml.in deleted file mode 100644 index d735ce2b..00000000 --- a/src/config.xml.in +++ /dev/null @@ -1,11 +0,0 @@ - - - @PROJECT_NAME@ - - - This is a demo application used to control and dialog with HVAC system - Romain Forlot <romain.forlot@iot.bzh> - APL 2.0 - - - diff --git a/src/configuration.cpp b/src/configuration.cpp deleted file mode 100644 index 8a50cbc4..00000000 --- a/src/configuration.cpp +++ /dev/null @@ -1,156 +0,0 @@ -/* - * Copyright (C) 2015, 2016 "IoT.bzh" - * Author "Romain Forlot" - * - * 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. - */ - -#include "configuration.hpp" - -#include "utils/signals.hpp" -#include "utils/openxc-utils.hpp" - -/// @brief Return singleton instance of configuration object. -configuration_t& configuration_t::instance() -{ - static configuration_t config; - return config; -} - -can_bus_t& configuration_t::get_can_bus_manager() -{ - return can_bus_manager_; -} - -const std::map>& configuration_t::get_can_bus_devices() -{ - return can_bus_manager_.get_can_devices(); -} - -diagnostic_manager_t& configuration_t::get_diagnostic_manager() -{ - return diagnostic_manager_; -} - -uint8_t configuration_t::get_active_message_set() const -{ - return active_message_set_; -} - -const std::vector& configuration_t::get_can_message_set() -{ - return can_message_set_; -} - -std::vector& configuration_t::get_can_signals() -{ - return can_signals_[active_message_set_]; -} - -std::vector& configuration_t::get_diagnostic_messages() -{ - return diagnostic_messages_[active_message_set_]; -} - -const std::vector& configuration_t::get_can_message_definition() -{ - return can_message_definition_[active_message_set_]; -} - -const can_message_definition_t& configuration_t::get_can_message_definition(std::uint8_t message_set_id, std::uint8_t message_id) -{ - return can_message_definition_[message_set_id][message_id]; -} - -uint32_t configuration_t::get_signal_id(diagnostic_message_t& sig) const -{ - return sig.get_pid(); -} - -uint32_t configuration_t::get_signal_id(can_signal_t& sig) const -{ - return sig.get_message().get_id(); -} - -void configuration_t::set_active_message_set(uint8_t id) -{ - active_message_set_ = id; -} - -/// @brief return diagnostic messages name found searching through diagnostic messages list. -/// -/// @param[in] key - can contain numeric or string value in order to search against -/// can signals or obd2 signals name. -/// @param[out] found_signals - Vector of signals name found. -/// -void configuration_t::find_diagnostic_messages(const openxc_DynamicField &key, std::vector& found_signals) -{ - switch(key.type) - { - case openxc_DynamicField_Type::openxc_DynamicField_Type_STRING: - lookup_signals_by_name(key.string_value, diagnostic_messages_[active_message_set_], found_signals); - break; - case openxc_DynamicField_Type::openxc_DynamicField_Type_NUM: - lookup_signals_by_id(key.numeric_value, diagnostic_messages_[active_message_set_], found_signals); - break; - default: - ERROR(binder_interface, "find_diagnostic_messages: wrong openxc_DynamicField specified. Use openxc_DynamicField_Type_NUM or openxc_DynamicField_Type_STRING type only."); - break; - } - DEBUG(binder_interface, "find_diagnostic_messages: Found %d signal(s)", (int)found_signals.size()); -} - -diagnostic_message_t* configuration_t::get_diagnostic_message(std::string message_name) const -{ - std::vector found; - configuration_t::instance().find_diagnostic_messages(build_DynamicField(message_name), found); - if(! found.empty()) - return found.front(); - return nullptr; -} - -DiagnosticRequest* configuration_t::get_request_from_diagnostic_message(diagnostic_message_t* diag_msg) const -{ - return new DiagnosticRequest(diag_msg->build_diagnostic_request()); -} - -DiagnosticRequest* configuration_t::get_request_from_diagnostic_message(std::string message_name) const -{ - diagnostic_message_t* diag_msg = get_diagnostic_message(message_name); - if( diag_msg != nullptr) - return new DiagnosticRequest(diag_msg->build_diagnostic_request()); - return nullptr; -} - -/// @brief return signals name found searching through CAN signals list. -/// -/// @param[in] key - can contain numeric or string value in order to search against -/// can signals or obd2 signals name. -/// @param[out] found_signals - provided vector to fill with pointer to matched signals. -/// -void configuration_t::find_can_signals(const openxc_DynamicField& key, std::vector& found_signals) -{ - switch(key.type) - { - case openxc_DynamicField_Type::openxc_DynamicField_Type_STRING: - lookup_signals_by_name(std::string(key.string_value), can_signals_[active_message_set_], found_signals); - break; - case openxc_DynamicField_Type::openxc_DynamicField_Type_NUM: - lookup_signals_by_id(key.numeric_value, can_signals_[active_message_set_], found_signals); - break; - default: - ERROR(binder_interface, "find_can_signals: wrong openxc_DynamicField specified. Use openxc_DynamicField_Type_NUM or openxc_DynamicField_Type_STRING type only."); - break; - } - DEBUG(binder_interface, "find_can_signals: Found %d signal(s)", (int)found_signals.size()); -} diff --git a/src/configuration.hpp b/src/configuration.hpp deleted file mode 100644 index 017b148d..00000000 --- a/src/configuration.hpp +++ /dev/null @@ -1,120 +0,0 @@ -/* - * Copyright (C) 2015, 2016 "IoT.bzh" - * Author "Romain Forlot" - * - * 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. - */ - -#pragma once - -#include -#include -#include -#include - -#include "can/can-bus.hpp" -#include "can/can-signals.hpp" -#include "can/can-message.hpp" -#include "diagnostic/diagnostic-manager.hpp" - -#include "low-can-binding.hpp" - -/// -/// @brief Class representing a configuration attached to the binding. -/// -/// It regroups all needed objects instance from other class -/// that will be used along the binding life. It gets a global vision -/// on which signals are implemented for that binding. -/// Here, it is only the definition of the class with predefined accessors -/// methods used in the binding. -/// -/// It will be the reference point to needed objects. -/// -class configuration_t -{ - private: - can_bus_t can_bus_manager_ = can_bus_t( - afb_daemon_rootdir_open_locale( - binder_interface->daemon, "etc/can_buses.json", O_RDONLY, NULL)); ///< instanciate the CAN bus - ///< This will read the configuration file and initialize all CAN devices specified in it. - diagnostic_manager_t diagnostic_manager_; ///< Diagnostic manager use to manage diagnostic message communication. - uint8_t active_message_set_ = 0; ///< Which is the active message set ? Default to 0. - - std::vector can_message_set_; - std::vector> can_message_definition_; - std::vector> can_signals_; - std::vector> diagnostic_messages_; - - configuration_t(); ///< Private constructor with implementation generated by the AGL generator. - - public: - static configuration_t& instance(); - - can_bus_t& get_can_bus_manager(); - - const std::map>& get_can_bus_devices(); - - const std::string get_diagnostic_bus() const; - - diagnostic_manager_t& get_diagnostic_manager() ; - - uint8_t get_active_message_set() const; - - const std::vector& get_can_message_set(); - - std::vector& get_can_signals(); - - std::vector& get_diagnostic_messages(); - - const std::vector& get_signals_prefix() const; - - const std::vector& get_can_message_definition(); - const can_message_definition_t& get_can_message_definition(std::uint8_t message_set_id, std::uint8_t message_id); - - uint32_t get_signal_id(diagnostic_message_t& sig) const; - - uint32_t get_signal_id(can_signal_t& sig) const; - - void set_active_message_set(uint8_t id); - - void find_diagnostic_messages(const openxc_DynamicField &key, std::vector& found_signals); - diagnostic_message_t* get_diagnostic_message(std::string message_name) const; - DiagnosticRequest* get_request_from_diagnostic_message(diagnostic_message_t* diag_msg) const; - DiagnosticRequest* get_request_from_diagnostic_message(std::string message_name) const; - - void find_can_signals(const openxc_DynamicField &key, std::vector& found_signals); - -/* - /// TODO: implement this function as method into can_bus class - /// @brief Pre initialize actions made before CAN bus initialization - /// @param[in] bus A CanBus struct defining the bus's metadata - /// @param[in] writable Configure the controller in a writable mode. If false, it will be configured as "listen only" and will not allow writes or even CAN ACKs. - /// @param[in] buses An array of all CAN buses. - void pre_initialize(can_bus_dev_t* bus, bool writable, can_bus_dev_t* buses, const int busCount); - /// TODO: implement this function as method into can_bus class - /// @brief Post-initialize actions made after CAN bus initialization - /// @param[in] bus A CanBus struct defining the bus's metadata - /// @param[in] writable Configure the controller in a writable mode. If false, it will be configured as "listen only" and will not allow writes or even CAN ACKs. - /// @param[in] buses An array of all CAN buses. - void post_initialize(can_bus_dev_t* bus, bool writable, can_bus_dev_t* buses, const int busCount); - /// TODO: implement this function as method into can_bus class - /// @brief Check if the device is connected to an active CAN bus, i.e. it's received a message in the recent past. - /// @return true if a message was received on the CAN bus within CAN_ACTIVE_TIMEOUT_S seconds. - void logBusStatistics(can_bus_dev_t* buses, const int busCount); - /// TODO: implement this function as method into can_bus class - /// @brief Log transfer statistics about all active CAN buses to the debug log. - /// @param[in] buses An array of active CAN buses. - bool isBusActive(can_bus_dev_t* bus); - */ -}; - diff --git a/src/diagnostic/active-diagnostic-request.cpp b/src/diagnostic/active-diagnostic-request.cpp deleted file mode 100644 index 7ddf1d51..00000000 --- a/src/diagnostic/active-diagnostic-request.cpp +++ /dev/null @@ -1,194 +0,0 @@ -/* - * Copyright (C) 2015, 2016 "IoT.bzh" - * Author "Romain Forlot" - * - * 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. - */ - -#include -#include - -#include "active-diagnostic-request.hpp" - -#include "../configuration.hpp" - -#define ERROR_PID 0xFF - -std::string active_diagnostic_request_t::prefix_ = "diagnostic_messages"; - -bool active_diagnostic_request_t::operator==(const active_diagnostic_request_t& b) -{ - return (bus_ == b.bus_ && id_ == b.id_ && handle_ == b.handle_); -} - -active_diagnostic_request_t& active_diagnostic_request_t::operator=(const active_diagnostic_request_t& adr) -{ - if (this != &adr) - { - bus_ = adr.bus_; - id_ = adr.id_; - handle_ = adr.handle_; - name_ = adr.name_; - decoder_ = adr.decoder_; - callback_ = adr.callback_; - recurring_ = adr.recurring_; - wait_for_multiple_responses_ = adr.wait_for_multiple_responses_; - in_flight_ = adr.in_flight_; - frequency_clock_ = adr.frequency_clock_; - timeout_clock_ = adr.timeout_clock_; - } - - return *this; -} - -active_diagnostic_request_t::active_diagnostic_request_t() - : bus_{nullptr}, id_{0}, handle_{nullptr}, name_{""}, - decoder_{nullptr}, callback_{nullptr}, recurring_{false}, wait_for_multiple_responses_{false}, - in_flight_{false}, frequency_clock_{frequency_clock_t()}, timeout_clock_{frequency_clock_t()} -{} - -active_diagnostic_request_t::active_diagnostic_request_t(const std::string& bus, DiagnosticRequest* request, - const std::string& name, bool wait_for_multiple_responses, const DiagnosticResponseDecoder decoder, - const DiagnosticResponseCallback callback, float frequencyHz) - : bus_{bus}, id_{request->arbitration_id}, handle_{nullptr}, name_{name}, - decoder_{decoder}, callback_{callback}, recurring_{frequencyHz ? true : false}, wait_for_multiple_responses_{wait_for_multiple_responses}, - in_flight_{false}, frequency_clock_{frequency_clock_t(frequencyHz)}, timeout_clock_{frequency_clock_t(10)} -{} - -uint32_t active_diagnostic_request_t::get_id() const -{ - return id_; -} - -const std::shared_ptr active_diagnostic_request_t::get_can_bus_dev() const -{ - return can_bus_t::get_can_device(bus_); -} - -uint16_t active_diagnostic_request_t::get_pid() const -{ - if (handle_->request.has_pid) - return handle_->request.pid; - return ERROR_PID; -} - -DiagnosticRequestHandle* active_diagnostic_request_t::get_handle() -{ - return handle_; -} - -const std::string active_diagnostic_request_t::get_name() const -{ - return name_; -} - -std::string& active_diagnostic_request_t::get_prefix() -{ - return active_diagnostic_request_t::prefix_; -} - -DiagnosticResponseDecoder& active_diagnostic_request_t::get_decoder() -{ - return decoder_; -} - -DiagnosticResponseCallback& active_diagnostic_request_t::get_callback() -{ - return callback_; -} - -bool active_diagnostic_request_t::get_recurring() const -{ - return recurring_; -} - -bool active_diagnostic_request_t::get_in_flight() const -{ - return in_flight_; -} - -frequency_clock_t& active_diagnostic_request_t::get_frequency_clock() -{ - return frequency_clock_; -} - -frequency_clock_t& active_diagnostic_request_t::get_timeout_clock() -{ - return timeout_clock_; -} - -void active_diagnostic_request_t::set_handle(DiagnosticShims& shims, DiagnosticRequest* request) -{ - handle_ = new DiagnosticRequestHandle(generate_diagnostic_request(&shims, request, nullptr)); -} - -void active_diagnostic_request_t::set_in_flight(bool val) -{ - in_flight_ = val; -} - -/// -/// @brief Check if requested signal name is a diagnostic message. If the name -/// begin with the diagnostic message prefix then true else false. -/// -/// @param[in] name - A signal name. -/// -/// @return true if name began with the diagnostic message prefix else false. -/// -bool active_diagnostic_request_t::is_diagnostic_signal(const std::string& name) -{ - const std::string p = active_diagnostic_request_t::prefix_ + "*"; - if(::fnmatch(p.c_str(), name.c_str(), FNM_CASEFOLD) == 0) - return true; - return false; -} - -/// @brief Check is the request should be sent or not -/// -/// @return true if the request is not running or recurring nor completed, -/// or it's recurring, its clock elapsed -/// so it's time to send another one. -bool active_diagnostic_request_t::should_send() -{ - return !in_flight_ && ( (!recurring_ && !request_completed()) || - (recurring_ && frequency_clock_.elapsed(true)) ); -} - -/// @brief check if the timeout clock has elapsed -/// -/// @return true if elapsed, so it is a timeout, else false. -bool active_diagnostic_request_t::timed_out() -{ - // don't use staggered start with the timeout clock - return timeout_clock_.elapsed(false); -} - -/// @brief Returns true if a sufficient response has been received for a -/// diagnostic request. -/// -/// This is true when at least one response has been received and the request is -/// configured to not wait for multiple responses. Functional broadcast requests -/// may often wish to wait the full 100ms for modules to respond. -bool active_diagnostic_request_t::response_received() const -{ - return !wait_for_multiple_responses_ && - handle_->completed; -} - -/// @brief Returns true if the request has timed out waiting for a response, -/// or a sufficient number of responses has been received. -bool active_diagnostic_request_t::request_completed() -{ - return response_received() || - (timed_out() && diagnostic_request_sent(handle_)); -} diff --git a/src/diagnostic/active-diagnostic-request.hpp b/src/diagnostic/active-diagnostic-request.hpp deleted file mode 100644 index 247eeb17..00000000 --- a/src/diagnostic/active-diagnostic-request.hpp +++ /dev/null @@ -1,122 +0,0 @@ -/* - * Copyright (C) 2015, 2016 "IoT.bzh" - * Author "Romain Forlot" - * - * 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. - */ - -#pragma once - -#include -#include - -#include "uds/uds.h" -#include "uds/uds_types.h" -#include "../utils/timer.hpp" -#include "../can/can-bus-dev.hpp" - -class active_diagnostic_request_t; -class diagnostic_manager_t; - -/// @brief The signature for an optional function that can apply the neccessary -/// formula to translate the binary payload into meaningful data. -/// -/// @param[in] response - the received DiagnosticResponse (the data is in response.payload, -/// a byte array). This is most often used when the byte order is signiticant, i.e. with many OBD-II PID formulas. -/// @param[in] parsed_payload - the entire payload of the response parsed as an int. -/// -/// @return float value after decoding. -/// -typedef float (*DiagnosticResponseDecoder)(const DiagnosticResponse* response, - float parsed_payload); - -/// @brief: The signature for an optional function to handle a new diagnostic -/// response. -/// -/// @param[in] request - The original diagnostic request. -/// @param[in] response - The response object that was just received. -/// @param[in] parsed_payload - The payload of the response, parsed as a float. -/// -typedef void (*DiagnosticResponseCallback)(const active_diagnostic_request_t* request, - const DiagnosticResponse* response, float parsed_payload); - -/// -/// @brief An active diagnostic request, either recurring or one-time. -/// -/// Will host a diagnostic_message_t class members to describe an on going -/// diagnostic request on the CAN bus. Diagnostic message will be converted to -/// a DiagnosticRequest using ad-hoc method build_diagnostic_request from diagnostic message. -/// Then missing member, that can not be hosted into a DiagnosticRequest struct, will be passed -/// as argument when adding the request to (non)-recurrent vector. Argument will be used to instanciate -/// an active_diagnostic_request_t object before sending it. -/// -class active_diagnostic_request_t { -private: - std::string bus_; ///< bus_ - The CAN bus this request should be made on, or is currently in flight-on - uint32_t id_; ///< id_ - The arbitration ID (aka message ID) for the request. - DiagnosticRequestHandle* handle_; ///< handle_ - A handle for the request to keep track of it between - ///< sending the frames of the request and receiving all frames of the response. - std::string name_; ///< name_ - Human readable name, to be used when publishing received responses. - ///< TODO: If the name is NULL, the published output will use the raw OBD-II response format. - static std::string prefix_; ///< prefix_ - It has to reflect the JSON object which it comes from. It makes easier sorting - ///< incoming CAN messages. - DiagnosticResponseDecoder decoder_; ///< decoder_ - An optional DiagnosticResponseDecoder to parse the payload of responses - ///< to this request. If the decoder is NULL, the output will include the raw payload - ///< instead of a parsed value. - DiagnosticResponseCallback callback_; ///< callback_ - An optional DiagnosticResponseCallback to be notified whenever a - ///< response is received for this request. - bool recurring_; ///< bool recurring_ - If true, this is a recurring request and it will remain as active until explicitly cancelled. - ///< The frequencyClock attribute controls how often a recurrin request is made. - bool wait_for_multiple_responses_; ///< wait_for_multiple_responses_ - False by default, when any response is received for a request - ///< it will be removed from the active list. If true, the request will remain active until the timeout - ///< clock expires, to allow it to receive multiple response (e.g. to a functional broadcast request). - bool in_flight_; ///< in_flight_ - True if the request has been sent and we are waiting for a response. - frequency_clock_t frequency_clock_; ///< frequency_clock_ - A frequency_clock_t object to control the send rate for a - ///< recurring request. If the request is not reecurring, this attribute is not used. - frequency_clock_t timeout_clock_; ///< timeout_clock_ - A frequency_clock_t object to monitor how long it's been since - ///< this request was sent. -public: - bool operator==(const active_diagnostic_request_t& b); - active_diagnostic_request_t& operator=(const active_diagnostic_request_t& adr); - - active_diagnostic_request_t(); - active_diagnostic_request_t(active_diagnostic_request_t&&) = default; - active_diagnostic_request_t(const std::string& bus, DiagnosticRequest* request, - const std::string& name, bool wait_for_multiple_responses, - const DiagnosticResponseDecoder decoder, - const DiagnosticResponseCallback callback, float frequencyHz); - - uint32_t get_id() const; - const std::shared_ptr get_can_bus_dev() const; - DiagnosticRequestHandle* get_handle(); - uint16_t get_pid() const; - const std::string get_name() const; - static std::string& get_prefix(); - DiagnosticResponseDecoder& get_decoder(); - DiagnosticResponseCallback& get_callback(); - bool get_recurring() const; - bool get_in_flight() const; - frequency_clock_t& get_frequency_clock(); - frequency_clock_t& get_timeout_clock(); - - void set_handle(DiagnosticShims& shims, DiagnosticRequest* request); - void set_in_flight(bool val); - - static bool is_diagnostic_signal(const std::string& name); - - bool should_send(); - - bool timed_out(); - bool response_received() const; - bool request_completed(); -}; diff --git a/src/diagnostic/diagnostic-manager.cpp b/src/diagnostic/diagnostic-manager.cpp deleted file mode 100644 index e3a78d0f..00000000 --- a/src/diagnostic/diagnostic-manager.cpp +++ /dev/null @@ -1,618 +0,0 @@ -/* - * Copyright (C) 2015, 2016 "IoT.bzh" - * Author "Romain Forlot" - * - * 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. - */ - -#include -#include - -#include "diagnostic-manager.hpp" - -#include "../utils/openxc-utils.hpp" -#include "../configuration.hpp" - -#define MAX_RECURRING_DIAGNOSTIC_FREQUENCY_HZ 10 -#define MAX_SIMULTANEOUS_DIAG_REQUESTS 50 -// There are only 8 slots of in flight diagnostic requests -#define MAX_SIMULTANEOUS_IN_FLIGHT_REQUESTS 8 -#define TIMERFD_ACCURACY 0 -#define MICRO 1000000 - -diagnostic_manager_t::diagnostic_manager_t() - : initialized_{false} -{} - -/// @brief Diagnostic manager isn't initialized at launch but after -/// CAN bus devices initialization. For the moment, it is only possible -/// to have 1 diagnostic bus which are the first bus declared in the JSON -/// description file. Configuration instance will return it. -/// -/// this will initialize DiagnosticShims and cancel all active requests -/// if there are any. -bool diagnostic_manager_t::initialize() -{ - // Mandatory to set the bus before intialize shims. - bus_ = configuration_t::instance().get_diagnostic_bus(); - - init_diagnostic_shims(); - reset(); - - initialized_ = true; - DEBUG(binder_interface, "initialize: Diagnostic Manager initialized"); - return initialized_; -} - -/// @brief initialize shims used by UDS lib and set initialized_ to true. -/// It is needed before used the diagnostic manager fully because shims are -/// required by most member functions. -void diagnostic_manager_t::init_diagnostic_shims() -{ - shims_ = diagnostic_init_shims(shims_logger, shims_send, NULL); - DEBUG(binder_interface, "init_diagnostic_shims: Shims initialized"); -} - -/// @brief Force cleanup all active requests. -void diagnostic_manager_t::reset() -{ - DEBUG(binder_interface, "Clearing existing diagnostic requests"); - cleanup_active_requests(true); -} - -/// @brief send function use by diagnostic library. Only one bus used for now -/// so diagnostic request is sent using the default diagnostic bus not matter of -/// which is specified in the diagnostic message definition. -/// -/// @param[in] arbitration_id - CAN arbitration ID to use when send message. OBD2 broadcast ID -/// is 0x7DF by example. -/// @param[in] data - The data payload for the message. NULL is valid if size is also 0. -/// @param[in] size - The size of the data payload, in bytes. -/// -/// @return true if the CAN message was sent successfully. -bool diagnostic_manager_t::shims_send(const uint32_t arbitration_id, const uint8_t* data, const uint8_t size) -{ - std::shared_ptr can_bus_dev = can_bus_t::get_can_device(configuration_t::instance().get_diagnostic_manager().bus_); - if(can_bus_dev != nullptr) - return can_bus_dev->shims_send(arbitration_id, data, size); - ERROR(binder_interface, "shims_send: Can not retrieve diagnostic bus: %s", configuration_t::instance().get_diagnostic_manager().bus_.c_str()); - return false; -} - -/// @brief The type signature for an optional logging function, if the user -/// wishes to provide one. It should print, store or otherwise display the -/// message. -/// -/// message - A format string to log using the given parameters. -/// ... (vargs) - the parameters for the format string. -/// -void diagnostic_manager_t::shims_logger(const char* format, ...) -{ - va_list args; - va_start(args, format); - - char buffer[256]; - vsnprintf(buffer, 256, format, args); - - DEBUG(binder_interface, "shims_logger: %s", buffer); -} - -/// @brief The type signature for a... OpenXC TODO: not used yet. -void diagnostic_manager_t::shims_timer() -{} - -std::shared_ptr diagnostic_manager_t::get_can_bus_dev() -{ - return can_bus_t::get_can_device(bus_); -} - -/// @brief Return diagnostic manager shims member. -DiagnosticShims& diagnostic_manager_t::get_shims() -{ - return shims_; -} - -/// @brief Search for a specific active diagnostic request in the provided requests list -/// and erase it from the vector. This is useful at unsubscription to clean up the list otherwize -/// all received CAN messages will be passed to DiagnosticRequestHandle of all active diagnostic request -/// contained in the vector but no event if connected to, so we will decode uneeded request. -/// -/// @param[in] entry - a pointer of an active_diagnostic_request instance to clean up -/// @param[in] requests_list - a vector where to make the search and cleaning. -void diagnostic_manager_t::find_and_erase(active_diagnostic_request_t* entry, std::vector& requests_list) -{ - auto i = std::find(requests_list.begin(), requests_list.end(), entry); - if ( i != requests_list.end()) - requests_list.erase(i); -} - -// @brief TODO: implement cancel_request if needed... Don't know. -void diagnostic_manager_t::cancel_request(active_diagnostic_request_t* entry) -{ - - /* TODO: implement acceptance filters. - if(entry.arbitration_id_ == OBD2_FUNCTIONAL_BROADCAST_ID) { - for(uint32_t filter = OBD2_FUNCTIONAL_RESPONSE_START; - filter < OBD2_FUNCTIONAL_RESPONSE_START + - OBD2_FUNCTIONAL_RESPONSE_COUNT; - filter++) { - removeAcceptanceFilter(entry.bus_, filter, - CanMessageFormat::STANDARD, getCanBuses(), - getCanBusCount()); - } - } else { - removeAcceptanceFilter(entry.bus_, - entry.arbitration_id_ + - DIAGNOSTIC_RESPONSE_ARBITRATION_ID_OFFSET, - CanMessageFormat::STANDARD, getCanBuses(), getCanBusCount()); - }*/ -} - -/// @brief Cleanup a specific request if it isn't running and get complete. As it is almost -/// impossible to get that state for a recurring request without waiting for that, you can -/// force the cleaning operation. -/// -/// @param[in] entry - the request to clean -/// @param[in] force - Force the cleaning or not ? -void diagnostic_manager_t::cleanup_request(active_diagnostic_request_t* entry, bool force) -{ - if((force || (entry != nullptr && entry->get_in_flight() && entry->request_completed()))) - { - entry->set_in_flight(false); - - char request_string[128] = {0}; - diagnostic_request_to_string(&entry->get_handle()->request, - request_string, sizeof(request_string)); - if(force && entry->get_recurring()) - { - find_and_erase(entry, recurring_requests_); - cancel_request(entry); - DEBUG(binder_interface, "cleanup_request: Cancelling completed, recurring request: %s", request_string); - } - else - { - DEBUG(binder_interface, "cleanup_request: Cancelling completed, non-recurring request: %s", request_string); - find_and_erase(entry, non_recurring_requests_); - cancel_request(entry); - } - } -} - -/// @brief Clean up all requests lists, recurring and not recurring. -/// -/// @param[in] force - Force the cleaning or not ? If true, that will do -/// the same effect as a call to reset(). -void diagnostic_manager_t::cleanup_active_requests(bool force) -{ - for(auto& entry : non_recurring_requests_) - if (entry != nullptr) - cleanup_request(entry, force); - - for(auto& entry : recurring_requests_) - if (entry != nullptr) - cleanup_request(entry, force); -} - -/// @brief Will return the active_diagnostic_request_t pointer for theDiagnosticRequest or nullptr if -/// not found. -/// -/// @param[in] request - Search key, method will go through recurring list to see if it find that request -/// holded by the DiagnosticHandle member. -active_diagnostic_request_t* diagnostic_manager_t::find_recurring_request(const DiagnosticRequest* request) -{ - for (auto& entry : recurring_requests_) - { - if(entry != nullptr) - { - if(diagnostic_request_equals(&entry->get_handle()->request, request)) - { - return entry; - break; - } - } - } - return nullptr; -} - -/// @brief Add and send a new one-time diagnostic request. -/// -/// A one-time (aka non-recurring) request can existing in parallel with a -/// recurring request for the same PID or mode, that's not a problem. -/// -/// For an example, see the docs for addRecurringRequest. This function is very -/// similar but leaves out the frequencyHz parameter. -/// -/// @param[in] request - The parameters for the request. -/// @param[in] name - Human readable name this response, to be used when -/// publishing received responses. TODO: If the name is NULL, the published output -/// will use the raw OBD-II response format. -/// @param[in] wait_for_multiple_responses - If false, When any response is received -/// for this request it will be removed from the active list. If true, the -/// request will remain active until the timeout clock expires, to allow it -/// to receive multiple response. Functional broadcast requests will always -/// waint for the timeout, regardless of this parameter. -/// @param[in] decoder - An optional DiagnosticResponseDecoder to parse the payload of -/// responses to this request. If the decoder is NULL, the output will -/// include the raw payload instead of a parsed value. -/// @param[in] callback - An optional DiagnosticResponseCallback to be notified whenever a -/// response is received for this request. -/// -/// @return true if the request was added successfully. Returns false if there -/// wasn't a free active request entry, if the frequency was too high or if the -/// CAN acceptance filters could not be configured, -bool diagnostic_manager_t::add_request(DiagnosticRequest* request, const std::string name, - bool wait_for_multiple_responses, const DiagnosticResponseDecoder decoder, - const DiagnosticResponseCallback callback) -{ - cleanup_active_requests(false); - - bool added = true; - - if (non_recurring_requests_.size() <= MAX_SIMULTANEOUS_DIAG_REQUESTS) - { - // TODO: implement Acceptance Filter - // if(updateRequiredAcceptanceFilters(bus, request)) { - active_diagnostic_request_t* entry = new active_diagnostic_request_t(bus_, request, name, - wait_for_multiple_responses, decoder, callback, 0); - entry->set_handle(shims_, request); - - char request_string[128] = {0}; - diagnostic_request_to_string(&entry->get_handle()->request, request_string, - sizeof(request_string)); - - find_and_erase(entry, non_recurring_requests_); - DEBUG(binder_interface, "Added one-time diagnostic request on bus %s: %s", - bus_.c_str(), request_string); - - non_recurring_requests_.push_back(entry); - } - else - { - WARNING(binder_interface, "There isn't enough request entry. Vector exhausted %d/%d", (int)non_recurring_requests_.size(), MAX_SIMULTANEOUS_DIAG_REQUESTS); - non_recurring_requests_.resize(MAX_SIMULTANEOUS_DIAG_REQUESTS); - added = false; - } - return added; -} - -bool diagnostic_manager_t::validate_optional_request_attributes(float frequencyHz) -{ - if(frequencyHz > MAX_RECURRING_DIAGNOSTIC_FREQUENCY_HZ) { - DEBUG(binder_interface, "Requested recurring diagnostic frequency %lf is higher than maximum of %d", - frequencyHz, MAX_RECURRING_DIAGNOSTIC_FREQUENCY_HZ); - return false; - } - return true; -} - -/// @brief Add and send a new recurring diagnostic request. -/// -/// At most one recurring request can be active for the same arbitration ID, mode -/// and (if set) PID on the same bus at one time. If you try and call -/// addRecurringRequest with the same key, it will return an error. -/// -/// TODO: This also adds any neccessary CAN acceptance filters so we can receive the -/// response. If the request is to the functional broadcast ID (0x7df) filters -/// are added for all functional addresses (0x7e8 to 0x7f0). -/// -/// Example: -/// -/// // Creating a functional broadcast, mode 1 request for PID 2. -/// DiagnosticRequest request = { -/// arbitration_id: 0x7df, -/// mode: 1, -/// has_pid: true, -/// pid: 2 -/// }; -/// -/// // Add a recurring request, to be sent at 1Hz, and published with the -/// // name "my_pid_request" -/// addRecurringRequest(&getConfiguration()->diagnosticsManager, -/// canBus, -/// &request, -/// "my_pid_request", -/// false, -/// NULL, -/// NULL, -/// 1); -/// -/// @param[in] request - The parameters for the request. -/// @param[in] name - An optional human readable name this response, to be used when -/// publishing received responses. If the name is NULL, the published output -/// will use the raw OBD-II response format. -/// @param[in] wait_for_multiple_responses - If false, When any response is received -/// for this request it will be removed from the active list. If true, the -/// request will remain active until the timeout clock expires, to allow it -/// to receive multiple response. Functional broadcast requests will always -/// waint for the timeout, regardless of this parameter. -/// @param[in] decoder - An optional DiagnosticResponseDecoder to parse the payload of -/// responses to this request. If the decoder is NULL, the output will -/// include the raw payload instead of a parsed value. -/// @param[in] callback - An optional DiagnosticResponseCallback to be notified whenever a -/// response is received for this request. -/// @param[in] frequencyHz - The frequency (in Hz) to send the request. A frequency above -/// MAX_RECURRING_DIAGNOSTIC_FREQUENCY_HZ is not allowed, and will make this -/// function return false. -/// -/// @return true if the request was added successfully. Returns false if there -/// was too much already running requests, if the frequency was too high TODO:or if the -/// CAN acceptance filters could not be configured, -/// -bool diagnostic_manager_t::add_recurring_request(DiagnosticRequest* request, const char* name, - bool wait_for_multiple_responses, const DiagnosticResponseDecoder decoder, - const DiagnosticResponseCallback callback, float frequencyHz) -{ - if(!validate_optional_request_attributes(frequencyHz)) - return false; - - cleanup_active_requests(false); - - bool added = true; - if(find_recurring_request(request) == nullptr) - { - if(recurring_requests_.size() <= MAX_SIMULTANEOUS_DIAG_REQUESTS) - { - sd_event_source *source; - // TODO: implement Acceptance Filter - //if(updateRequiredAcceptanceFilters(bus, request)) { - active_diagnostic_request_t* entry = new active_diagnostic_request_t(bus_, request, name, - wait_for_multiple_responses, decoder, callback, frequencyHz); - entry->set_handle(shims_, request); - - //start_diagnostic_request(&shims_, entry->get_handle()); - //char request_string[128] = {0}; - //diagnostic_request_to_string(&entry->get_handle()->request, request_string, - // sizeof(request_string)); - - uint64_t usec; - sd_event_now(afb_daemon_get_event_loop(binder_interface->daemon), CLOCK_BOOTTIME, &usec); - if(recurring_requests_.size() > 0) - { - DEBUG(binder_interface, "add_recurring_request: Added 100ms to usec to stagger sending requests"); - usec += 100000; - } - - DEBUG(binder_interface, "add_recurring_request: Added recurring diagnostic request (freq: %f) on bus %s at %ld. Event loop state: %d", - frequencyHz, - bus_.c_str(), - usec, - sd_event_get_state(afb_daemon_get_event_loop(binder_interface->daemon))); - - if(sd_event_add_time(afb_daemon_get_event_loop(binder_interface->daemon), &source, - CLOCK_BOOTTIME, usec, TIMERFD_ACCURACY, send_request, request) < 0) - { - ERROR(binder_interface, "add_recurring_request: Request fails to be schedule through event loop"); - added = false; - } - recurring_requests_.push_back(entry); - } - else - { - WARNING(binder_interface, "add_recurring_request: There isn't enough request entry. Vector exhausted %d/%d", (int)recurring_requests_.size(), MAX_SIMULTANEOUS_DIAG_REQUESTS); - recurring_requests_.resize(MAX_SIMULTANEOUS_DIAG_REQUESTS); - added = false; - } - } - else - { - DEBUG(binder_interface, "add_recurring_request: Can't add request, one already exists with same key"); - added = false; - } - return added; -} - -/// @brief Returns true if there are two active requests running for the same arbitration ID. -bool diagnostic_manager_t::conflicting(active_diagnostic_request_t* request, active_diagnostic_request_t* candidate) const -{ - return (candidate->get_in_flight() && candidate != request && - candidate->get_can_bus_dev() == request->get_can_bus_dev() && - candidate->get_id() == request->get_id()); -} - - -/// @brief Returns true if there are no other active requests to the same arbitration ID -/// and if there aren't more than 8 requests in flight at the same time. -bool diagnostic_manager_t::clear_to_send(active_diagnostic_request_t* request) const -{ - int total_in_flight = 0; - for ( auto entry : non_recurring_requests_) - { - if(conflicting(request, entry)) - return false; - if(entry->get_in_flight()) - total_in_flight++; - } - - for ( auto entry : recurring_requests_) - { - if(conflicting(request, entry)) - return false; - if(entry->get_in_flight()) - total_in_flight++; - } - - if(total_in_flight > MAX_SIMULTANEOUS_IN_FLIGHT_REQUESTS) - return false; - return true; -} - -int diagnostic_manager_t::reschedule_request(sd_event_source *s, uint64_t usec, active_diagnostic_request_t* adr) -{ - usec = usec + (uint64_t)(adr->get_frequency_clock().frequency_to_period()); - DEBUG(binder_interface, "send_request: Event loop state: %d. usec: %ld", sd_event_get_state(afb_daemon_get_event_loop(binder_interface->daemon)), usec); - if(sd_event_source_set_time(s, usec) >= 0) - if(sd_event_source_set_enabled(s, SD_EVENT_ON) >= 0) - return 0; - sd_event_source_unref(s); - return -1; -} - -/// @brief Systemd timer event callback use to send CAN messages at regular interval. Depending -/// on the diagnostic message frequency. -/// -/// This should be called from systemd binder event loop and the event is created on add_recurring_request -/// -/// @param[in] s - Systemd event source pointer used to reschedule the new iteration. -/// @param[in] usec - previous call timestamp in microseconds. -/// @param[in] userdata - the DiagnosticRequest struct, use to retrieve the active request from the list. -/// -/// @return positive integer if sent and rescheduled or negative value if something wrong. If an error occurs -/// event will be disabled. -int diagnostic_manager_t::send_request(sd_event_source *s, uint64_t usec, void *userdata) -{ - diagnostic_manager_t& dm = configuration_t::instance().get_diagnostic_manager(); - DiagnosticRequest* request = (DiagnosticRequest*)userdata; - active_diagnostic_request_t* adr = dm.find_recurring_request(request); - - dm.cleanup_active_requests(false); - if(adr != nullptr && adr->get_can_bus_dev() == dm.get_can_bus_dev() && adr->should_send() && - dm.clear_to_send(adr)) - { - adr->get_frequency_clock().tick(); - start_diagnostic_request(&dm.shims_, adr->get_handle()); - if(adr->get_handle()->completed && !adr->get_handle()->success) - { - ERROR(binder_interface, "send_request: Fatal error sending diagnostic request"); - sd_event_source_unref(s); - return -1; - } - - adr->get_timeout_clock().tick(); - adr->set_in_flight(true); - } - - if(adr != nullptr && adr->get_recurring()) - { - return dm.reschedule_request(s, usec, adr); - } - - sd_event_source_unref(s); - NOTICE(binder_interface, "send_request: Request doesn't exist anymore. Canceling.'"); - return -2; -} - -/// @brief Will decode the diagnostic response and build the final openxc_VehicleMessage to return. -/// -/// @param[in] adr - A pointer to an active diagnostic request holding a valid diagnostic handle -/// @param[in] response - The response to decode from which the Vehicle message will be built and returned -/// -/// @return A filled openxc_VehicleMessage or a zeroed struct if there is an error. -openxc_VehicleMessage diagnostic_manager_t::relay_diagnostic_response(active_diagnostic_request_t* adr, const DiagnosticResponse& response) -{ - openxc_VehicleMessage message = build_VehicleMessage(); - float value = (float)diagnostic_payload_to_integer(&response); - if(adr->get_decoder() != nullptr) - { - value = adr->get_decoder()(&response, value); - } - - if((response.success && strnlen(adr->get_name().c_str(), adr->get_name().size())) > 0) - { - // If name, include 'value' instead of payload, and leave of response - // details. - message = build_VehicleMessage(build_SimpleMessage(adr->get_name(), build_DynamicField(value))); - } - else - { - // If no name, send full details of response but still include 'value' - // instead of 'payload' if they provided a decoder. The one case you - // can't get is the full detailed response with 'value'. We could add - // another parameter for that but it's onerous to carry that around. - message = build_VehicleMessage(adr, response, value); - } - - // If not success but completed then the pid isn't supported - if(!response.success) - { - std::vector found_signals; - configuration_t::instance().find_diagnostic_messages( build_DynamicField(adr->get_name()), found_signals ); - found_signals.front()->set_supported(false); - cleanup_request(adr, true); - NOTICE(binder_interface, "relay_diagnostic_response: PID not supported or ill formed. Please unsubscribe from it. Error code : %d", response.negative_response_code); - message = build_VehicleMessage(build_SimpleMessage(adr->get_name(), build_DynamicField("This PID isn't supported by your vehicle."))); - } - - if(adr->get_callback() != nullptr) - { - adr->get_callback()(adr, &response, value); - } - - return message; -} - -/// @brief Will take the CAN message and pass it to the receive functions that will process -/// diagnostic handle for each active diagnostic request then depending on the result we will -/// return pass the diagnostic response to decode it. -/// -/// @param[in] entry - A pointer to an active diagnostic request holding a valid diagnostic handle -/// @param[in] cm - A raw CAN message. -/// -/// @return A pointer to a filled openxc_VehicleMessage or a nullptr if nothing has been found. -openxc_VehicleMessage diagnostic_manager_t::relay_diagnostic_handle(active_diagnostic_request_t* entry, const can_message_t& cm) -{ - DiagnosticResponse response = diagnostic_receive_can_frame(&shims_, entry->get_handle(), cm.get_id(), cm.get_data(), cm.get_length()); - if(response.completed && entry->get_handle()->completed) - { - if(entry->get_handle()->success) - return relay_diagnostic_response(entry, response); - } - else if(!response.completed && response.multi_frame) - { - // Reset the timeout clock while completing the multi-frame receive - entry->get_timeout_clock().tick(); - } - - return build_VehicleMessage(); -} - -/// @brief Find the active diagnostic request with the correct DiagnosticRequestHandle -/// member that will understand the CAN message using diagnostic_receive_can_frame function -/// from UDS-C library. Then decode it with an ad-hoc method. -/// -/// @param[in] cm - Raw CAN message received -/// -/// @return VehicleMessage with decoded value. -openxc_VehicleMessage diagnostic_manager_t::find_and_decode_adr(const can_message_t& cm) -{ - openxc_VehicleMessage vehicle_message = build_VehicleMessage(); - - for ( auto entry : non_recurring_requests_) - { - vehicle_message = relay_diagnostic_handle(entry, cm); - if (is_valid(vehicle_message)) - return vehicle_message; - } - - for ( auto entry : recurring_requests_) - { - vehicle_message = relay_diagnostic_handle(entry, cm); - if (is_valid(vehicle_message)) - return vehicle_message; - } - - return vehicle_message; -} - -/// @brief Tell if the CAN message received is a diagnostic response. -/// Request broadcast ID use 0x7DF and assigned ID goes from 0x7E0 to Ox7E7. That allows up to 8 ECU to respond -/// at the same time. The response is the assigned ID + 0x8, so response ID can goes from 0x7E8 to 0x7EF. -/// -/// @param[in] cm - CAN message received from the socket. -/// -/// @return True if the active diagnostic request match the response. -bool diagnostic_manager_t::is_diagnostic_response(const can_message_t& cm) -{ - if (cm.get_id() >= 0x7e8 && cm.get_id() <= 0x7ef) - return true; - return false; -} diff --git a/src/diagnostic/diagnostic-manager.hpp b/src/diagnostic/diagnostic-manager.hpp deleted file mode 100644 index 3edb2b12..00000000 --- a/src/diagnostic/diagnostic-manager.hpp +++ /dev/null @@ -1,99 +0,0 @@ -/* - * Copyright (C) 2015, 2016 "IoT.bzh" - * Author "Romain Forlot" - * - * 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. - */ - -#pragma once - -#include -#include -#include - -#include "uds/uds.h" -#include "openxc.pb.h" -#include "../can/can-bus.hpp" -#include "active-diagnostic-request.hpp" - -/// Each CAN bus needs its own set of shim functions, so this should -/// match the maximum CAN controller count. -/// -#define MAX_SHIM_COUNT can_bus_t.get_can_devices().size() -#define DIAGNOSTIC_RESPONSE_ARBITRATION_ID_OFFSET 0x8 - -class active_diagnostic_request_t; - -/// -/// @brief The core structure for running the diagnostics module by the binding. -/// -/// This stores details about the active requests and shims required to connect -/// the diagnostics library to the CAN device. -/// -class diagnostic_manager_t { -protected: - static bool shims_send(const uint32_t arbitration_id, const uint8_t* data, const uint8_t size); - static void shims_logger(const char* m, ...); - static void shims_timer(); - -private: - DiagnosticShims shims_; /*!< shims_ - Shim functions for each CAN bus that plug the diagnostics - * library (uds-c) into the VI's CAN peripheral.*/ - std::string bus_; /*!< bus_ - A pointer to the CAN bus that should be used for all standard OBD-II requests, if the bus is not - * explicitly spcified in the request. Default to the first bus CAN at initialization.*/ - std::vector recurring_requests_; /*!< recurringRequests - A list of active recurring diagnostic requests.*/ - std::vector non_recurring_requests_; /*!< nonrecurringRequests - A list of active one-time diagnostic requests. When a - * response is received for a non-recurring request or it times out, it is removed*/ - bool initialized_; /*!< * initialized - True if the DiagnosticsManager has been initialized with shims. It will interface with the uds-c lib*/ - - void init_diagnostic_shims(); - void reset(); -public: - diagnostic_manager_t(); - - bool initialize(); - - std::shared_ptr get_can_bus_dev(); - DiagnosticShims& get_shims(); - - void find_and_erase(active_diagnostic_request_t* entry, std::vector& requests_list); - void cancel_request(active_diagnostic_request_t* entry); - void cleanup_request(active_diagnostic_request_t* entry, bool force); - void cleanup_active_requests(bool force); - active_diagnostic_request_t* find_recurring_request(const DiagnosticRequest* request); - - void checkSupportedPids(const active_diagnostic_request_t& request, - const DiagnosticResponse& response, float parsedPayload); - - // Subscription parts - bool add_request(DiagnosticRequest* request, const std::string name, - bool waitForMultipleResponses, const DiagnosticResponseDecoder decoder, - const DiagnosticResponseCallback callback); - bool validate_optional_request_attributes(float frequencyHz); - bool add_recurring_request(DiagnosticRequest* request, const char* name, - bool waitForMultipleResponses, const DiagnosticResponseDecoder decoder, - const DiagnosticResponseCallback callback, float frequencyHz); - - // Sendig requests part - bool conflicting(active_diagnostic_request_t* request, active_diagnostic_request_t* candidate) const; - bool clear_to_send(active_diagnostic_request_t* request) const; - int reschedule_request(sd_event_source *s, uint64_t usec, active_diagnostic_request_t* adr); - static int send_request(sd_event_source *s, uint64_t usec, void *userdata); - - // Decoding part - openxc_VehicleMessage relay_diagnostic_response(active_diagnostic_request_t* adr, const DiagnosticResponse& response); - openxc_VehicleMessage relay_diagnostic_handle(active_diagnostic_request_t* entry, const can_message_t& cm); - openxc_VehicleMessage find_and_decode_adr(const can_message_t& cm); - bool is_diagnostic_response(const can_message_t& cm); - -}; diff --git a/src/diagnostic/diagnostic-message.cpp b/src/diagnostic/diagnostic-message.cpp deleted file mode 100644 index 6f615574..00000000 --- a/src/diagnostic/diagnostic-message.cpp +++ /dev/null @@ -1,108 +0,0 @@ -/* - * Copyright (C) 2015, 2016 "IoT.bzh" - * Author "Romain Forlot" - * - * 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. - */ -#include - -#include "diagnostic-message.hpp" - -#include "../configuration.hpp" -#include "../utils/signals.hpp" - -const char *UNIT_NAMES[10] = { - "POURCENT", - "DEGREES_CELSIUS", - "KPA", - "RPM", - "GRAMS_SEC", - "SECONDS", - "KM", - "KM_H", - "PA", - "NM" -}; - -diagnostic_message_t::diagnostic_message_t(uint8_t pid, const std::string generic_name, const int min, - const int max, enum UNIT unit, float frequency, DiagnosticResponseDecoder decoder, - DiagnosticResponseCallback callback, bool supported) - : pid_{pid}, generic_name_{generic_name}, min_{min}, max_{max}, unit_{unit}, - frequency_{frequency}, decoder_{decoder}, callback_{callback}, supported_{supported} -{} - -uint32_t diagnostic_message_t::get_pid() -{ - return (uint32_t)pid_; -} - -const std::string& diagnostic_message_t::get_generic_name() const -{ - return generic_name_; -} - -const std::string diagnostic_message_t::get_name() const -{ - return active_diagnostic_request_t::get_prefix() + "." + generic_name_; -} - -float diagnostic_message_t::get_frequency() const -{ - return frequency_; -} - -DiagnosticResponseDecoder diagnostic_message_t::get_decoder() const -{ - return decoder_; -} -DiagnosticResponseCallback diagnostic_message_t::get_callback() const -{ - return callback_; -} - -bool diagnostic_message_t::get_supported() const -{ - return supported_; -} - -void diagnostic_message_t::set_supported(bool value) -{ - supported_ = value; -} - -/// -/// @brief Build a DiagnosticRequest struct to be passed -/// to diagnostic manager instance. -/// -const DiagnosticRequest diagnostic_message_t::build_diagnostic_request() -{ - return {/*arbitration_id: */OBD2_FUNCTIONAL_BROADCAST_ID, - /*mode: */0x1, - /*has_pid: */true, - /*pid: */pid_, - /*pid_length: */0, - /*payload[]: */{0}, - /*payload_length: */0, - /*no_frame_padding: */false, - /*DiagnosticRequestType: */DiagnosticRequestType::DIAGNOSTIC_REQUEST_TYPE_PID }; -} - -/// -/// @brief Check if a request is an OBD-II PID request. -/// -/// @return true if the request is a mode 1 request and it has a 1 byte PID. -/// -bool diagnostic_message_t::is_obd2_request(const DiagnosticRequest* request) -{ - return request->mode == 0x1 && request->has_pid && request->pid < 0xff; -} diff --git a/src/diagnostic/diagnostic-message.hpp b/src/diagnostic/diagnostic-message.hpp deleted file mode 100644 index 064904d2..00000000 --- a/src/diagnostic/diagnostic-message.hpp +++ /dev/null @@ -1,79 +0,0 @@ -/* - * Copyright (C) 2015, 2016 "IoT.bzh" - * Author "Romain Forlot" - * - * 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. - */ - -#pragma once - -#include -#include - -#include "uds/uds.h" -#include "../can/can-message.hpp" -#include "active-diagnostic-request.hpp" - -enum UNIT { - POURCENT, - DEGREES_CELSIUS, - KPA, - RPM, - GRAMS_SEC, - SECONDS, - KM, - KM_H, - PA, - NM, - INVALID -}; - -/// -/// @brief - A representation of an OBD-II PID. -/// -class diagnostic_message_t { - private: - uint8_t pid_; /*!< pid_ - The 1 byte PID.*/ - std::string generic_name_; /*!< generic_name_ - A human readable name to use for this PID when published.*/ - int min_; /*!< min_ - Minimum value that can take this pid */ - int max_; /*!< max_ - Maximum value that can take this pid */ - enum UNIT unit_; /*!< unit_ : Which unit system is used by that pid. See enum UNIT above.*/ - float frequency_; /*!< frequency_ - The frequency to request this PID if supported by the vehicle when automatic, recurring OBD-II requests are enabled.*/ - DiagnosticResponseDecoder decoder_; /*!< decoder_ - An optional DiagnosticResponseDecoder to parse the payload of responses - * to this request. If the decoder is NULL, the output will include the raw payload - * instead of a parsed value.*/ - DiagnosticResponseCallback callback_; /*!< callback_ - An optional DiagnosticResponseCallback to be notified whenever a - * response is received for this request.*/ - - bool supported_; /*!< supported_ - boolean indicating whether this pid is supported by the vehicle or not.*/ - - public: - const char* generic_name = generic_name_.c_str(); - diagnostic_message_t(uint8_t pid, const std::string generic_name, const int min, const int max, enum UNIT unit, float frequency, - DiagnosticResponseDecoder decoder, DiagnosticResponseCallback callback, bool supported); - - uint32_t get_pid(); - const std::string& get_generic_name() const; - const std::string get_name() const; - float get_frequency() const; - DiagnosticResponseDecoder get_decoder() const; - DiagnosticResponseCallback get_callback() const; - bool get_supported() const; - - void set_supported(bool value); - - const DiagnosticRequest build_diagnostic_request(); - - bool is_obd2_response(const can_message_t& can_message); - bool is_obd2_request(const DiagnosticRequest *request); -}; diff --git a/src/export.map b/src/export.map deleted file mode 100644 index 52c1b4aa..00000000 --- a/src/export.map +++ /dev/null @@ -1 +0,0 @@ -{ global: afbBindingV1*; local: *; }; diff --git a/src/icon.png b/src/icon.png deleted file mode 100644 index 9bd6a6e4..00000000 Binary files a/src/icon.png and /dev/null differ diff --git a/src/libs/bitfield-c b/src/libs/bitfield-c deleted file mode 160000 index a34745ec..00000000 --- a/src/libs/bitfield-c +++ /dev/null @@ -1 +0,0 @@ -Subproject commit a34745ec93ae0a1d4f1b640dba8fb6702331a8e9 diff --git a/src/libs/isotp-c b/src/libs/isotp-c deleted file mode 160000 index ee24440b..00000000 --- a/src/libs/isotp-c +++ /dev/null @@ -1 +0,0 @@ -Subproject commit ee24440b7c123ab1b0317e57be33e837a1cb51f1 diff --git a/src/libs/nanopb b/src/libs/nanopb deleted file mode 160000 index ffe4aff8..00000000 --- a/src/libs/nanopb +++ /dev/null @@ -1 +0,0 @@ -Subproject commit ffe4aff87cc3a15863c09aa808adf2381c8f2fb7 diff --git a/src/libs/openxc-message-format b/src/libs/openxc-message-format deleted file mode 160000 index d9f54f97..00000000 --- a/src/libs/openxc-message-format +++ /dev/null @@ -1 +0,0 @@ -Subproject commit d9f54f97578429773421abce98d5f6579717afcc diff --git a/src/libs/uds-c b/src/libs/uds-c deleted file mode 160000 index e506334e..00000000 --- a/src/libs/uds-c +++ /dev/null @@ -1 +0,0 @@ -Subproject commit e506334e270d77b20c0bc259ac6c7d8c9b702b7a diff --git a/src/low-can-binding.cpp b/src/low-can-binding.cpp deleted file mode 100644 index 07b3f1ea..00000000 --- a/src/low-can-binding.cpp +++ /dev/null @@ -1,279 +0,0 @@ -/* - * Copyright (C) 2015, 2016 "IoT.bzh" - * Author "Romain Forlot" - * Author "Loic Collignon" - * - * 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. - */ - -#include "low-can-binding.hpp" - -#include -#include -#include -#include -#include -#include -#include -#include - -#include "openxc.pb.h" -#include "configuration.hpp" -#include "can/can-bus.hpp" -#include "can/can-signals.hpp" -#include "can/can-message.hpp" -#include "utils/timer.hpp" -#include "utils/signals.hpp" -#include "diagnostic/diagnostic-message.hpp" -#include "utils/openxc-utils.hpp" - -extern "C" -{ - #include -}; - -// Interface between the daemon and the binding -const struct afb_binding_interface *binder_interface; - -void on_no_clients(std::string message) -{ - DiagnosticRequest* diag_req = configuration_t::instance().get_request_from_diagnostic_message(message); - if(diag_req != nullptr) - { - active_diagnostic_request_t* adr = configuration_t::instance().get_diagnostic_manager().find_recurring_request(diag_req); - if( adr != nullptr) - configuration_t::instance().get_diagnostic_manager().cleanup_request(adr, true); - } -} - -///****************************************************************************** -/// -/// Subscription and unsubscription -/// -///*******************************************************************************/ - -static int make_subscription_unsubscription(struct afb_req request, const std::string& sig_name, std::map& s, bool subscribe) -{ - /* Make the subscription or unsubscription to the event */ - if (((subscribe ? afb_req_subscribe : afb_req_unsubscribe)(request, s[sig_name])) < 0) - { - ERROR(binder_interface, "make_subscription_unsubscription: Operation goes wrong for signal: %s", sig_name.c_str()); - return 0; - } - return 1; -} - -static int create_event_handle(const std::string& sig_name, std::map& s) -{ - s[sig_name] = afb_daemon_make_event(binder_interface->daemon, sig_name.c_str()); - if (!afb_event_is_valid(s[sig_name])) - { - ERROR(binder_interface, "create_event_handle: Can't create an event for %s, something goes wrong.", sig_name.c_str()); - return 0; - } - return 1; -} - -static int subscribe_unsubscribe_signal(struct afb_req request, bool subscribe, const std::string& sig) -{ - int ret; - - std::lock_guard subscribed_signals_lock(get_subscribed_signals_mutex()); - std::map& s = get_subscribed_signals(); - if (s.find(sig) != s.end()) - { - if (!afb_event_is_valid(s[sig]) && !subscribe) - { - NOTICE(binder_interface, "subscribe_unsubscribe_signal: Event isn't valid, it can't be unsubscribed."); - ret = -1; - } - /*else - { - // Event it isn't valid annymore, recreate it - ret = create_event_handle(sig, s); - }*/ - } - else - { - /* Event doesn't exist , so let's create it */ - struct afb_event empty_event = {nullptr, nullptr}; - subscribed_signals[sig] = empty_event; - ret = create_event_handle(sig, s); - } - - /* Check whether or not the event handler has been correctly created and - * make the subscription/unsubscription operation is so. - */ - if (ret <= 0) - return ret; - return make_subscription_unsubscription(request, sig, s, subscribe); -} - -/// -/// @fn static int subscribe_unsubscribe_signals(struct afb_req request, bool subscribe, const std::vector& signals) -/// @brief subscribe to all signals in the vector signals -/// -/// @param[in] afb_req request : contain original request use to subscribe or unsubscribe -/// @param[in] subscribe boolean value used to chose between a subscription operation or an unsubscription -/// @param[in] can_signal_t vector with can_signal_t to subscribe -/// -/// @return Number of correctly subscribed signal -/// -static int subscribe_unsubscribe_signals(struct afb_req request, bool subscribe, const std::vector& signals) -{ - int rets = 0; - - //TODO: Implement way to dynamically call the right function no matter - // how much signals types we have. - - for(const std::string& sig : signals) - { - int ret; - if (active_diagnostic_request_t::is_diagnostic_signal(sig)) - { - diagnostic_message_t* diag_msg = configuration_t::instance().get_diagnostic_message(sig); - DiagnosticRequest* diag_req = configuration_t::instance().get_request_from_diagnostic_message(diag_msg); - - // If the requested diagnostic message isn't supported by the car then unssubcribe. - // no matter what we want, worse case will be a fail unsubscription but at least we don't - // poll a PID for nothing. - if(diag_msg->get_supported() && subscribe) - { - float frequency = diag_msg->get_frequency(); - subscribe = configuration_t::instance().get_diagnostic_manager().add_recurring_request( - diag_req, sig.c_str(), false, diag_msg->get_decoder(), diag_msg->get_callback(), (float)frequency); - //TODO: Adding callback requesting ignition status: diag_req, sig.c_str(), false, diagnostic_message_t::decode_obd2_response, diagnostic_message_t::check_ignition_status, frequency); - } - else - { - configuration_t::instance().get_diagnostic_manager().cleanup_request( - configuration_t::instance().get_diagnostic_manager().find_recurring_request(diag_req), true); - WARNING(binder_interface, "Signal: %s isn't supported. Canceling operation.", sig.c_str()); - return -1; - } - } - - ret = subscribe_unsubscribe_signal(request, subscribe, sig); - if(ret <= 0) - return ret; - rets++; - - DEBUG(binder_interface, "Signal: %s subscribed", sig.c_str()); - } - return rets; -} - -static int subscribe_unsubscribe_name(struct afb_req request, bool subscribe, const char *name) -{ - std::vector signals; - int ret = 0; - - openxc_DynamicField search_key = build_DynamicField(std::string(name)); - signals = find_signals(search_key); - if (signals.empty()) - ret = 0; - - ret = subscribe_unsubscribe_signals(request, subscribe, signals); - NOTICE(binder_interface, "Subscribed/unsubscribe correctly to %d/%d signal(s).", ret, (int)signals.size()); - - return ret; -} - -static void subscribe_unsubscribe(struct afb_req request, bool subscribe) -{ - int ok, i, n; - struct json_object *args, *a, *x; - - /* makes the subscription/unsubscription */ - args = afb_req_json(request); - if (args == NULL || !json_object_object_get_ex(args, "event", &a)) { - ok = subscribe_unsubscribe_name(request, subscribe, "*"); - } else if (json_object_get_type(a) != json_type_array) { - ok = subscribe_unsubscribe_name(request, subscribe, json_object_get_string(a)); - } else { - n = json_object_array_length(a); - ok = 0; - for (i = 0 ; i < n ; i++) { - x = json_object_array_get_idx(a, i); - if (subscribe_unsubscribe_name(request, subscribe, json_object_get_string(x))) - ok++; - } - ok = (ok == n); - } - - /* send the report */ - if (ok) - afb_req_success(request, NULL, NULL); - else - afb_req_fail(request, "error", NULL); -} - -extern "C" -{ - static void subscribe(struct afb_req request) - { - subscribe_unsubscribe(request, true); - } - - static void unsubscribe(struct afb_req request) - { - subscribe_unsubscribe(request, false); - } - - static const struct afb_verb_desc_v1 verbs[]= - { - { .name= "subscribe", .session= AFB_SESSION_NONE, .callback= subscribe, .info= "subscribe to notification of CAN bus messages." }, - { .name= "unsubscribe", .session= AFB_SESSION_NONE, .callback= unsubscribe, .info= "unsubscribe a previous subscription." } - }; - - static const struct afb_binding binding_desc { - AFB_BINDING_VERSION_1, - { - "Low level CAN bus service", - "low-can", - verbs - } - }; - - const struct afb_binding *afbBindingV1Register (const struct afb_binding_interface *itf) - { - binder_interface = itf; - - return &binding_desc; - } - - /// @brief Initialize the binding. - /// - /// @param[in] service Structure which represent the Application Framework Binder. - /// - /// @return Exit code, zero if success. - int afbBindingV1ServiceInit(struct afb_service service) - { - can_bus_t& can_bus_manager = configuration_t::instance().get_can_bus_manager(); - - /// Initialize CAN socket - if(can_bus_manager.init_can_dev() == 0) - { - can_bus_manager.start_threads(); - - /// Initialize Diagnostic manager that will handle obd2 requests. - /// We pass by default the first CAN bus device to its Initialization. - /// TODO: be able to choose the CAN bus device that will be use as Diagnostic bus. - if(configuration_t::instance().get_diagnostic_manager().initialize()) - return 0; - } - - ERROR(binder_interface, "There was something wrong with CAN device Initialization. Check your config file maybe"); - return 1; - } -}; diff --git a/src/low-can-binding.hpp b/src/low-can-binding.hpp deleted file mode 100644 index ed5741d8..00000000 --- a/src/low-can-binding.hpp +++ /dev/null @@ -1,33 +0,0 @@ -/* - * Copyright (C) 2015, 2016 "IoT.bzh" - * Author "Romain Forlot" - * Author "Loic Collignon" - * - * 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. - */ - -#pragma once - -#include -#include - -extern "C" -{ - #include -}; - -extern "C" struct afb_binding_interface; - -extern const struct afb_binding_interface *binder_interface; - -void on_no_clients(std::string message); \ No newline at end of file diff --git a/src/utils/config-parser.cpp b/src/utils/config-parser.cpp deleted file mode 100644 index e73b0f94..00000000 --- a/src/utils/config-parser.cpp +++ /dev/null @@ -1,84 +0,0 @@ -/* - * Copyright (C) 2015, 2016 ,2017 "IoT.bzh" - * Author "Romain Forlot" - * - * 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. - */ - -namespace utils -{ - config_parser_t::config_parser_t(int conf_file) - : conf_file_{conf_file}, devices_name{} - {} - - /// @brief read the conf_file_ and will parse json objects - /// in it searching for canbus objects devices name. - /// - /// @return Vector of can bus device name string. - void can_bus_t::read_conf() - { - FILE *fd = fdopen(conf_file_, "r"); - if (fd) - { - std::fseek(fd, 0, SEEK_END); - config_content_.resize(std::ftell(fd)); - std::rewind(fd); - std::fread(&config_content_[0], 1, config_content_.size(), fd); - std::fclose(fd); - - DEBUG(binder_interface, "Configuration file content : %s", config_content_.c_str()); - } - ERROR(binder_interface, "Problem at reading the conf file"); - } - - void parse_devices_name() - { - json_object *jo, *canbus; - const char* taxi; - - jo = json_tokener_parse(config_content_.c_str()); - - if (jo == NULL || !json_object_object_get_ex(jo, "canbus", &canbus)) - { - ERROR(binder_interface, "Can't find canbus node in the configuration file. Please review it."); - devices_name_.clear(); - } - else if (json_object_get_type(canbus) != json_type_array) - { - taxi = json_object_get_string(canbus); - DEBUG(binder_interface, "Can bus found: %s", taxi); - devices_name_.push_back(std::string(taxi)); - } - else - { - int n, i; - n = json_object_array_length(canbus); - for (i = 0 ; i < n ; i++) - devices_name_.push_back(json_object_get_string(json_object_array_get_idx(canbus, i))); - } - } - - /// @brief Public method to access devices_name_ vector. If vector size equal 0 - /// then it will parses the configuration file content to fill it. It could be empty even - /// after parsing if content file just don't have a correct "canbus" directive so you - /// have to test the returned value. - /// - /// @return A const vector with string of linux CAN devices. - const std::vector& get_devices_name() - { - if(devices_name_.empty()) - parse_devices_name(); - - return devices_name_; - } -} \ No newline at end of file diff --git a/src/utils/config-parser.hpp b/src/utils/config-parser.hpp deleted file mode 100644 index e6bd9d22..00000000 --- a/src/utils/config-parser.hpp +++ /dev/null @@ -1,43 +0,0 @@ -/* - * Copyright (C) 2015, 2016 ,2017 "IoT.bzh" - * Author "Romain Forlot" - * - * 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. - */ - -#pragma once - -#include -#include -#include -#include - -#include - -namespace utils -{ - class config_parser_t - { - private: - int conf_file_; /*!< conf_file_ - file that handle the binding configuration file */ - std::string config_content_; /*!< config_content_ - String that contains the content of config file */ - std::vector devices_name_; /*!< devices_name - Found devices name after reading configuration file */ - - void parse_devices_name(); - public: - config_parser_t(int conf_file); - - void read_conf(); - std::vector get_devices_name(); - }; -} diff --git a/src/utils/openxc-utils.cpp b/src/utils/openxc-utils.cpp deleted file mode 100644 index 52b49d29..00000000 --- a/src/utils/openxc-utils.cpp +++ /dev/null @@ -1,282 +0,0 @@ -/* - * Copyright (C) 2015, 2016 "IoT.bzh" - * Author "Romain Forlot" - * Author "Loic Collignon" - * - * 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. - */ - -#include "openxc-utils.hpp" - -#include "../configuration.hpp" - -/// -/// @brief Build a specific VehicleMessage containing a DiagnosticResponse. -/// -/// @param[in] request - Original request use to retrieve decoder and callback -/// @param[in] response - Response to the request that will be decoded if decoder set -/// and put into the DiagnosticResponse of the VehicleMessage. -/// @param[in] parsed_value - raw parsed value of the payload from CAN message -/// -/// @return a vehicle message including simple message that will be convert into -/// a JSON object before being pushed to the subscribers -/// -openxc_VehicleMessage build_VehicleMessage(active_diagnostic_request_t* request, const DiagnosticResponse& response, float parsed_value) -{ - openxc_VehicleMessage message; - - message.has_type = true; - message.type = openxc_VehicleMessage_Type::openxc_VehicleMessage_Type_DIAGNOSTIC; - message.has_diagnostic_response = true; - message.diagnostic_response.has_bus = true; - message.diagnostic_response.bus = configuration_t::instance().get_diagnostic_manager().get_can_bus_dev()->get_address(); - message.diagnostic_response.has_message_id = true; - - if(request->get_id() != OBD2_FUNCTIONAL_BROADCAST_ID) - { - message.diagnostic_response.message_id = response.arbitration_id - - DIAGNOSTIC_RESPONSE_ARBITRATION_ID_OFFSET; - } - else - { - // must preserve responding arb ID for responses to functional broadcast - // requests, as they are the actual module address and not just arb ID + - // 8. - message.diagnostic_response.message_id = response.arbitration_id; - } - - message.diagnostic_response.has_mode = true; - message.diagnostic_response.mode = response.mode; - message.diagnostic_response.has_pid = response.has_pid; - if(message.diagnostic_response.has_pid) - message.diagnostic_response.pid = response.pid; - message.diagnostic_response.has_success = true; - message.diagnostic_response.success = response.success; - message.diagnostic_response.has_negative_response_code = !response.success; - message.diagnostic_response.negative_response_code = - response.negative_response_code; - - if(response.payload_length > 0) - { - if(request->get_decoder() != nullptr) - { - message.diagnostic_response.has_value = true; - message.diagnostic_response.value = parsed_value; - } - else - { - message.diagnostic_response.has_payload = true; - ::memcpy(message.diagnostic_response.payload.bytes, response.payload, - response.payload_length); - message.diagnostic_response.payload.size = response.payload_length; - } - } - - return message; -} - -/// -/// @brief Build a specific VehicleMessage containing a SimpleMessage. -/// -/// @param[in] message - simple message to include into openxc_VehicleMessage -/// -/// @return a vehicle message including simple message that will be convert into -/// a JSON object before being pushed to the subscribers -/// -openxc_VehicleMessage build_VehicleMessage(const openxc_SimpleMessage& message) -{ - openxc_VehicleMessage v; - - v.has_type = true, - v.type = openxc_VehicleMessage_Type::openxc_VehicleMessage_Type_SIMPLE; - v.has_simple_message = true; - v.simple_message = message; - v.has_timestamp = true; - v.timestamp = system_time_ms(); - - return v; -} - -/// -/// @brief Build an empty VehicleMessage that isn't usable by at least the struct -/// is initialized for the most part and can be use to check a false return value. -/// -/// @return A VehicleMessage with all boolean value to false. -/// -openxc_VehicleMessage build_VehicleMessage() -{ - openxc_VehicleMessage v; - - ::memset(&v, 0, sizeof(openxc_VehicleMessage)); - return v; -} - -bool is_valid(const openxc_VehicleMessage& v) -{ - if (v.has_type == false && - v.has_can_message == false && - v.has_simple_message == false && - v.has_diagnostic_response == false && - v.has_control_command == false && - v.has_command_response == false && - v.has_timestamp == false) - return false; - return true; -} - -/// -/// @brief Build an openxc_SimpleMessage associating a name to an openxc_DynamicField -/// -/// @param[in] name - const string reference name to assign to the created SimpleMessage -/// this will set has_name member to true and assign name to the name member. Maximum size for name is -/// set to 100 char. -/// @param[in] value - const reference with DynamicField to assign to SimpleMessage -/// value. -/// -/// @return an openxc_SimpleMessage struct initialized with name and value provided. -/// -openxc_SimpleMessage build_SimpleMessage(const std::string& name, const openxc_DynamicField& value) -{ - openxc_SimpleMessage s; - - s.has_name = true; - ::strncpy(s.name, name.c_str(), 100); - s.has_value = true; - s.value = value; - - return s; -} - -/// -/// @brief Build an openxc_DynamicField with a string value -/// -/// @param[in] value - const string reference value to assign to builded -/// openxc_DynamicField. -/// -/// @return openxc_DynamicField initialized with a string value. -/// -openxc_DynamicField build_DynamicField(const std::string& value) -{ - openxc_DynamicField d; - d.has_type = true; - d.type = openxc_DynamicField_Type_STRING; - - d.has_string_value = true; - d.has_numeric_value = false; - d.has_boolean_value = false; - ::strncpy(d.string_value, value.c_str(), 100); - - return d; -} - -/// -/// @fn openxc_DynamicField build_DynamicField(double value); -/// -/// @brief Build an openxc_DynamicField with a double value -/// -/// @param[in] value - double value to assign to builded openxc_DynamicField. -/// -/// @return openxc_DynamicField initialized with a double value. -/// -openxc_DynamicField build_DynamicField(double value) -{ - openxc_DynamicField d; - d.has_type = true; - d.type = openxc_DynamicField_Type_NUM; - - d.has_string_value = false; - d.has_numeric_value = true; - d.has_boolean_value = false; - d.numeric_value = value; - - return d; -} - -/// -/// @brief Build an openxc_DynamicField with a boolean value -/// -/// @param[in] value - boolean value to assign to builded openxc_DynamicField. -/// -/// @return openxc_DynamicField initialized with a boolean value. -/// -openxc_DynamicField build_DynamicField(bool value) -{ - openxc_DynamicField d; - d.has_type = true; - d.type = openxc_DynamicField_Type_BOOL; - - d.has_string_value = false; - d.has_numeric_value = false; - d.has_boolean_value = true; - d.boolean_value = value; - - return d; -} - -/// -/// @brief Extract the simple message value from an openxc_VehicleMessage -/// and return it. If there isn't SimpleMessage in the VehicleMessage then -/// returned value will be a SimpleMessage with all field set at false. -/// DynamicField from SimpleMessage will be boolean DynamicField set to false too. -/// -/// @param[in] v_msg - const reference to openxc_VehicleMessage -/// -/// @return A simpleMessage from the provided VehicleMessage. -/// -openxc_SimpleMessage get_simple_message(const openxc_VehicleMessage& v_msg) -{ - if (v_msg.has_simple_message) - return v_msg.simple_message; - - openxc_SimpleMessage s_msg = { false, "", false, build_DynamicField(false), false, build_DynamicField(false)}; - return s_msg; -} - -/// -/// @brief Make a JSON object from a DynamicField -/// -/// @param[in] field - openxc_DynamicField struct to convert into -/// a json object. -/// @param[out] value - pointer to the object to set up. -/// -void jsonify_DynamicField(const openxc_DynamicField& field, json_object* value) -{ - if(field.has_numeric_value) - json_object_object_add(value, "value", json_object_new_double(field.numeric_value)); - else if(field.has_boolean_value) - json_object_object_add(value, "value", json_object_new_boolean(field.boolean_value)); - else if(field.has_string_value) - json_object_object_add(value, "value", json_object_new_string(field.string_value)); -} - -/// -/// @brief Make a JSON object from a SimpleMessage -/// -/// @param[in] s_msg - const reference to an openxc_SimpleMessage -/// struct to convert into a json object. -/// @param[out] json - pointer with the DynamicField converted into json object -/// -/// @return True if SimpleMessage has been transformed into json object -/// and false if not. In such case, a json object is returned { "error": "error msg"} -/// -bool jsonify_simple(const openxc_SimpleMessage& s_msg, json_object* json) -{ - if(s_msg.has_name) - { - json_object_object_add(json, "name", json_object_new_string(s_msg.name)); - jsonify_DynamicField(s_msg.value, json); - return true; - } - json_object_object_add(json, "error", json_object_new_string("openxc_SimpleMessage doesn't have name'")); - return false; -} \ No newline at end of file diff --git a/src/utils/openxc-utils.hpp b/src/utils/openxc-utils.hpp deleted file mode 100644 index d36b359b..00000000 --- a/src/utils/openxc-utils.hpp +++ /dev/null @@ -1,42 +0,0 @@ -/* - * Copyright (C) 2015, 2016 "IoT.bzh" - * Author "Romain Forlot" - * Author "Loic Collignon" - * - * 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. - */ - -#pragma once - -#include -#include -#include - -#include "openxc.pb.h" -#include "../diagnostic/active-diagnostic-request.hpp" - -openxc_VehicleMessage build_VehicleMessage(active_diagnostic_request_t* request, const DiagnosticResponse& response, float parsed_value); -openxc_VehicleMessage build_VehicleMessage(const openxc_SimpleMessage& message); -openxc_VehicleMessage build_VehicleMessage(); -bool is_valid(const openxc_VehicleMessage& v); - -openxc_SimpleMessage build_SimpleMessage(const std::string& name, const openxc_DynamicField& value); -openxc_DynamicField build_DynamicField(const std::string& value); -openxc_DynamicField build_DynamicField(double value); -openxc_DynamicField build_DynamicField(bool value); - -openxc_SimpleMessage get_simple_message(const openxc_VehicleMessage& v_msg); - -void jsonify_DynamicField(const openxc_DynamicField& field, json_object* value); - -bool jsonify_simple(const openxc_SimpleMessage& s_msg, json_object* json); \ No newline at end of file diff --git a/src/utils/signals.cpp b/src/utils/signals.cpp deleted file mode 100644 index 2e14a98f..00000000 --- a/src/utils/signals.cpp +++ /dev/null @@ -1,76 +0,0 @@ -/* - * Copyright (C) 2015, 2016 "IoT.bzh" - * Author "Romain Forlot" - * - * 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. - */ - -#include "signals.hpp" - -/// -/// @brief Can signal event map making access to afb_event -/// externaly to an openxc existing structure. -/// -/// Event map is making relation between can_signal_t generic name -/// and the afb_event struct used by application framework to pushed -/// to the subscriber. -/// -std::map subscribed_signals; - -/// -/// @brief Mutex allowing safe manipulation on subscribed_signals map. -/// To ensure that the map object isn't modified when we read it, you -/// have to set this mutex before use subscribed_signals map object. -/// -std::mutex subscribed_signals_mutex; - -std::mutex& get_subscribed_signals_mutex() -{ - return subscribed_signals_mutex; -} - -std::map& get_subscribed_signals() -{ - return subscribed_signals; -} - -/// -/// @fn std::vector find_signals(const openxc_DynamicField &key) -/// @brief return signals name found searching through CAN_signals and OBD2 pid -/// -/// @param[in] key : can contain numeric or string value in order to search against -/// can signals or obd2 signals name. -/// -/// @return Vector of signals name found. -/// -std::vector find_signals(const openxc_DynamicField &key) -{ - std::vector found_signals_name; - - switch(key.type) - { - case openxc_DynamicField_Type::openxc_DynamicField_Type_STRING: - lookup_signals_by_name(key.string_value, configuration_t::instance().get_can_signals(), found_signals_name); - lookup_signals_by_name(key.string_value, configuration_t::instance().get_diagnostic_messages(), found_signals_name); - break; - case openxc_DynamicField_Type::openxc_DynamicField_Type_NUM: - lookup_signals_by_id(key.numeric_value, configuration_t::instance().get_can_signals(), found_signals_name); - lookup_signals_by_id(key.numeric_value, configuration_t::instance().get_diagnostic_messages(), found_signals_name); - break; - default: - ERROR(binder_interface, "find_signals: wrong openxc_DynamicField specified. Use openxc_DynamicField_Type_NUM or openxc_DynamicField_Type_STRING type only."); - break; - } - DEBUG(binder_interface, "find_signals: Found %d signal(s)", (int)found_signals_name.size()); - return found_signals_name; -} diff --git a/src/utils/signals.hpp b/src/utils/signals.hpp deleted file mode 100644 index e9417569..00000000 --- a/src/utils/signals.hpp +++ /dev/null @@ -1,90 +0,0 @@ -/* - * Copyright (C) 2015, 2016 "IoT.bzh" - * Author "Romain Forlot" - * - * 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. - */ - -#pragma once - -#include -#include -#include - -#include "openxc.pb.h" -#include "../configuration.hpp" -#include "../can/can-signals.hpp" -#include "../diagnostic/diagnostic-message.hpp" - -#include "../low-can-binding.hpp" - -extern std::mutex subscribed_signals_mutex; -std::mutex& get_subscribed_signals_mutex(); - -/** - * @brief return the subscribed_signals map. - * - * return Map of subscribed signals. - */ -extern std::map subscribed_signals; -std::map& get_subscribed_signals(); - -template -void lookup_signals_by_name(const std::string& key, std::vector& signals, std::vector& found_signals) -{ - for(T& s : signals) - { - if(::fnmatch(key.c_str(), s.get_generic_name().c_str(), FNM_CASEFOLD) == 0) - found_signals.push_back(&s); - if(::fnmatch(key.c_str(), s.get_name().c_str(), FNM_CASEFOLD) == 0) - found_signals.push_back(&s); - } -} - -template -void lookup_signals_by_name(const std::string& key, std::vector& signals, std::vector& found_signals_name) -{ - for(T& s : signals) - { - if(::fnmatch(key.c_str(), s.get_generic_name().c_str(), FNM_CASEFOLD) == 0) - found_signals_name.push_back(s.get_name()); - if(::fnmatch(key.c_str(), s.get_name().c_str(), FNM_CASEFOLD) == 0) - found_signals_name.push_back(s.get_name()); - } -} - -template -void lookup_signals_by_id(const double key, std::vector& signals, std::vector& found_signals) -{ - for(T& s : signals) - { - if(configuration_t::instance().get_signal_id(s) == key) - { - found_signals.push_back(&s); - } - } -} - -template -void lookup_signals_by_id(const double key, std::vector& signals, std::vector& found_signals_name) -{ - for(T& s : signals) - { - if(configuration_t::instance().get_signal_id(s) == key) - { - found_signals_name.push_back(s.get_name()); - } - } -} - -std::vector find_signals(const openxc_DynamicField &key); diff --git a/src/utils/socket.cpp b/src/utils/socket.cpp deleted file mode 100644 index e75e27f2..00000000 --- a/src/utils/socket.cpp +++ /dev/null @@ -1,89 +0,0 @@ -/* - * Copyright (C) 2015, 2016 ,2017 "IoT.bzh" - * Author "Romain Forlot" - * Author "Loïc Collignon" - * 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. - */ - -#include -#include "socket.hpp" - -namespace utils -{ - /// @brief Construct a default, invalid, socket. - socket_t::socket_t() - : socket_{INVALID_SOCKET} - { - } - - /// @brief Construct a socket by moving an existing one. - socket_t::socket_t(socket_t&& s) - : socket_{s.socket_} - { - s.socket_ = INVALID_SOCKET; - } - - /// @brief Destruct the socket. - socket_t::~socket_t() - { - if(socket_ != INVALID_SOCKET) - ::close(socket_); - } - - /// @brief Test if socket is valid. - /// @return true if valid, false otherwise. - socket_t::operator bool() const - { - return socket_ != INVALID_SOCKET; - } - - /// @brief Open the socket. - /// @param[in] domain Specifies the communications domain in which a socket is to be created. - /// @param[in] type Specifies the type of socket to be created. - /// @param[in] protocol Specifies a particular protocol to be used with the socket. Specifying a protocol of 0 causes socket() to use an unspecified default protocol appropriate for the requested socket type. - /// @return Upon successful completion, shall return a non-negative integer, the socket file descriptor. Otherwise, a value of -1 shall be returned and errno set to indicate the error. - int socket_t::open(int domain, int type, int protocol) - { - close(); - socket_ = ::socket(domain, type, protocol); - return socket_; - } - - /// @brief Close the socket. - /// @return 0 if success. - int socket_t::close() - { - return socket_ != INVALID_SOCKET ? ::close(socket_) : 0; - } - - /// @brief Set socket option. - /// @return 0 if success. - int socket_t::setopt(int level, int optname, const void* optval, socklen_t optlen) - { - return socket_ != INVALID_SOCKET ? ::setsockopt(socket_, level, optname, optval, optlen) : 0; - } - - /// @brief Bind the socket. - /// @return 0 if success. - int socket_t::bind(const struct sockaddr* addr, socklen_t len) - { - return socket_ != INVALID_SOCKET ? ::bind(socket_, addr, len) : 0; - } - - /// @brief Get the file descriptor. - /// @return The socket's file descriptor - int socket_t::socket() const - { - return socket_; - } -} diff --git a/src/utils/socket.hpp b/src/utils/socket.hpp deleted file mode 100644 index b42eee6a..00000000 --- a/src/utils/socket.hpp +++ /dev/null @@ -1,46 +0,0 @@ -#pragma once - -/* - * Copyright (C) 2015, 2016 ,2017 "IoT.bzh" - * Author "Romain Forlot" - * Author "Loïc Collignon" - * 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. - */ - -#include - -#define INVALID_SOCKET -1 - -namespace utils -{ - class socket_t - { - public: - socket_t(); - socket_t(const socket_t&) = delete; - socket_t(socket_t&&); - ~socket_t(); - - explicit operator bool() const; - - int open(int domain, int type, int protocol); - int close(); - int setopt(int level, int optname, const void* optval, socklen_t optlen); - int socket() const; - int bind(const struct sockaddr* addr, socklen_t len); - - private: - int socket_; - }; -} - diff --git a/src/utils/timer.cpp b/src/utils/timer.cpp deleted file mode 100644 index a35a3e9f..00000000 --- a/src/utils/timer.cpp +++ /dev/null @@ -1,102 +0,0 @@ -/* - * Copyright (C) 2015, 2016 "IoT.bzh" - * Author "Romain Forlot" - * - * 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. - */ - -#include -#include - -#include "timer.hpp" - -long long int system_time_us() -{ - struct timespec t_usec; - long long int timestamp_usec; - - if(!::clock_gettime(CLOCK_MONOTONIC, &t_usec)) - timestamp_usec = (t_usec.tv_nsec / 1000ll) + (t_usec.tv_sec* 1000000ll); - return timestamp_usec; -} - -long long int system_time_ms() -{ - struct timespec t_msec; - long long int timestamp_msec; - - if(!::clock_gettime(CLOCK_MONOTONIC, &t_msec)) - timestamp_msec = (t_msec.tv_nsec / 1000000ll) + (t_msec.tv_sec* 1000ll); - return timestamp_msec; -} - -long long int system_time_s() -{ - struct timespec t_sec; - long long int timestamp_sec; - - if(!::clock_gettime(CLOCK_MONOTONIC, &t_sec)) - timestamp_sec = t_sec.tv_sec; - return timestamp_sec; -} - -frequency_clock_t::frequency_clock_t() - : unit_{1000000}, frequency_{10.0}, last_tick_{0}, time_function_{nullptr} -{} - - -frequency_clock_t::frequency_clock_t(float frequency) - : unit_{1000000}, frequency_{frequency}, last_tick_{0}, time_function_{nullptr} -{} - -/// @brief Return the period in ms given the frequency in hertz. -/// @param[in] frequency - Frequency to convert, in hertz -float frequency_clock_t::frequency_to_period() -{ - return 1 / frequency_ * unit_; -} - -bool frequency_clock_t::started() -{ - return last_tick_ != 0; -} - -time_function_t frequency_clock_t::get_time_function() -{ - return time_function_ != nullptr ? time_function_ : system_time_us; -} - -bool frequency_clock_t::elapsed(bool stagger) -{ - float period = frequency_to_period(); - float elapsed_time = 0; - if(!started() && stagger) - last_tick_ = get_time_function()() - (rand() % int(period)); - - // Make sure it ticks the the first call - elapsed_time = !started() ? period : get_time_function()() - last_tick_; - - return frequency_ == 0 || elapsed_time >= period; -} - -float frequency_clock_t::get_frequency() const -{ - return frequency_; -} - -/// @brief Force the clock to tick, regardless of it its time has actually -/// elapsed. -void frequency_clock_t::tick() -{ - last_tick_ = get_time_function()(); -} \ No newline at end of file diff --git a/src/utils/timer.hpp b/src/utils/timer.hpp deleted file mode 100644 index f5659044..00000000 --- a/src/utils/timer.hpp +++ /dev/null @@ -1,53 +0,0 @@ -/* - * Copyright (C) 2015, 2016 "IoT.bzh" - * Author "Romain Forlot" - * - * 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. - */ - -#pragma once - -/// @brief return epoch in milliseconds -/// -/// @return long long int epoch in milliseconds -typedef long long int (*time_function_t)(); - -long long int system_time_us(); -long long int system_time_ms(); -long long int system_time_s(); - - -/// @brief A frequency counting clock. -/// Utility class allowing some time function. -class frequency_clock_t -{ -private: - float unit_; ///< unit_ - multiplicator to make operation to be in the right unit (milli, micro, nano, etc) - float frequency_; ///< the clock frequency in Hz. - unsigned long last_tick_; ///< the last time (in milliseconds since startup) that the clock ticked. - time_function_t time_function_; ///< a function returning current time - -public: - frequency_clock_t(); - frequency_clock_t(float frequency); - frequency_clock_t(float frequency, unsigned long last_tick, time_function_t time_function); - - float get_frequency() const; - - float frequency_to_period(); - bool started(); - time_function_t get_time_function(); - bool elapsed(bool stagger); - - void tick(); -}; \ No newline at end of file -- cgit 1.2.3-korg