VERSION 0.9.20

Author: jordimariasi2cat

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "v2xflexstack"
-version = "0.9.19"
+version = "0.9.20"
 authors = [
   { name = "Jordi Marias-i-Parella", email = "[email protected]" },
   { name = "Daniel Ulied Guevara", email = "[email protected]" },

src/flexstack/applications/road_hazard_signalling_service/emergency_vehicle_approaching_service.py

@@ -59,7 +59,7 @@ def __init__(
         self.denm_interval = 100
         self.priority_level = PriorityLevel.WARNING
         # Get DENM data to simulate the hazard detection
-        self.detection_time = int((TimeService.time() - 1072915200 + 5) * 1000)
+        self.detection_time = TimeService.timestamp_its()
         self.event_position = {
             "latitude": 900000001,
             "longitude": 1800000001,

src/flexstack/facilities/ca_basic_service/cam_ldm_adaptation.py

@@ -52,7 +52,7 @@ def add_provider_data_to_ldm(self, cam: dict) -> None:
         timestamp = TimestampIts()
         data = AddDataProviderReq(
             application_id=CAM,
-            time_stamp=timestamp,
+            timestamp=timestamp,
             location=Location.location_builder_circle(
                 latitude=cam["cam"]["camParameters"]["basicContainer"][
                     "referencePosition"

src/flexstack/facilities/ca_basic_service/cam_transmission_management.py

@@ -16,6 +16,7 @@
     CommunicationProfile,
     TrafficClass,
 )
+from ...utils.time_service import ITS_EPOCH_MS, ELAPSED_MILLISECONDS
 from .cam_ldm_adaptation import CABasicServiceLDM
 
 T_GEN_CAM_MIN = 100  # T_GenCamMin [in ms]
@@ -111,25 +112,27 @@ class GenerationDeltaTime:
     def __init__(self) -> None:
         self.msec = 0
 
-    def set_in_normal_timestamp(self, timestamp_seconds: float) -> None:
+    def set_in_normal_timestamp(self, utc_timestamp_in_seconds: float) -> None:
         """
-        Set the Generation Delta Time in normal timestamp. [Seconds]
+        Set the Generation Delta Time in normal UTC timestamp. [Seconds]
 
         Parameters
         ----------
         timestamp : int
             Timestamp in milliseconds.
         """
-        self.msec = (timestamp_seconds*1000 - 1072915200000 + 5000) % 65536
+        self.msec = (
+            utc_timestamp_in_seconds * 1000 - ITS_EPOCH_MS + ELAPSED_MILLISECONDS
+        ) % 65536
 
-    def as_timestamp_in_certain_point(self, point_in_time_millis: int) -> float:
+    def as_timestamp_in_certain_point(self, utc_timestamp_in_millis: int) -> float:
         """
         Returns the generation delta time as timestamp as it would be if received at
         certain point in time.
 
         Parameters
         ----------
-        point_in_time : int
+        utc_timestamp_in_millis : int
             Timestamp in milliseconds
 
         Returns
@@ -138,12 +141,12 @@ def as_timestamp_in_certain_point(self, point_in_time_millis: int) -> float:
             Timestamp of the generation delta time in milliseconds
         """
         number_of_cycles = trunc(
-            (point_in_time_millis - 1072915200000 + 5000) / 65536)
+            (utc_timestamp_in_millis - ITS_EPOCH_MS + ELAPSED_MILLISECONDS) / 65536)
         transformed_timestamp = self.msec + 65536 * \
-            number_of_cycles + 1072915200000 - 5000
-        if transformed_timestamp <= point_in_time_millis:
+            number_of_cycles + ITS_EPOCH_MS - ELAPSED_MILLISECONDS
+        if transformed_timestamp <= utc_timestamp_in_millis:
             return transformed_timestamp
-        return self.msec + 65536 * (number_of_cycles - 1) + 1072915200000 - 5000
+        return self.msec + 65536 * (number_of_cycles - 1) + ITS_EPOCH_MS - ELAPSED_MILLISECONDS
 
     def __gt__(self, other: object) -> bool:
         """

src/flexstack/facilities/decentralized_environmental_notification_service/denm_reception_management.py

@@ -68,7 +68,7 @@ def feed_ldm(self, denm: dict) -> None:
         if self.ldm_facility is not None:
             data = AddDataProviderReq(
                 application_id=DENM,
-                time_stamp=TimestampIts.initialize_with_timestamp_its(denm["denm"]["management"]["detectionTime"]),
+                timestamp=TimestampIts.initialize_with_timestamp_its(denm["denm"]["management"]["detectionTime"]),
                 location=Location.location_builder_circle(
                     latitude=denm["denm"]["management"]["eventPosition"]["latitude"],
                     longitude=denm["denm"]["management"]["eventPosition"]["longitude"],

src/flexstack/facilities/decentralized_environmental_notification_service/denm_transmission_management.py

@@ -89,7 +89,7 @@ def fullfill_with_denrequest(self, request: DENRequest) -> None:
         # Add Management Container
         self.denm["denm"]["management"]["detectionTime"] = request.detection_time
         self.denm["denm"]["management"]["referenceTime"] = int(
-            (TimeService.time() - 1072915200 + 5) * 1000
+            TimeService.timestamp_its()
         )
         self.denm["denm"]["management"]["TransmissionInterval"] = request.denm_interval
 
@@ -147,7 +147,7 @@ def fullfill_with_collision_risk_warning(self, request: DENRequest) -> None:
         # Add Management Container
         self.denm["denm"]["management"]["detectionTime"] = request.detection_time
         self.denm["denm"]["management"]["referenceTime"] = int(
-            (TimeService.time() - 1072915200 + 5) % 65536
+            TimeService.timestamp_its()
         )
         self.denm["denm"]["management"]["TransmissionInterval"] = request.denm_interval
 

src/flexstack/facilities/local_dynamic_map/ldm_classes.py

@@ -17,12 +17,11 @@
 """
 
 from __future__ import annotations
-from ...utils.time_service import TimeService
+from ...utils.time_service import TimeService, ITS_EPOCH, ELAPSED_SECONDS
 import math
 
 from .ldm_constants import (
     EATH_RADIUS,
-    REFERENCE_ITS_TIMESTAMP,
     DATA_OBJECT_TYPE_ID,
     DENM,
     CAM,
@@ -53,23 +52,25 @@ class TimestampIts:
     TimestamptITS class to handle timestamps. Timestamps are expressed in ETSI Timestamp format.
     """
 
-    def __init__(self, timestamp: int = None) -> None:
+    def __init__(self, utc_timestamp_seconds: int = None) -> None:
         """
         Initializes the TimestampIts class.
 
         Parameters
         ----------
-        timestamp : int
-            The timestamp in seconds since the epoch (UTC). If None, it will be set to the current time.
+        utc_timestamp_seconds : int
+            The UTC timestamp in seconds since the epoch (UTC).
+            If None, it will be set to the current UTC timestamp.
         """
-        self.timestamp = None
-        if timestamp:
+        self.timestamp = 0
+        if utc_timestamp_seconds:
             self.timestamp = self.__transform_utc_seconds_timestamp_to_timestamp_its(
-                timestamp)
+                utc_timestamp_seconds)
         else:
             self.timestamp = self.__transform_utc_seconds_timestamp_to_timestamp_its(
                 int(TimeService.time()))
 
+    @staticmethod
     def initialize_with_timestamp_its(timestamp_its: int) -> TimestampIts:
         """
         Initializes the TimestampIts class with a given ETSI ITS timestamp.
@@ -84,25 +85,25 @@ def initialize_with_timestamp_its(timestamp_its: int) -> TimestampIts:
         TimestampIts
             An instance of the TimestampIts class.
         """
-        to_return: TimestampIts = TimestampIts(REFERENCE_ITS_TIMESTAMP+5)
+        to_return: TimestampIts = TimestampIts(ITS_EPOCH + ELAPSED_SECONDS)
         to_return.timestamp = timestamp_its
         return to_return
 
-    def __transform_utc_seconds_timestamp_to_timestamp_its(self, timestamp: int) -> int:
+    def __transform_utc_seconds_timestamp_to_timestamp_its(self, utc_timestamp_seconds: int) -> int:
         """
         Method to transform a UTC timestamp to a ETSI ITS timestamp.
 
         Parameters
         ----------
-        timestamp : int
-            UTC timestamp to be converted.
+        utc_timestamp_seconds : int
+            UTC timestamp in seconds to be converted.
 
         Returns
         -------
         int
             Converted ITS timestamp.
         """
-        return (timestamp - REFERENCE_ITS_TIMESTAMP + 5) * 1000  # The 5 correspond to leap seconds
+        return int((utc_timestamp_seconds - ITS_EPOCH + ELAPSED_SECONDS) * 1000)
 
     def __add__(self, other: TimestampIts) -> TimestampIts:
         """
@@ -248,7 +249,7 @@ def to_etsi_its(self) -> int:
         int
             Converted timestamp in ETSI ITS format.
         """
-        return ((self.time - REFERENCE_ITS_TIMESTAMP)) * 1000
+        return int(((self.time - ITS_EPOCH)) * 1000)
 
 
 class DataContainer:
@@ -977,21 +978,21 @@ class AddDataProviderReq:
     def __init__(
         self,
         application_id: int,
-        time_stamp: TimestampIts,
+        timestamp: TimestampIts,
         location: Location,
         data_object: dict,
         time_validity: TimeValidity,
     ) -> None:
         self.application_id = application_id
-        self.time_stamp = time_stamp
+        self.timestamp = timestamp
         self.location = location
         self.data_object = data_object
         self.time_validity = time_validity
 
     def __iter__(self):
         # pylint: disable=line-too-long
         yield "application_id", self.application_id
-        yield "timestamp", self.time_stamp.timestamp
+        yield "timestamp", self.timestamp.timestamp
         yield "location", {
             "referencePosition": {
                 "latitude": self.location.reference_position.latitude,
@@ -1058,7 +1059,7 @@ def to_dict(self) -> dict:
         # pylint: disable=line-too-long
         data = {
             "application_id": self.application_id,
-            "timestamp": self.time_stamp.timestamp,
+            "timestamp": self.timestamp.timestamp,
             "location": {
                 "referencePosition": {
                     "latitude": self.location.reference_position.latitude,
@@ -1127,7 +1128,8 @@ def from_dict(data: dict) -> "AddDataProviderReq":
             An instance of the AddDataProviderReq class.
         """
         application_id = data.get("application_id")
-        time_stamp = TimestampIts.initialize_with_timestamp_its(data.get("timestamp"))
+        time_stamp = TimestampIts.initialize_with_timestamp_its(
+            data.get("timestamp"))
         location_data = data.get("location")
         data_object = data.get("dataObject")
         time_validity = TimeValidity(data.get("timeValidity"))
@@ -1193,7 +1195,7 @@ def from_dict(data: dict) -> "AddDataProviderReq":
 
         return AddDataProviderReq(
             application_id=application_id,
-            time_stamp=time_stamp,
+            timestamp=time_stamp,
             location=location,
             data_object=data_object,
             time_validity=time_validity,

src/flexstack/facilities/local_dynamic_map/ldm_constants.py

@@ -5,7 +5,6 @@
 library_folder = os.path.dirname(os.path.abspath(__file__))
 file_path = os.path.join(library_folder, "data_containers.json")
 LDM_STORAGE_PATH = file_path
-REFERENCE_ITS_TIMESTAMP = 1072911600
 MAINTENANCE_AREA_MAX_ALTITUDE_DIFFERENCE = 15
 EATH_RADIUS = 6371000.0
 

src/flexstack/facilities/vru_awareness_service/vam_ldm_adaptation.py

@@ -57,7 +57,7 @@ def add_provider_data_to_ldm(self, vam: dict) -> None:
         timestamp = TimestampIts()
         data = AddDataProviderReq(
             application_id=VAM,
-            time_stamp=timestamp,
+            timestamp=timestamp,
             location=Location.location_builder_circle(
                 latitude=vam["vam"]["vamParameters"]["basicContainer"]["referencePosition"]["latitude"],
                 longitude=vam["vam"]["vamParameters"]["basicContainer"]["referencePosition"]["longitude"],

src/flexstack/geonet/position_vector.py

@@ -1,5 +1,5 @@
 from dateutil import parser
-
+from ..utils.time_service import ITS_EPOCH, ITS_EPOCH_MS, ELAPSED_SECONDS, ELAPSED_MILLISECONDS
 from .exceptions import DecodeError
 from .gn_address import GNAddress
 
@@ -26,27 +26,27 @@ class TST:
     def __init__(self) -> None:
         self.msec = 0
 
-    def set_in_normal_timestamp_seconds(self, timestamp: int) -> None:
+    def set_in_normal_timestamp_seconds(self, utc_timestamp_seconds: int) -> None:
         """
         Set the timestamp in normal timestamp format.
 
         Parameters
         ----------
-        timestamp : int
-            Timestamp in normal timestamp format.
+        utc_timestamp_seconds : int
+            Timestamp in normal UTC timestamp format.
         """
-        self.msec = ((timestamp-1072911600+5)*1000) % 2**32
+        self.msec = ((utc_timestamp_seconds-ITS_EPOCH+ELAPSED_SECONDS)*1000) % 2**32
 
-    def set_in_normal_timestamp_milliseconds(self, timestamp: int) -> None:
+    def set_in_normal_timestamp_milliseconds(self, utc_timestamp_milliseconds: int) -> None:
         """
         Set the timestamp in normal timestamp format.
 
         Parameters
         ----------
-        timestamp : int
-            Timestamp in normal timestamp format.
+        utc_timestamp_milliseconds : int
+            Timestamp in normal UTC timestamp format.
         """
-        self.msec = (timestamp-1072911600000 + 5000) % 2**32
+        self.msec = (utc_timestamp_milliseconds-ITS_EPOCH_MS+ELAPSED_MILLISECONDS) % 2**32
 
     def encode(self) -> int:
         """