Add first test application using vsomeip

Author: chrizog

.gitignore

@@ -1,4 +1,7 @@
 .vscode/
 dist/
 someipy.egg-info/
-__pycache__
+__pycache__
+
+test_apps/build
+test_apps/install

example_apps/send_events_udp.py

@@ -2,10 +2,8 @@
 import ipaddress
 import logging
 
-from someipy import TransportLayerProtocol
-from someipy.service import ServiceBuilder, EventGroup
+from someipy import TransportLayerProtocol, ServiceBuilder, EventGroup, construct_server_service_instance
 from someipy.service_discovery import construct_service_discovery
-from someipy.server_service_instance import construct_server_service_instance
 from someipy.logging import set_someipy_log_level
 from someipy.serialization import Uint8, Uint64, Float32
 from temperature_msg import TemparatureMsg
@@ -83,7 +81,7 @@ async def main():
     try:
         # Either cyclically send events in an endless loop..
         while True:
-            await asyncio.sleep(5)
+            await asyncio.sleep(1)
             tmp_msg.timestamp = Uint64(tmp_msg.timestamp.value + 1)
             payload = tmp_msg.serialize()
             service_instance_temperature.send_event(

src/someipy/__init__.py

@@ -1,2 +1,3 @@
 from ._internal.someip_sd_header import TransportLayerProtocol
 from .server_service_instance import ServerServiceInstance, construct_server_service_instance
+from .service import Service, ServiceBuilder, EventGroup

src/someipy/logging.py

@@ -1,6 +1,6 @@
 import logging
 
-_log_level = logging.INFO
+_log_level = logging.DEBUG
 
 
 def set_someipy_log_level(log_level: int):

src/someipy/server_service_instance.py

@@ -1,9 +1,9 @@
 import asyncio
 from typing import Tuple
 
-from someipy._internal.tcp_client_manager import TcpClientManager, TcpClientProtocol
 from someipy.service import Service
 
+from someipy._internal.tcp_client_manager import TcpClientManager, TcpClientProtocol
 from someipy._internal.message_types import MessageType, ReturnCode
 from someipy._internal.someip_sd_builder import (
     build_subscribe_eventgroup_ack_entry,
@@ -24,7 +24,6 @@
     ServiceDiscoveryObserver,
     ServiceDiscoverySender,
 )
-
 from someipy._internal.simple_timer import SimplePeriodicTimer
 from someipy._internal.utils import (
     create_udp_socket,
@@ -43,17 +42,26 @@
 
 
 class ServerServiceInstance(ServiceDiscoveryObserver):
-    service: Service
-    instance_id: int
-    endpoint: EndpointType
-    protocol: TransportLayerProtocol
-    someip_endpoint: SomeipEndpoint
-    ttl: int
-    sd_sender: ServiceDiscoverySender
-    cyclic_offer_delay_ms: int
-
-    subscribers: Subscribers
-    offer_timer: SimplePeriodicTimer
+    """AI is creating summary for ServerServiceInstance
+
+    Args:
+        ServiceDiscoveryObserver ([type]): [description]
+
+    Returns:
+        [type]: [description]
+    """
+    
+    _service: Service
+    _instance_id: int
+    _endpoint: EndpointType
+    _protocol: TransportLayerProtocol
+    _someip_endpoint: SomeipEndpoint
+    _ttl: int
+    _sd_sender: ServiceDiscoverySender
+    _cyclic_offer_delay_ms: int
+
+    _subscribers: Subscribers
+    _offer_timer: SimplePeriodicTimer
 
     def __init__(
         self,
@@ -66,24 +74,24 @@ def __init__(
         sd_sender=None,
         cyclic_offer_delay_ms=2000,
     ):
-        self.service = service
-        self.instance_id = instance_id
-        self.endpoint = endpoint
-        self.protocol = protocol
-        self.someip_endpoint = someip_endpoint
-        self.ttl = ttl
-        self.sd_sender = sd_sender
-        self.cyclic_offer_delay_ms = cyclic_offer_delay_ms
-
-        self.subscribers = Subscribers()
-        self.offer_timer = None
+        self._service = service
+        self._instance_id = instance_id
+        self._endpoint = endpoint
+        self._protocol = protocol
+        self._someip_endpoint = someip_endpoint
+        self._ttl = ttl
+        self._sd_sender = sd_sender
+        self._cyclic_offer_delay_ms = cyclic_offer_delay_ms
+
+        self._subscribers = Subscribers()
+        self._offer_timer = None
 
     def send_event(self, event_group_id: int, event_id: int, payload: bytes) -> None:
-        self.subscribers.update()
+        self._subscribers.update()
 
         length = 8 + len(payload)
         someip_header = SomeIpHeader(
-            service_id=self.service.id,
+            service_id=self._service.id,
             method_id=event_id,
             length=length,
             client_id=0x00,  # TODO
@@ -93,16 +101,13 @@ def send_event(self, event_group_id: int, event_id: int, payload: bytes) -> None
             message_type=MessageType.NOTIFICATION.value,
             return_code=0x00,
         )
-        _logger.debug(
-            f"Send event for instance 0x{self.instance_id:04X}, service: 0x{self.service.id:04X}"
-        )
 
-        for sub in self.subscribers.subscribers:
+        for sub in self._subscribers.subscribers:
             if sub.eventgroup_id == event_group_id:
                 _logger.debug(
-                    f"Send event for instance 0x{self.instance_id:04X}, service: 0x{self.service.id:04X} to {sub.endpoint[0]}:{sub.endpoint[1]}"
+                    f"Send event for instance 0x{self._instance_id:04X}, service: 0x{self._service.id:04X} to {sub.endpoint[0]}:{sub.endpoint[1]}"
                 )
-                self.someip_endpoint.sendto(
+                self._someip_endpoint.sendto(
                     someip_header.to_buffer() + payload,
                     endpoint_to_str_int_tuple(sub.endpoint),
                 )
@@ -148,12 +153,12 @@ def send_response():
 
             if not success:
                 _logger.debug(
-                    f"Return ERROR message type to {addr} for service and instance ID: 0x{self.service_id:04X} / 0x{self.instance_id:04X}"
+                    f"Return ERROR message type to {addr} for service and instance ID: 0x{self.service_id:04X} / 0x{self._instance_id:04X}"
                 )
                 header_to_return.message_type = MessageType.ERROR.value
             else:
                 _logger.debug(
-                    f"Return RESPONSE message type to {addr} for service and instance ID: 0x{self.service_id:04X} / 0x{self.instance_id:04X}"
+                    f"Return RESPONSE message type to {addr} for service and instance ID: 0x{self.service_id:04X} / 0x{self._instance_id:04X}"
                 )
                 header_to_return.message_type = MessageType.RESPONSE.value
 
@@ -182,17 +187,17 @@ def subscribe_eventgroup_update(
         # an Eventgroup of a Service Instance.
         # TODO: enable major version check
         if (
-            sd_event_group.sd_entry.service_id == self.service.id
-            and sd_event_group.sd_entry.instance_id == self.instance_id
-            and sd_event_group.eventgroup_id in self.service.eventgroupids
+            sd_event_group.sd_entry.service_id == self._service.id
+            and sd_event_group.sd_entry.instance_id == self._instance_id
+            and sd_event_group.eventgroup_id in self._service.eventgroupids
         ):
             (
                 session_id,
                 reboot_flag,
-            ) = self.sd_sender.get_unicast_session_handler().update_session()
+            ) = self._sd_sender.get_unicast_session_handler().update_session()
 
             _logger.debug(
-                f"Send Subscribe ACK for instance 0x{self.instance_id:04X}, service: 0x{self.service.id:04X}, TTL: {sd_event_group.sd_entry.ttl}"
+                f"Send Subscribe ACK for instance 0x{self._instance_id:04X}, service: 0x{self._service.id:04X}, TTL: {sd_event_group.sd_entry.ttl}"
             )
             ack_entry = build_subscribe_eventgroup_ack_entry(
                 service_id=sd_event_group.sd_entry.service_id,
@@ -205,12 +210,12 @@ def subscribe_eventgroup_update(
                 entry=ack_entry, session_id=session_id, reboot_flag=reboot_flag
             )
 
-            self.sd_sender.send_unicast(
+            self._sd_sender.send_unicast(
                 buffer=header_output.to_buffer(),
                 dest_ip=ipv4_endpoint_option.ipv4_address,
             )
 
-            self.subscribers.add_subscriber(
+            self._subscribers.add_subscriber(
                 EventGroupSubscriber(
                     eventgroup_id=sd_event_group.eventgroup_id,
                     endpoint=(
@@ -230,40 +235,40 @@ def offer_timer_callback(self):
         (
             session_id,
             reboot_flag,
-        ) = self.sd_sender.get_multicast_session_handler().update_session()
+        ) = self._sd_sender.get_multicast_session_handler().update_session()
 
         _logger.debug(
-            f"Offer service for instance 0x{self.instance_id:04X}, service: 0x{self.service.id:04X}, TTL: {self.ttl}, version: {self.service.major_version}.{self.service.minor_version}, session ID: {session_id}"
+            f"Offer service for instance 0x{self._instance_id:04X}, service: 0x{self._service.id:04X}, TTL: {self._ttl}, version: {self._service.major_version}.{self._service.minor_version}, session ID: {session_id}"
         )
 
         service_to_offer = SdService(
-            service_id=self.service.id,
-            instance_id=self.instance_id,
+            service_id=self._service.id,
+            instance_id=self._instance_id,
             major_version=1,
             minor_version=0,
-            ttl=self.ttl,
-            endpoint=self.endpoint,
-            protocol=self.protocol,
+            ttl=self._ttl,
+            endpoint=self._endpoint,
+            protocol=self._protocol,
         )
         sd_header = build_offer_service_sd_header(
             service_to_offer, session_id, reboot_flag
         )
-        self.sd_sender.send_multicast(sd_header.to_buffer())
+        self._sd_sender.send_multicast(sd_header.to_buffer())
 
     def start_offer(self):
-        self.offer_timer = SimplePeriodicTimer(
-            self.cyclic_offer_delay_ms / 1000.0, self.offer_timer_callback
+        self._offer_timer = SimplePeriodicTimer(
+            self._cyclic_offer_delay_ms / 1000.0, self.offer_timer_callback
         )
-        self.offer_timer.start()
+        self._offer_timer.start()
 
     async def stop_offer(self):
         _logger.debug(
-            f"Stop offer for instance 0x{self.instance_id:04X}, service: 0x{self.service.id:04X}"
+            f"Stop offer for instance 0x{self._instance_id:04X}, service: 0x{self._service.id:04X}"
         )
 
-        if self.offer_timer is not None:
-            self.offer_timer.stop()
-            await self.offer_timer.task
+        if self._offer_timer is not None:
+            self._offer_timer.stop()
+            await self._offer_timer.task
         # TODO: send out a stop offer sd message before stopping the timer
 
 

test_apps/CMakeLists.txt

@@ -0,0 +1,25 @@
+cmake_minimum_required (VERSION 3.13)
+
+project(someipy_test_apps)
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14")
+
+find_package(vsomeip3 CONFIG REQUIRED)
+
+# TODO: Common function for building a single test target
+function(add_test_app_target)
+
+
+    
+endfunction(add_test_app_target)
+
+
+add_executable(send_events_udp send_events_udp/send_events_udp.cpp)
+target_link_libraries(send_events_udp ${VSOMEIP_LIBRARIES} pthread)
+
+set(CMAKE_INSTALL_PREFIX "${CMAKE_SOURCE_DIR}/install")
+
+install(TARGETS send_events_udp
+    RUNTIME DESTINATION send_events_udp)
+
+file(GLOB JSON_FILES "${CMAKE_SOURCE_DIR}/send_events_udp/*.json" "${CMAKE_SOURCE_DIR}/send_events_udp/*.sh")
+install(FILES ${JSON_FILES} DESTINATION send_events_udp)

test_apps/README.md

@@ -0,0 +1,39 @@
+## Build Test Applications using CMake
+
+```bash
+rm -rf build install && mkdir -p build && cd build && cmake .. && make && make install  && cd ..
+```
+
+## Setup Python Pip Package from Source
+
+```bash
+python3.12 -m pip install -e .
+```
+
+## Test Procedure
+
+### Network Setup Linux
+
+```bash
+sudo ip addr add 127.0.0.2/8 dev lo
+sudo ip addr add 224.224.224.245 dev lo autojoin
+```
+
+### 1. send_events_udp
+
+Open two terminals (one for Python someipy example app, one for test app)
+
+Start apps:
+
+```bash
+python3.12 send_events_udp.py
+bash ./install/send_events_udp/start_app.sh
+```
+
+Expected in test app:
+- Receive event with frequency 1Hz
+- Service ID: 0x1234
+- Instance ID: 0x5678
+- Eventgroup ID: 0x0321
+- Event ID: 0x0123
+- SD Offer is sent with 0.5Hz