ros2/openvehicle-api
3
0
Fork 0
mirror of https://github.com/eclipse-openvehicle-api/openvehicle-api.git synced 2026-04-21 11:38:16 +00:00
Code Issues Packages Projects Releases 1 Wiki Activity

Precommit (#1)

Browse Source 
* first commit

* cleanup
This commit is contained in:
tompzf
2025-11-04 13:28:06 +01:00
committed by GitHub
parent dba45dc636
commit 6ed4b1534e
898 changed files with 256340 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

49
examples/door_demo_example/bs/bs_front_door_left/CMakeLists.txt Normal file
View File

@@ -0,0 +1,49 @@
# Enforce CMake version 3.20 or newer needed for path function
cmake_minimum_required (VERSION 3.20)
# Use new policy for project version settings and default warning level
cmake_policy(SET CMP0048 NEW) # requires CMake 3.14
cmake_policy(SET CMP0092 NEW) # requires CMake 3.15
# Define project
project(doors_bs_frontdoorleft VERSION 1.0 LANGUAGES CXX)
# Use C++17 support
set(CMAKE_CXX_STANDARD 17)
# Libary symbols are hidden by default
set(CMAKE_CXX_VISIBILITY_PRESET hidden)
# Set target name.
set(TARGET_NAME doors_bs_frontdoorleft)
# Set the SDV_FRAMEWORK_DEV_INCLUDE if not defined yet
if (NOT DEFINED SDV_FRAMEWORK_DEV_INCLUDE)
if (NOT DEFINED ENV{SDV_FRAMEWORK_DEV_INCLUDE})
message( FATAL_ERROR "The environment variable SDV_FRAMEWORK_DEV_INCLUDE needs to be pointing to the SDV V-API development include files location!")
endif()
set (SDV_FRAMEWORK_DEV_INCLUDE "$ENV{SDV_FRAMEWORK_DEV_INCLUDE}")
endif()
# Include link to export directory of SDV V-API development include files location
include_directories(${SDV_FRAMEWORK_DEV_INCLUDE})
include_directories(../../interfaces)
# Set platform specific compile flags
if (CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
add_compile_options(/W4 /WX /wd4996 /wd4100 /permissive- /Zc:rvalueCast)
else()
add_compile_options(-Werror -Wall -Wextra -Wshadow -Wpedantic -Wunreachable-code -fno-common)
endif()
# Add the dynamic library
add_library(${TARGET_NAME} SHARED
bs_front_door_left.h
bs_front_door_left.cpp)
# Set extension to .sdv
set_target_properties(${TARGET_NAME} PROPERTIES PREFIX "")
set_target_properties(${TARGET_NAME} PROPERTIES SUFFIX ".sdv")
# TODO: set target name.
#add_dependencies(${TARGET_NAME} <add_cmake_target_this_depends_on>)

115
examples/door_demo_example/bs/bs_front_door_left/bs_front_door_left.cpp Normal file
View File

@@ -0,0 +1,115 @@
/**
* @file bs_front_door_left.cpp
* @date 2025-07-11 12:57:18
* File is auto generated from VSS utility.
* VSS Version:1.0.0.1
*/
#include <iostream>
#include "bs_front_door_left.h"
/**
* @brief ConstructorF
*/
CBasicServiceFrontDoorLeft::CBasicServiceFrontDoorLeft()
{
auto leftDoorIsOpen01Device = sdv::core::GetObject("Vehicle.Chassis.Door.Axle01.Left_Device").GetInterface<vss::Vehicle::Chassis::Door::Axle01::LeftDevice::IVSS_IsOpen>();
if (!leftDoorIsOpen01Device)
{
SDV_LOG_ERROR("Could not get interface 'IVSS_IsOpen': [CBasicServiceFrontDoorLeft]");
throw std::runtime_error("Vehicle.Chassis.Door.Axle01.Left mode device not found");
}
leftDoorIsOpen01Device->RegisterIsOpenEvent(dynamic_cast<vss::Vehicle::Chassis::Door::Axle01::LeftDevice::IVSS_WriteIsOpen_Event*> (this));
m_ptrLock = sdv::core::GetObject("Vehicle.Chassis.Door.Axle01.Left_Device").GetInterface<vss::Vehicle::Chassis::Door::Axle01::LeftDevice::IVSS_WriteLock>();
if (!m_ptrLock)
{
SDV_LOG_ERROR("Could not get interface 'IVSS_WriteLock': [CBasicServiceFrontDoorLeft]");
throw std::runtime_error("Lock device not found");
}
SDV_LOG_TRACE("CBasicServiceFrontDoorLeft created: [Vehicle.Chassis.Door.Axle01.Left_Device]");
m_leftDoorIsOpen01 = 0;
}
/**
* @brief User-Defined Destructor
*/
CBasicServiceFrontDoorLeft::~CBasicServiceFrontDoorLeft()
{
auto leftDoorIsOpen01Device = sdv::core::GetObject("Vehicle.Chassis.Door.Axle01.Left_Device").GetInterface<vss::Vehicle::Chassis::Door::Axle01::LeftDevice::IVSS_IsOpen>();
if (leftDoorIsOpen01Device)
{
leftDoorIsOpen01Device->UnregisterIsOpenEvent(dynamic_cast<vss::Vehicle::Chassis::Door::Axle01::LeftDevice::IVSS_WriteIsOpen_Event*> (this));
}
leftDoorIsOpen01Device = nullptr;
}
/**
* @brief Set leftDoorIsOpen
* @param[in] value leftDoorIsOpen
*/
void CBasicServiceFrontDoorLeft::SetIsOpenL1(bool value)
{
m_leftDoorIsOpen01 = value;
std::lock_guard<std::mutex> lock(m_leftDoorIsOpen01MutexCallbacks);
for (auto callback : m_leftDoorIsOpen01Callbacks)
{
callback->SetIsOpenL1(value);
}
}
/**
* @brief Write leftDoorIsOpen
* @param[in] value leftDoorIsOpen
*/
void CBasicServiceFrontDoorLeft::WriteIsOpen(bool value)
{
SetIsOpenL1(value);
}
/**
* @brief Get leftDoorIsOpen
* @return Returns the leftDoorIsOpen
*/
bool CBasicServiceFrontDoorLeft::GetIsOpen() const
{
return m_leftDoorIsOpen01;
}
/**
* @brief Register Callback on signal change
* @param[in] callback function
*/
void CBasicServiceFrontDoorLeft::RegisterOnSignalChangeOfLeftDoorIsOpen01(vss::Vehicle::Chassis::Door::Axle01::LeftService::IVSS_SetIsOpen_Event* leftDoorIsOpen01Callback)
{
if ( leftDoorIsOpen01Callback)
{
std::lock_guard<std::mutex> lock(m_leftDoorIsOpen01MutexCallbacks);
m_leftDoorIsOpen01Callbacks.insert(leftDoorIsOpen01Callback);
}
}
/**
* @brief Unregister Callback
* @param[in] callback function
*/
void CBasicServiceFrontDoorLeft::UnregisterOnSignalChangeOfLeftDoorIsOpen01(vss::Vehicle::Chassis::Door::Axle01::LeftService::IVSS_SetIsOpen_Event* leftDoorIsOpen01Callback)
{
if (leftDoorIsOpen01Callback)
{
std::lock_guard<std::mutex> lock(m_leftDoorIsOpen01MutexCallbacks);
m_leftDoorIsOpen01Callbacks.erase(leftDoorIsOpen01Callback);
}
}
/**
* @brief Lock
* @param[in] value
* @return true on success otherwise false
*/
bool CBasicServiceFrontDoorLeft::SetLock(bool value)
{
return m_ptrLock->WriteLock(value);
}

95
examples/door_demo_example/bs/bs_front_door_left/bs_front_door_left.h Normal file
View File

@@ -0,0 +1,95 @@
/**
* @file bs_front_door_left.h
* @date 2025-07-11 12:57:18
* File is auto generated from VSS utility.
* VSS Version:1.0.0.1
*/
#ifndef __VSS_GENERATED__BS_FRONTDOORLEFT_H_20250711_125718_601__
#define __VSS_GENERATED__BS_FRONTDOORLEFT_H_20250711_125718_601__
#include <iostream>
#include <set>
#include <support/component_impl.h>
#include <support/signal_support.h>
#include "vss_vehiclechassisdooraxle01left_bs_rx.h"
#include "vss_vehiclechassisdooraxle01left_vd_tx.h"
#include "vss_vehiclechassisdooraxle01left_bs_tx.h"
/**
* @brief Basic Service Vehicle.Chassis.Door.Axle01.Left
*/
class CBasicServiceFrontDoorLeft
: public sdv::CSdvObject
, public vss::Vehicle::Chassis::Door::Axle01::LeftService::IVSS_GetIsOpen
, public vss::Vehicle::Chassis::Door::Axle01::LeftService::IVSS_SetIsOpen_Event
, public vss::Vehicle::Chassis::Door::Axle01::LeftDevice::IVSS_WriteIsOpen_Event
, public vss::Vehicle::Chassis::Door::Axle01::LeftService::IVSS_SetLock
{
public:
BEGIN_SDV_INTERFACE_MAP()
SDV_INTERFACE_ENTRY(vss::Vehicle::Chassis::Door::Axle01::LeftService::IVSS_GetIsOpen)
SDV_INTERFACE_ENTRY(vss::Vehicle::Chassis::Door::Axle01::LeftService::IVSS_SetLock)
END_SDV_INTERFACE_MAP()
DECLARE_OBJECT_CLASS_TYPE(sdv::EObjectType::BasicService)
DECLARE_OBJECT_CLASS_NAME("Vehicle.Chassis.Door.Axle01.Left_Service")
/**
* @brief Constructor
*/
CBasicServiceFrontDoorLeft();
/**
* @brief User-Defined Destructor
*/
~CBasicServiceFrontDoorLeft();
/**
* @brief Set leftDoorIsOpen signal
* @param[in] value leftDoorIsOpen
*/
void SetIsOpenL1(bool value) override;
/**
* @brief Get leftDoorIsOpen
* @return Returns the leftDoorIsOpen
*/
bool GetIsOpen() const override;
/**
* @brief Write leftDoorIsOpen signal
* @param[in] value leftDoorIsOpen
*/
void WriteIsOpen(bool value) override;
/**
* @brief Set leftLatch signal
* @param[in] value
* @return true on success otherwise false
*/
bool SetLock(bool value) override;
/**
* @brief Register CallBack function on signal change
* @param[in] callback function
*/
void RegisterOnSignalChangeOfLeftDoorIsOpen01(vss::Vehicle::Chassis::Door::Axle01::LeftService::IVSS_SetIsOpen_Event* callback) override;
/**
* @brief Unregister CallBack function on signal change
* @param[in] callback function
*/
void UnregisterOnSignalChangeOfLeftDoorIsOpen01(vss::Vehicle::Chassis::Door::Axle01::LeftService::IVSS_SetIsOpen_Event* callback) override;
private:
bool m_leftDoorIsOpen01 { 0 };
mutable std::mutex m_leftDoorIsOpen01MutexCallbacks; ///< Mutex protecting m_leftDoorIsOpen01Callbacks
std::set<vss::Vehicle::Chassis::Door::Axle01::LeftService::IVSS_SetIsOpen_Event*> m_leftDoorIsOpen01Callbacks; ///< collection of events to be called
vss::Vehicle::Chassis::Door::Axle01::LeftDevice::IVSS_WriteLock* m_ptrLock = nullptr;
};
DEFINE_SDV_OBJECT(CBasicServiceFrontDoorLeft)
#endif // !define __VSS_GENERATED__BS_FRONTDOORLEFT_H_20250711_125718_601__

49
examples/door_demo_example/bs/bs_front_door_right/CMakeLists.txt Normal file
View File

@@ -0,0 +1,49 @@
# Enforce CMake version 3.20 or newer needed for path function
cmake_minimum_required (VERSION 3.20)
# Use new policy for project version settings and default warning level
cmake_policy(SET CMP0048 NEW) # requires CMake 3.14
cmake_policy(SET CMP0092 NEW) # requires CMake 3.15
# Define project
project(doors_bs_frontdoorright VERSION 1.0 LANGUAGES CXX)
# Use C++17 support
set(CMAKE_CXX_STANDARD 17)
# Libary symbols are hidden by default
set(CMAKE_CXX_VISIBILITY_PRESET hidden)
# Set target name.
set(TARGET_NAME doors_bs_frontdoorright)
# Set the SDV_FRAMEWORK_DEV_INCLUDE if not defined yet
if (NOT DEFINED SDV_FRAMEWORK_DEV_INCLUDE)
if (NOT DEFINED ENV{SDV_FRAMEWORK_DEV_INCLUDE})
message( FATAL_ERROR "The environment variable SDV_FRAMEWORK_DEV_INCLUDE needs to be pointing to the SDV V-API development include files location!")
endif()
set (SDV_FRAMEWORK_DEV_INCLUDE "$ENV{SDV_FRAMEWORK_DEV_INCLUDE}")
endif()
# Include link to export directory of SDV V-API development include files location
include_directories(${SDV_FRAMEWORK_DEV_INCLUDE})
include_directories(../../interfaces)
# Set platform specific compile flags
if (CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
add_compile_options(/W4 /WX /wd4996 /wd4100 /permissive- /Zc:rvalueCast)
else()
add_compile_options(-Werror -Wall -Wextra -Wshadow -Wpedantic -Wunreachable-code -fno-common)
endif()
# Add the dynamic library
add_library(${TARGET_NAME} SHARED
bs_front_door_right.h
bs_front_door_right.cpp)
# Set extension to .sdv
set_target_properties(${TARGET_NAME} PROPERTIES PREFIX "")
set_target_properties(${TARGET_NAME} PROPERTIES SUFFIX ".sdv")
# TODO: set target name.
#add_dependencies(${TARGET_NAME} <add_cmake_target_this_depends_on>)

115
examples/door_demo_example/bs/bs_front_door_right/bs_front_door_right.cpp Normal file
View File

@@ -0,0 +1,115 @@
/**
* @file bs_front_door_right.cpp
* @date 2025-07-11 12:57:18
* File is auto generated from VSS utility.
* VSS Version:1.0.0.1
*/
#include <iostream>
#include "bs_front_door_right.h"
/**
* @brief ConstructorF
*/
CBasicServiceFrontDoorRight::CBasicServiceFrontDoorRight()
{
auto rightDoorIsOpen01Device = sdv::core::GetObject("Vehicle.Chassis.Door.Axle01.Right_Device").GetInterface<vss::Vehicle::Chassis::Door::Axle01::RightDevice::IVSS_IsOpen>();
if (!rightDoorIsOpen01Device)
{
SDV_LOG_ERROR("Could not get interface 'IVSS_IsOpen': [CBasicServiceFrontDoorRight]");
throw std::runtime_error("Vehicle.Chassis.Door.Axle01.Right mode device not found");
}
rightDoorIsOpen01Device->RegisterIsOpenEvent(dynamic_cast<vss::Vehicle::Chassis::Door::Axle01::RightDevice::IVSS_WriteIsOpen_Event*> (this));
m_ptrLock = sdv::core::GetObject("Vehicle.Chassis.Door.Axle01.Right_Device").GetInterface<vss::Vehicle::Chassis::Door::Axle01::RightDevice::IVSS_WriteLock>();
if (!m_ptrLock)
{
SDV_LOG_ERROR("Could not get interface 'IVSS_WriteLock': [CBasicServiceFrontDoorRight]");
throw std::runtime_error("Lock device not found");
}
SDV_LOG_TRACE("CBasicServiceFrontDoorRight created: [Vehicle.Chassis.Door.Axle01.Right_Device]");
m_rightDoorIsOpen01 = 0;
}
/**
* @brief User-Defined Destructor
*/
CBasicServiceFrontDoorRight::~CBasicServiceFrontDoorRight()
{
auto rightDoorIsOpen01Device = sdv::core::GetObject("Vehicle.Chassis.Door.Axle01.Right_Device").GetInterface<vss::Vehicle::Chassis::Door::Axle01::RightDevice::IVSS_IsOpen>();
if (rightDoorIsOpen01Device)
{
rightDoorIsOpen01Device->UnregisterIsOpenEvent(dynamic_cast<vss::Vehicle::Chassis::Door::Axle01::RightDevice::IVSS_WriteIsOpen_Event*> (this));
}
rightDoorIsOpen01Device = nullptr;
}
/**
* @brief Set rightDoorIsOpen
* @param[in] value rightDoorIsOpen
*/
void CBasicServiceFrontDoorRight::SetIsOpenR1(bool value)
{
m_rightDoorIsOpen01 = value;
std::lock_guard<std::mutex> lock(m_rightDoorIsOpen01MutexCallbacks);
for (auto callback : m_rightDoorIsOpen01Callbacks)
{
callback->SetIsOpenR1(value);
}
}
/**
* @brief Write rightDoorIsOpen
* @param[in] value rightDoorIsOpen
*/
void CBasicServiceFrontDoorRight::WriteIsOpen(bool value)
{
SetIsOpenR1(value);
}
/**
* @brief Get rightDoorIsOpen
* @return Returns the rightDoorIsOpen
*/
bool CBasicServiceFrontDoorRight::GetIsOpen() const
{
return m_rightDoorIsOpen01;
}
/**
* @brief Register Callback on signal change
* @param[in] callback function
*/
void CBasicServiceFrontDoorRight::RegisterOnSignalChangeOfRightDoorIsOpen01(vss::Vehicle::Chassis::Door::Axle01::RightService::IVSS_SetIsOpen_Event* rightDoorIsOpen01Callback)
{
if ( rightDoorIsOpen01Callback)
{
std::lock_guard<std::mutex> lock(m_rightDoorIsOpen01MutexCallbacks);
m_rightDoorIsOpen01Callbacks.insert(rightDoorIsOpen01Callback);
}
}
/**
* @brief Unregister Callback
* @param[in] callback function
*/
void CBasicServiceFrontDoorRight::UnregisterOnSignalChangeOfRightDoorIsOpen01(vss::Vehicle::Chassis::Door::Axle01::RightService::IVSS_SetIsOpen_Event* rightDoorIsOpen01Callback)
{
if (rightDoorIsOpen01Callback)
{
std::lock_guard<std::mutex> lock(m_rightDoorIsOpen01MutexCallbacks);
m_rightDoorIsOpen01Callbacks.erase(rightDoorIsOpen01Callback);
}
}
/**
* @brief Lock
* @param[in] value
* @return true on success otherwise false
*/
bool CBasicServiceFrontDoorRight::SetLock(bool value)
{
return m_ptrLock->WriteLock(value);
}

95
examples/door_demo_example/bs/bs_front_door_right/bs_front_door_right.h Normal file
View File

@@ -0,0 +1,95 @@
/**
* @file bs_front_door_right.h
* @date 2025-07-11 12:57:18
* File is auto generated from VSS utility.
* VSS Version:1.0.0.1
*/
#ifndef __VSS_GENERATED__BS_FRONTDOORRIGHT_H_20250711_125718_606__
#define __VSS_GENERATED__BS_FRONTDOORRIGHT_H_20250711_125718_606__
#include <iostream>
#include <set>
#include <support/component_impl.h>
#include <support/signal_support.h>
#include "vss_vehiclechassisdooraxle01right_bs_rx.h"
#include "vss_vehiclechassisdooraxle01right_vd_tx.h"
#include "vss_vehiclechassisdooraxle01right_bs_tx.h"
/**
* @brief Basic Service Vehicle.Chassis.Door.Axle01.Right
*/
class CBasicServiceFrontDoorRight
: public sdv::CSdvObject
, public vss::Vehicle::Chassis::Door::Axle01::RightService::IVSS_GetIsOpen
, public vss::Vehicle::Chassis::Door::Axle01::RightService::IVSS_SetIsOpen_Event
, public vss::Vehicle::Chassis::Door::Axle01::RightDevice::IVSS_WriteIsOpen_Event
, public vss::Vehicle::Chassis::Door::Axle01::RightService::IVSS_SetLock
{
public:
BEGIN_SDV_INTERFACE_MAP()
SDV_INTERFACE_ENTRY(vss::Vehicle::Chassis::Door::Axle01::RightService::IVSS_GetIsOpen)
SDV_INTERFACE_ENTRY(vss::Vehicle::Chassis::Door::Axle01::RightService::IVSS_SetLock)
END_SDV_INTERFACE_MAP()
DECLARE_OBJECT_CLASS_TYPE(sdv::EObjectType::BasicService)
DECLARE_OBJECT_CLASS_NAME("Vehicle.Chassis.Door.Axle01.Right_Service")
/**
* @brief Constructor
*/
CBasicServiceFrontDoorRight();
/**
* @brief User-Defined Destructor
*/
~CBasicServiceFrontDoorRight();
/**
* @brief Set rightDoorIsOpen signal
* @param[in] value rightDoorIsOpen
*/
void SetIsOpenR1(bool value) override;
/**
* @brief Set signal
* @param[in] value rightLatche
* @return true on success otherwise false
*/
bool SetLock(bool value) override;
/**
* @brief Get rightDoorIsOpen
* @return Returns the rightDoorIsOpen
*/
bool GetIsOpen() const override;
/**
* @brief Write rightDoorIsOpen signal
* @param[in] value rightDoorIsOpen
*/
void WriteIsOpen(bool value) override;
/**
* @brief Register CallBack function on signal change
* @param[in] callback function
*/
void RegisterOnSignalChangeOfRightDoorIsOpen01(vss::Vehicle::Chassis::Door::Axle01::RightService::IVSS_SetIsOpen_Event* callback) override;
/**
* @brief Unregister CallBack function on signal change
* @param[in] callback function
*/
void UnregisterOnSignalChangeOfRightDoorIsOpen01(vss::Vehicle::Chassis::Door::Axle01::RightService::IVSS_SetIsOpen_Event* callback) override;
private:
bool m_rightDoorIsOpen01 { 0 };
mutable std::mutex m_rightDoorIsOpen01MutexCallbacks; ///< Mutex protecting m_rightDoorIsOpen01Callbacks
std::set<vss::Vehicle::Chassis::Door::Axle01::RightService::IVSS_SetIsOpen_Event*> m_rightDoorIsOpen01Callbacks; ///< collection of events to be called
vss::Vehicle::Chassis::Door::Axle01::RightDevice::IVSS_WriteLock* m_ptrLock = nullptr;
};
DEFINE_SDV_OBJECT(CBasicServiceFrontDoorRight)
#endif // !define __VSS_GENERATED__BS_FRONTDOORRIGHT_H_20250711_125718_606__

49
examples/door_demo_example/bs/bs_rear_door_left/CMakeLists.txt Normal file
View File

@@ -0,0 +1,49 @@
# Enforce CMake version 3.20 or newer needed for path function
cmake_minimum_required (VERSION 3.20)
# Use new policy for project version settings and default warning level
cmake_policy(SET CMP0048 NEW) # requires CMake 3.14
cmake_policy(SET CMP0092 NEW) # requires CMake 3.15
# Define project
project(doors_bs_reardoorleft VERSION 1.0 LANGUAGES CXX)
# Use C++17 support
set(CMAKE_CXX_STANDARD 17)
# Libary symbols are hidden by default
set(CMAKE_CXX_VISIBILITY_PRESET hidden)
# Set target name.
set(TARGET_NAME doors_bs_reardoorleft)
# Set the SDV_FRAMEWORK_DEV_INCLUDE if not defined yet
if (NOT DEFINED SDV_FRAMEWORK_DEV_INCLUDE)
if (NOT DEFINED ENV{SDV_FRAMEWORK_DEV_INCLUDE})
message( FATAL_ERROR "The environment variable SDV_FRAMEWORK_DEV_INCLUDE needs to be pointing to the SDV V-API development include files location!")
endif()
set (SDV_FRAMEWORK_DEV_INCLUDE "$ENV{SDV_FRAMEWORK_DEV_INCLUDE}")
endif()
# Include link to export directory of SDV V-API development include files location
include_directories(${SDV_FRAMEWORK_DEV_INCLUDE})
include_directories(../../interfaces)
# Set platform specific compile flags
if (CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
add_compile_options(/W4 /WX /wd4996 /wd4100 /permissive- /Zc:rvalueCast)
else()
add_compile_options(-Werror -Wall -Wextra -Wshadow -Wpedantic -Wunreachable-code -fno-common)
endif()
# Add the dynamic library
add_library(${TARGET_NAME} SHARED
bs_rear_door_left.h
bs_rear_door_left.cpp)
# Set extension to .sdv
set_target_properties(${TARGET_NAME} PROPERTIES PREFIX "")
set_target_properties(${TARGET_NAME} PROPERTIES SUFFIX ".sdv")
# TODO: set target name.
#add_dependencies(${TARGET_NAME} <add_cmake_target_this_depends_on>)

115
examples/door_demo_example/bs/bs_rear_door_left/bs_rear_door_left.cpp Normal file
View File

@@ -0,0 +1,115 @@
/**
* @file bs_rear_door_left.cpp
* @date 2025-07-11 12:57:18
* File is auto generated from VSS utility.
* VSS Version:1.0.0.1
*/
#include <iostream>
#include "bs_rear_door_left.h"
/**
* @brief ConstructorF
*/
CBasicServiceRearDoorLeft::CBasicServiceRearDoorLeft()
{
auto leftDoorIsOpen02Device = sdv::core::GetObject("Vehicle.Chassis.Door.Axle02.Left_Device").GetInterface<vss::Vehicle::Chassis::Door::Axle02::LeftDevice::IVSS_IsOpen>();
if (!leftDoorIsOpen02Device)
{
SDV_LOG_ERROR("Could not get interface 'IVSS_IsOpen': [CBasicServiceRearDoorLeft]");
throw std::runtime_error("Vehicle.Chassis.Door.Axle02.Left mode device not found");
}
leftDoorIsOpen02Device->RegisterIsOpenEvent(dynamic_cast<vss::Vehicle::Chassis::Door::Axle02::LeftDevice::IVSS_WriteIsOpen_Event*> (this));
m_ptrLock = sdv::core::GetObject("Vehicle.Chassis.Door.Axle02.Left_Device").GetInterface<vss::Vehicle::Chassis::Door::Axle02::LeftDevice::IVSS_WriteLock>();
if (!m_ptrLock)
{
SDV_LOG_ERROR("Could not get interface 'IVSS_WriteLock': [CBasicServiceRearDoorLeft]");
throw std::runtime_error("Lock device not found");
}
SDV_LOG_TRACE("CBasicServiceRearDoorLeft created: [Vehicle.Chassis.Door.Axle02.Left_Device]");
m_leftDoorIsOpen02 = 0;
}
/**
* @brief User-Defined Destructor
*/
CBasicServiceRearDoorLeft::~CBasicServiceRearDoorLeft()
{
auto leftDoorIsOpen02Device = sdv::core::GetObject("Vehicle.Chassis.Door.Axle02.Left_Device").GetInterface<vss::Vehicle::Chassis::Door::Axle02::LeftDevice::IVSS_IsOpen>();
if (leftDoorIsOpen02Device)
{
leftDoorIsOpen02Device->UnregisterIsOpenEvent(dynamic_cast<vss::Vehicle::Chassis::Door::Axle02::LeftDevice::IVSS_WriteIsOpen_Event*> (this));
}
leftDoorIsOpen02Device = nullptr;
}
/**
* @brief Set rightDoorIsOpen
* @param[in] value rightDoorIsOpen
*/
void CBasicServiceRearDoorLeft::SetIsOpenL2(bool value)
{
m_leftDoorIsOpen02 = value;
std::lock_guard<std::mutex> lock(m_leftDoorIsOpen02MutexCallbacks);
for (auto callback : m_leftDoorIsOpen02Callbacks)
{
callback->SetIsOpenL2(value);
}
}
/**
* @brief Write rightDoorIsOpen
* @param[in] value rightDoorIsOpen
*/
void CBasicServiceRearDoorLeft::WriteIsOpen(bool value)
{
SetIsOpenL2(value);
}
/**
* @brief Get rightDoorIsOpen
* @return Returns the rightDoorIsOpen
*/
bool CBasicServiceRearDoorLeft::GetIsOpen() const
{
return m_leftDoorIsOpen02;
}
/**
* @brief Register Callback on signal change
* @param[in] callback function
*/
void CBasicServiceRearDoorLeft::RegisterOnSignalChangeOfLeftDoorIsOpen02(vss::Vehicle::Chassis::Door::Axle02::LeftService::IVSS_SetIsOpen_Event* leftDoorIsOpen02Callback)
{
if ( leftDoorIsOpen02Callback)
{
std::lock_guard<std::mutex> lock(m_leftDoorIsOpen02MutexCallbacks);
m_leftDoorIsOpen02Callbacks.insert(leftDoorIsOpen02Callback);
}
}
/**
* @brief Unregister Callback
* @param[in] callback function
*/
void CBasicServiceRearDoorLeft::UnregisterOnSignalChangeOfLeftDoorIsOpen02(vss::Vehicle::Chassis::Door::Axle02::LeftService::IVSS_SetIsOpen_Event* leftDoorIsOpen02Callback)
{
if (leftDoorIsOpen02Callback)
{
std::lock_guard<std::mutex> lock(m_leftDoorIsOpen02MutexCallbacks);
m_leftDoorIsOpen02Callbacks.erase(leftDoorIsOpen02Callback);
}
}
/**
* @brief Lock
* @param[in] value
* @return true on success otherwise false
*/
bool CBasicServiceRearDoorLeft::SetLock(bool value)
{
return m_ptrLock->WriteLock(value);
}

95
examples/door_demo_example/bs/bs_rear_door_left/bs_rear_door_left.h Normal file
View File

@@ -0,0 +1,95 @@
/**
* @file bs_rear_door_left.h
* @date 2025-07-11 12:57:18
* File is auto generated from VSS utility.
* VSS Version:1.0.0.1
*/
#ifndef __VSS_GENERATED__BS_REARDOORLEFT_H_20250711_125718_611__
#define __VSS_GENERATED__BS_REARDOORLEFT_H_20250711_125718_611__
#include <iostream>
#include <set>
#include <support/component_impl.h>
#include <support/signal_support.h>
#include "vss_vehiclechassisdooraxle02left_bs_rx.h"
#include "vss_vehiclechassisdooraxle02left_vd_tx.h"
#include "vss_vehiclechassisdooraxle02left_bs_tx.h"
/**
* @brief Basic Service Vehicle.Chassis.Door.Axle02.Left
*/
class CBasicServiceRearDoorLeft
: public sdv::CSdvObject
, public vss::Vehicle::Chassis::Door::Axle02::LeftService::IVSS_GetIsOpen
, public vss::Vehicle::Chassis::Door::Axle02::LeftService::IVSS_SetIsOpen_Event
, public vss::Vehicle::Chassis::Door::Axle02::LeftDevice::IVSS_WriteIsOpen_Event
, public vss::Vehicle::Chassis::Door::Axle02::LeftService::IVSS_SetLock
{
public:
BEGIN_SDV_INTERFACE_MAP()
SDV_INTERFACE_ENTRY(vss::Vehicle::Chassis::Door::Axle02::LeftService::IVSS_GetIsOpen)
SDV_INTERFACE_ENTRY(vss::Vehicle::Chassis::Door::Axle02::LeftService::IVSS_SetLock)
END_SDV_INTERFACE_MAP()
DECLARE_OBJECT_CLASS_TYPE(sdv::EObjectType::BasicService)
DECLARE_OBJECT_CLASS_NAME("Vehicle.Chassis.Door.Axle02.Left_Service")
/**
* @brief Constructor
*/
CBasicServiceRearDoorLeft();
/**
* @brief User-Defined Destructor
*/
~CBasicServiceRearDoorLeft();
/**
* @brief Set rightDoorIsOpen signal
* @param[in] value rightDoorIsOpen
*/
void SetIsOpenL2(bool value) override;
/**
* @brief Set leftLatch02 signal
* @param[in] value
* @return true on success otherwise false
*/
bool SetLock(bool value) override;
/**
* @brief Get rightDoorIsOpen
* @return Returns the rightDoorIsOpen
*/
bool GetIsOpen() const override;
/**
* @brief Write rightDoorIsOpen signal
* @param[in] value rightDoorIsOpen
*/
void WriteIsOpen(bool value) override;
/**
* @brief Register CallBack function on signal change
* @param[in] callback function
*/
void RegisterOnSignalChangeOfLeftDoorIsOpen02(vss::Vehicle::Chassis::Door::Axle02::LeftService::IVSS_SetIsOpen_Event* callback) override;
/**
* @brief Unregister CallBack function on signal change
* @param[in] callback function
*/
void UnregisterOnSignalChangeOfLeftDoorIsOpen02(vss::Vehicle::Chassis::Door::Axle02::LeftService::IVSS_SetIsOpen_Event* callback) override;
private:
bool m_leftDoorIsOpen02 { 0 };
mutable std::mutex m_leftDoorIsOpen02MutexCallbacks; ///< Mutex protecting m_leftDoorIsOpen02Callbacks
std::set<vss::Vehicle::Chassis::Door::Axle02::LeftService::IVSS_SetIsOpen_Event*> m_leftDoorIsOpen02Callbacks; ///< collection of events to be called
vss::Vehicle::Chassis::Door::Axle02::LeftDevice::IVSS_WriteLock* m_ptrLock = nullptr;
};
DEFINE_SDV_OBJECT(CBasicServiceRearDoorLeft)
#endif // !define __VSS_GENERATED__BS_REARDOORLEFT_H_20250711_125718_611__

49
examples/door_demo_example/bs/bs_rear_door_right/CMakeLists.txt Normal file
View File

@@ -0,0 +1,49 @@
# Enforce CMake version 3.20 or newer needed for path function
cmake_minimum_required (VERSION 3.20)
# Use new policy for project version settings and default warning level
cmake_policy(SET CMP0048 NEW) # requires CMake 3.14
cmake_policy(SET CMP0092 NEW) # requires CMake 3.15
# Define project
project(doors_bs_reardoorright VERSION 1.0 LANGUAGES CXX)
# Use C++17 support
set(CMAKE_CXX_STANDARD 17)
# Libary symbols are hidden by default
set(CMAKE_CXX_VISIBILITY_PRESET hidden)
# Set target name.
set(TARGET_NAME doors_bs_reardoorright)
# Set the SDV_FRAMEWORK_DEV_INCLUDE if not defined yet
if (NOT DEFINED SDV_FRAMEWORK_DEV_INCLUDE)
if (NOT DEFINED ENV{SDV_FRAMEWORK_DEV_INCLUDE})
message( FATAL_ERROR "The environment variable SDV_FRAMEWORK_DEV_INCLUDE needs to be pointing to the SDV V-API development include files location!")
endif()
set (SDV_FRAMEWORK_DEV_INCLUDE "$ENV{SDV_FRAMEWORK_DEV_INCLUDE}")
endif()
# Include link to export directory of SDV V-API development include files location
include_directories(${SDV_FRAMEWORK_DEV_INCLUDE})
include_directories(../../interfaces)
# Set platform specific compile flags
if (CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
add_compile_options(/W4 /WX /wd4996 /wd4100 /permissive- /Zc:rvalueCast)
else()
add_compile_options(-Werror -Wall -Wextra -Wshadow -Wpedantic -Wunreachable-code -fno-common)
endif()
# Add the dynamic library
add_library(${TARGET_NAME} SHARED
bs_rear_door_right.h
bs_rear_door_right.cpp)
# Set extension to .sdv
set_target_properties(${TARGET_NAME} PROPERTIES PREFIX "")
set_target_properties(${TARGET_NAME} PROPERTIES SUFFIX ".sdv")
# TODO: set target name.
#add_dependencies(${TARGET_NAME} <add_cmake_target_this_depends_on>)

115
examples/door_demo_example/bs/bs_rear_door_right/bs_rear_door_right.cpp Normal file
View File

@@ -0,0 +1,115 @@
/**
* @file bs_rear_door_right.cpp
* @date 2025-07-11 12:57:18
* File is auto generated from VSS utility.
* VSS Version:1.0.0.1
*/
#include <iostream>
#include "bs_rear_door_right.h"
/**
* @brief ConstructorF
*/
CBasicServiceRearDoorRight::CBasicServiceRearDoorRight()
{
auto rightDoorIsOpen02Device = sdv::core::GetObject("Vehicle.Chassis.Door.Axle02.Right_Device").GetInterface<vss::Vehicle::Chassis::Door::Axle02::RightDevice::IVSS_IsOpen>();
if (!rightDoorIsOpen02Device)
{
SDV_LOG_ERROR("Could not get interface 'IVSS_IsOpen': [CBasicServiceRearDoorRight]");
throw std::runtime_error("Vehicle.Chassis.Door.Axle02.Right mode device not found");
}
rightDoorIsOpen02Device->RegisterIsOpenEvent(dynamic_cast<vss::Vehicle::Chassis::Door::Axle02::RightDevice::IVSS_WriteIsOpen_Event*> (this));
m_ptrLock = sdv::core::GetObject("Vehicle.Chassis.Door.Axle02.Right_Device").GetInterface<vss::Vehicle::Chassis::Door::Axle02::RightDevice::IVSS_WriteLock>();
if (!m_ptrLock)
{
SDV_LOG_ERROR("Could not get interface 'IVSS_WriteLock': [CBasicServiceRearDoorRight]");
throw std::runtime_error("Lock device not found");
}
SDV_LOG_TRACE("CBasicServiceRearDoorRight created: [Vehicle.Chassis.Door.Axle02.Right_Device]");
m_rightDoorIsOpen02 = 0;
}
/**
* @brief User-Defined Destructor
*/
CBasicServiceRearDoorRight::~CBasicServiceRearDoorRight()
{
auto rightDoorIsOpen02Device = sdv::core::GetObject("Vehicle.Chassis.Door.Axle02.Right_Device").GetInterface<vss::Vehicle::Chassis::Door::Axle02::RightDevice::IVSS_IsOpen>();
if (rightDoorIsOpen02Device)
{
rightDoorIsOpen02Device->UnregisterIsOpenEvent(dynamic_cast<vss::Vehicle::Chassis::Door::Axle02::RightDevice::IVSS_WriteIsOpen_Event*> (this));
}
rightDoorIsOpen02Device = nullptr;
}
/**
* @brief Set rightDoorIsOpen
* @param[in] value rightDoorIsOpen
*/
void CBasicServiceRearDoorRight::SetIsOpenR2(bool value)
{
m_rightDoorIsOpen02 = value;
std::lock_guard<std::mutex> lock(m_rightDoorIsOpen02MutexCallbacks);
for (auto callback : m_rightDoorIsOpen02Callbacks)
{
callback->SetIsOpenR2(value);
}
}
/**
* @brief Write rightDoorIsOpen
* @param[in] value rightDoorIsOpen
*/
void CBasicServiceRearDoorRight::WriteIsOpen(bool value)
{
SetIsOpenR2(value);
}
/**
* @brief Get rightDoorIsOpen
* @return Returns the rightDoorIsOpen
*/
bool CBasicServiceRearDoorRight::GetIsOpen() const
{
return m_rightDoorIsOpen02;
}
/**
* @brief Register Callback on signal change
* @param[in] callback function
*/
void CBasicServiceRearDoorRight::RegisterOnSignalChangeOfRightDoorIsOpen02(vss::Vehicle::Chassis::Door::Axle02::RightService::IVSS_SetIsOpen_Event* rightDoorIsOpen02Callback)
{
if ( rightDoorIsOpen02Callback)
{
std::lock_guard<std::mutex> lock(m_rightDoorIsOpen02MutexCallbacks);
m_rightDoorIsOpen02Callbacks.insert(rightDoorIsOpen02Callback);
}
}
/**
* @brief Unregister Callback
* @param[in] callback function
*/
void CBasicServiceRearDoorRight::UnregisterOnSignalChangeOfRightDoorIsOpen02(vss::Vehicle::Chassis::Door::Axle02::RightService::IVSS_SetIsOpen_Event* rightDoorIsOpen02Callback)
{
if (rightDoorIsOpen02Callback)
{
std::lock_guard<std::mutex> lock(m_rightDoorIsOpen02MutexCallbacks);
m_rightDoorIsOpen02Callbacks.erase(rightDoorIsOpen02Callback);
}
}
/**
* @brief Lock
* @param[in] value
* @return true on success otherwise false
*/
bool CBasicServiceRearDoorRight::SetLock(bool value)
{
return m_ptrLock->WriteLock(value);
}

95
examples/door_demo_example/bs/bs_rear_door_right/bs_rear_door_right.h Normal file
View File

@@ -0,0 +1,95 @@
/**
* @file bs_rear_door_right.h
* @date 2025-07-11 12:57:18
* File is auto generated from VSS utility.
* VSS Version:1.0.0.1
*/
#ifndef __VSS_GENERATED__BS_REARDOORRIGHT_H_20250711_125718_616__
#define __VSS_GENERATED__BS_REARDOORRIGHT_H_20250711_125718_616__
#include <iostream>
#include <set>
#include <support/component_impl.h>
#include <support/signal_support.h>
#include "vss_vehiclechassisdooraxle02right_bs_rx.h"
#include "vss_vehiclechassisdooraxle02right_vd_tx.h"
#include "vss_vehiclechassisdooraxle02right_bs_tx.h"
/**
* @brief Basic Service Vehicle.Chassis.Door.Axle02.Right
*/
class CBasicServiceRearDoorRight
: public sdv::CSdvObject
, public vss::Vehicle::Chassis::Door::Axle02::RightService::IVSS_GetIsOpen
, public vss::Vehicle::Chassis::Door::Axle02::RightService::IVSS_SetIsOpen_Event
, public vss::Vehicle::Chassis::Door::Axle02::RightDevice::IVSS_WriteIsOpen_Event
, public vss::Vehicle::Chassis::Door::Axle02::RightService::IVSS_SetLock
{
public:
BEGIN_SDV_INTERFACE_MAP()
SDV_INTERFACE_ENTRY(vss::Vehicle::Chassis::Door::Axle02::RightService::IVSS_GetIsOpen)
SDV_INTERFACE_ENTRY(vss::Vehicle::Chassis::Door::Axle02::RightService::IVSS_SetLock)
END_SDV_INTERFACE_MAP()
DECLARE_OBJECT_CLASS_TYPE(sdv::EObjectType::BasicService)
DECLARE_OBJECT_CLASS_NAME("Vehicle.Chassis.Door.Axle02.Right_Service")
/**
* @brief Constructor
*/
CBasicServiceRearDoorRight();
/**
* @brief User-Defined Destructor
*/
~CBasicServiceRearDoorRight();
/**
* @brief Set rightDoorIsOpen signal
* @param[in] value rightDoorIsOpen
*/
void SetIsOpenR2(bool value) override;
/**
* @brief Set rightLatch02 signal
* @param[in] value
* @return true on success otherwise false
*/
bool SetLock(bool value) override;
/**
* @brief Get rightDoorIsOpen
* @return Returns the rightDoorIsOpen
*/
bool GetIsOpen() const override;
/**
* @brief Write rightDoorIsOpen signal
* @param[in] value rightDoorIsOpen
*/
void WriteIsOpen(bool value) override;
/**
* @brief Register CallBack function on signal change
* @param[in] callback function
*/
void RegisterOnSignalChangeOfRightDoorIsOpen02(vss::Vehicle::Chassis::Door::Axle02::RightService::IVSS_SetIsOpen_Event* callback) override;
/**
* @brief Unregister CallBack function on signal change
* @param[in] callback function
*/
void UnregisterOnSignalChangeOfRightDoorIsOpen02(vss::Vehicle::Chassis::Door::Axle02::RightService::IVSS_SetIsOpen_Event* callback) override;
private:
bool m_rightDoorIsOpen02 { 0 };
mutable std::mutex m_rightDoorIsOpen02MutexCallbacks; ///< Mutex protecting m_rightDoorIsOpen02Callbacks
std::set<vss::Vehicle::Chassis::Door::Axle02::RightService::IVSS_SetIsOpen_Event*> m_rightDoorIsOpen02Callbacks; ///< collection of events to be called
vss::Vehicle::Chassis::Door::Axle02::RightDevice::IVSS_WriteLock* m_ptrLock = nullptr;
};
DEFINE_SDV_OBJECT(CBasicServiceRearDoorRight)
#endif // !define __VSS_GENERATED__BS_REARDOORRIGHT_H_20250711_125718_616__