diff --git a/README.md b/README.md
old mode 100644
new mode 100755
index bd8f951..d6bf84b
--- a/README.md
+++ b/README.md
@@ -25,6 +25,7 @@ python -m pip install https://codeload.github.com/open-stage/python-psn/zip/refs
 
 ## Usage
 
+### Receiving PSN data
 ```python
 import pypsn
 
@@ -45,15 +46,54 @@ receiver.start()  # start the receiving thread
 
 receiver.stop() # stop receiving
 
+```
+
+### Senfing PSN data
+```python
+import pypsn
+
+# create a psn_info object with appropriate data
+psn_info = pypsn.PsnInfoPacket(
+    info=pypsn.PsnInfo(
+        timestamp=1312,
+        version_high=2,
+        version_low=0,
+        frame_id=1,
+        packet_count=1,
+    ),
+    name="system_name_001",
+    trackers=(
+        [
+            pypsn.PsnTrackerInfo(
+                tracker_id=i,
+                tracker_name="tracker_" + str(i),
+            )
+            for i in range(0, 8))
+        ]
+    ),
+)
+
+# convert the object to a byte string
+psn_info_packet_bytes = pypsn.prepare_psn_info_packet_bytes(psn_info)
+
+# send the PSN info via multicast
+pypsn.send_psn_packet(
+    psn_packet=psn_info_packet_bytes,
+    mcast_ip="236.10.10.10",
+    ip_addr="192.168.1.42",
+    mcast_port=56565,
+)
+
 ```
 See examples folder for some more examples.
 
 ## Development, status
 
 - Supporting PSN V2
-- Parsing and sending (via [Multicast Expert](https://github.com/multiplemonomials/multicast_expert))
+- Parsing and sending (via [Multicast Expert](https://github.com/multiplemonomials/multicast_expert)) or via Unicast
 - Using threading module
 - Linux (Rpi OS incl.), Windows and macOS tested
+- PSN messages recognized by GrandMa3 2.1
 - Typed, no-strict
 - Initial pytest testing provided together with CI/CD setup
 
diff --git a/examples/simple_send_and_receive/send_psn.py b/examples/simple_send_and_receive/send_psn.py
index 8cef861..37aab36 100755
--- a/examples/simple_send_and_receive/send_psn.py
+++ b/examples/simple_send_and_receive/send_psn.py
@@ -1,19 +1,49 @@
 #! /bin/env python3
 """
-Usage: python send_psn.py 192.168.1.4 <--- change IP address
+Usage:
+
+multicast: python send_psn.py 1 192.168.1.4 236.10.10.10
+unicast: python send_psn.py 1 192.168.1.4
+
+Args:
+- number of trackers to generate
+- local IP adress
+- multricast adress (opt)
+
+Variables mapping for GrandMa3 users:
+
+- pos.xyz -> Position X Y Z
+- speed.xyz -> Speed X Y Z
+- ori.xyz -> Rot X Y Z
+- accel.xyz -> None
+- trgtpos.xyz -> None
 
 """
 
 import sys
+import time
 import pypsn
 
+try:
+    tracker_num = int(sys.argv[1])
+    ip_addr = sys.argv[2]
+    mcast_ip = None
+
+    if sys.argv[3]:
+        mcast_ip = sys.argv[3]
+
+except Exception as e:
+    print("Args: tracker_num ip_addr mcast_ip (opt).")
+    print(e)
+
+start_time_us = time.time_ns() // 1000
 
 psn_info = pypsn.PsnInfoPacket(
     info=pypsn.PsnInfo(
-        timestamp=1312,
+        timestamp=start_time_us,
         version_high=2,
         version_low=0,
-        frame_id=56,
+        frame_id=1,
         packet_count=1,
     ),
     name="system_name_001",
@@ -23,13 +53,19 @@
                 tracker_id=i,
                 tracker_name="tracker_" + str(i),
             )
-            for i in range(0, 7)
+            for i in range(0, tracker_num)
         ]
     ),
 )
 
 psn_data = pypsn.PsnDataPacket(
-    info=psn_info.info,
+    info=pypsn.PsnInfo(
+        timestamp=start_time_us,
+        version_high=2,
+        version_low=0,
+        frame_id=1,
+        packet_count=1,
+    ),
     trackers=(
         [
             pypsn.PsnTracker(
@@ -50,6 +86,7 @@
                     y=0.0,
                     z=0.0,
                 ),
+                status=0.5,
                 accel=pypsn.PsnVector3(
                     x=0.0,
                     y=0.0,
@@ -60,15 +97,14 @@
                     y=0.0,
                     z=0.0,
                 ),
-                status=0,
-                timestamp=psn_info.info.timestamp,
+                timestamp=start_time_us,
             )
             for tracker in psn_info.trackers
         ]
     ),
 )
 
-print("\n--- PSN infos to be sent ---")
+print("\n--- PSN infos to be sent at 1Hz ---")
 print("system name: " + psn_info.name)
 print("timestamp: " + str(psn_info.info.timestamp))
 print("version_high: " + str(psn_info.info.version_high))
@@ -79,7 +115,7 @@
 for tracker in psn_info.trackers:
     print(str(tracker.tracker_id) + ": " + str(tracker.tracker_name))
 
-print("\n--- PSN data to be sent ---")
+print("\n--- PSN data to be sent at 60Hz ---")
 print("timestamp: " + str(psn_data.info.timestamp))
 print("version_high: " + str(psn_data.info.version_high))
 print("version_low: " + str(psn_data.info.version_low))
@@ -108,19 +144,48 @@
         + str(tracker.timestamp)
     )
 
-psn_info_packet_bytes = pypsn.prepare_psn_info_packet_bytes(psn_info)
-psn_data_packet_bytes = pypsn.prepare_psn_data_packet_bytes(psn_data)
+print("\n--- Sendin PSN data in loop ---")
+counter = 0.0
 
-pypsn.send_psn_packet(
-    psn_packet=psn_info_packet_bytes,
-    mcast_ip="236.10.10.10",
-    ip_addr=sys.argv[1],
-    mcast_port=56565,
-)
+while True:
+    time.sleep(1 / 60)
+    elapsed_time_us = time.time_ns() // 1000 - start_time_us
 
-pypsn.send_psn_packet(
-    psn_packet=psn_data_packet_bytes,
-    mcast_ip="236.10.10.10",
-    ip_addr=sys.argv[1],
-    mcast_port=56565,
-)
+    if counter < 6.0:
+        counter += 0.1
+    else:
+        counter = 0.0
+
+        psn_info.info.timestamp = elapsed_time_us
+        psn_info_packet_bytes = pypsn.prepare_psn_info_packet_bytes(psn_info)
+
+        pypsn.send_psn_packet(
+            psn_packet=psn_info_packet_bytes,
+            mcast_ip=mcast_ip,
+            ip_addr=ip_addr,
+            port=56565,
+        )
+
+    psn_data.info.timestamp = elapsed_time_us
+
+    if psn_data.info.frame_id < 255:
+        psn_data.info.frame_id += 1
+    else:
+        psn_data.info.frame_id = 0
+
+    for tracker in psn_data.trackers:
+        tracker.timestamp = elapsed_time_us
+        tracker.pos.x = counter
+        tracker.speed.x = counter
+        tracker.ori.x = counter
+        tracker.accel.x = counter
+        tracker.trgtpos.x = counter
+
+    psn_data_packet_bytes = pypsn.prepare_psn_data_packet_bytes(psn_data)
+
+    pypsn.send_psn_packet(
+        psn_packet=psn_data_packet_bytes,
+        mcast_ip=mcast_ip,
+        ip_addr=ip_addr,
+        port=56565,
+    )
diff --git a/pypsn/__init__.py b/pypsn/__init__.py
index ad94867..7d6af1b 100755
--- a/pypsn/__init__.py
+++ b/pypsn/__init__.py
@@ -15,7 +15,9 @@
 
 
 class PsnVector3:
-    """_summary_"""
+    """
+    PSN vector variable structure
+    """
 
     def __init__(self, x: float, y: float, z: float):
         self.x = x
@@ -33,7 +35,9 @@ def __iter__(self):
 
 
 class PsnInfo:
-    """_summary_"""
+    """
+    PSN info packet variable structure
+    """
 
     def __init__(
         self,
@@ -51,7 +55,9 @@ def __init__(
 
 
 class PsnTrackerInfo:
-    """_summary_"""
+    """
+    PSN tracker info variable structure
+    """
 
     def __init__(self, tracker_id: int, tracker_name: str):
         self.tracker_id = tracker_id
@@ -59,7 +65,9 @@ def __init__(self, tracker_id: int, tracker_name: str):
 
 
 class PsnTracker:
-    """_summary_"""
+    """
+    PSN tracker data variable structure
+    """
 
     def __init__(
         self,
@@ -85,7 +93,9 @@ def __init__(
 
 
 class PsnDataPacket:
-    """_summary_"""
+    """
+    PSN data packet variable structure
+    """
 
     def __init__(self, info: "PsnInfo", trackers: List["PsnTracker"]):
         self.info = info
@@ -93,7 +103,9 @@ def __init__(self, info: "PsnInfo", trackers: List["PsnTracker"]):
 
 
 class PsnInfoPacket:
-    """_summary_"""
+    """
+    PSN info packet variable structure
+    """
 
     def __init__(
         self,
@@ -107,10 +119,8 @@ def __init__(
 
 
 class PsnV1Chunk(IntEnum):
-    """_summary_
-
-    Args:
-        IntEnum (_type_): _description_
+    """
+    V1 main PSN ID
     """
 
     PSN_V1_INFO_PACKET = 0x503C
@@ -118,10 +128,8 @@ class PsnV1Chunk(IntEnum):
 
 
 class PsnV2Chunck(IntEnum):
-    """_summary_
-
-    Args:
-        IntEnum (_type_): _description_
+    """
+    V2 main PSN ID
     """
 
     PSN_INFO_PACKET = 0x6756
@@ -129,10 +137,8 @@ class PsnV2Chunck(IntEnum):
 
 
 class PsnInfoChunk(IntEnum):
-    """_summary_
-
-    Args:
-        IntEnum (_type_): _description_
+    """
+    PSN ID for info packet
     """
 
     PSN_INFO_PACKET_HEADER = 0x0000
@@ -141,10 +147,8 @@ class PsnInfoChunk(IntEnum):
 
 
 class PsnDataChunk(IntEnum):
-    """_summary_
-
-    Args:
-        IntEnum (_type_): _description_
+    """
+    PSN ID for data packet
     """
 
     PSN_DATA_PACKET_HEADER = 0x0000
@@ -152,20 +156,16 @@ class PsnDataChunk(IntEnum):
 
 
 class PasnTrackerListChunk(IntEnum):
-    """_summary_
-
-    Args:
-        IntEnum (_type_): _description_
+    """
+    PSN ID for trackers name
     """
 
     PSN_INFO_TRACKER_NAME = 0x0000
 
 
 class PsnTrackerChunk(IntEnum):
-    """_summary_
-
-    Args:
-        IntEnum (_type_): _description_
+    """
+    PSN ID for trackers coordinates
     """
 
     PSN_DATA_TRACKER_POS = 0x0000
@@ -176,10 +176,8 @@ class PsnTrackerChunk(IntEnum):
 
 
 class PsnTrackerChunkInfo(IntEnum):
-    """_summary_
-
-    Args:
-        IntEnum (_type_): _description_
+    """
+    PSN ID for trackers status and timestamp
     """
 
     PSN_DATA_TRACKER_STATUS = 0x0003
@@ -187,15 +185,16 @@ class PsnTrackerChunkInfo(IntEnum):
 
 
 def join_multicast_windows(mcast_grp, mcast_port, if_ip):
-    """_summary_
+    """
+        Join multicast on Windows
 
     Args:
-        mcast_grp (_type_): _description_
-        mcast_port (_type_): _description_
-        if_ip (_type_): _description_
+        mcast_grp (str): multicast ip
+        mcast_port (str): multicast port
+        if_ip (str): iface ip
 
     Returns:
-        _type_: _description_
+        socket
     """
     sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
     sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
@@ -209,15 +208,16 @@ def join_multicast_windows(mcast_grp, mcast_port, if_ip):
 
 
 def join_multicast_posix(mcast_grp, mcast_port, if_ip):
-    """_summary_
+    """
+        Join multicast on posix OS
 
     Args:
-        mcast_grp (_type_): _description_
-        mcast_port (_type_): _description_
-        if_ip (_type_): _description_
+        mcast_grp (str): multicast ip
+        mcast_port (str): multicast port
+        if_ip (str): iface ip
 
     Returns:
-        _type_: _description_
+        socket
     """
     sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP)
     try:
@@ -238,10 +238,11 @@ def join_multicast_posix(mcast_grp, mcast_port, if_ip):
 
 
 def determine_os():
-    """_summary_
+    """
+        Get local OS
 
     Returns:
-        _type_: _description_
+        OS name
     """
     if os.name == "nt":
         return str(os.name)
@@ -254,10 +255,8 @@ def determine_os():
 
 
 class Receiver(Thread):
-    """_summary_
-
-    Args:
-        Thread (_type_): _description_
+    """
+    PSN receiver class
     """
 
     def __init__(self, callback, ip_addr="0.0.0.0", mcast_port=56565, timeout=2):
@@ -269,14 +268,18 @@ def __init__(self, callback, ip_addr="0.0.0.0", mcast_port=56565, timeout=2):
             self.socket.settimeout(timeout)
 
     def stop(self):
-        """_summary_"""
+        """
+        Stop listening.
+        """
         self.running = False
         if self.socket is not None:
             self.socket.close()
         self.join()
 
     def run(self):
-        """_summary_"""
+        """
+        Start listnening.
+        """
         data = ""
         if self.socket is None:
             return
@@ -291,14 +294,15 @@ def run(self):
 
 
 def get_socket(ip_addr, mcast_port):
-    """_summary_
+    """
+        Listening for incomming psn packets
 
     Args:
-        ip_addr (_type_): _description_
-        mcast_port (_type_): _description_
+        ip_addr (str): iface ip
+        mcast_port (str): multicast port
 
     Returns:
-        _type_: _description_
+        socket
     """
     mcast_grp = "236.10.10.10"
     sock = None
@@ -314,13 +318,14 @@ def get_socket(ip_addr, mcast_port):
 
 
 def parse_psn_packet(buffer):
-    """_summary_
+    """
+        Parse received data buffer
 
     Args:
-        buffer (_type_): _description_
+        buffer (bytes): Received PSN data
 
     Returns:
-        _type_: _description_
+        psn packet
     """
     psn_id = unpack("<H", buffer[0:2])[0]
     if psn_id in iter(PsnV1Chunk):
@@ -334,13 +339,14 @@ def parse_psn_packet(buffer):
 
 
 def parse_chunk(buffer):
-    """_summary_
+    """
+        Parse received psn chunk
 
     Args:
-        buffer (_type_): _description_
+        buffer (bytes): Received PSN data
 
     Returns:
-        _type_: _description_
+        chunk_id, data, and rest
     """
     chunk_id, data_field = unpack("<HH", buffer[0:4])
     data_len = data_field & 0x7FFF
@@ -353,13 +359,14 @@ def parse_chunk(buffer):
 
 
 def parse_info(buffer):
-    """_summary_
+    """
+        Parse received info buffer
 
     Args:
-        buffer (_type_): _description_
+        buffer (bytes): Received PSN data
 
     Returns:
-        _type_: _description_
+        psn packet
     """
     info = None
     system_name = None
@@ -382,13 +389,14 @@ def parse_info(buffer):
 
 
 def parse_data(buffer):
-    """_summary_
+    """
+        Parse received data buffer
 
     Args:
-        buffer (_type_): _description_
+        buffer (bytes): Received PSN data
 
     Returns:
-        _type_: _description_
+        psn packet
     """
     info = None
     trackers = None
@@ -408,13 +416,14 @@ def parse_data(buffer):
 
 
 def parse_header(buffer):
-    """_summary_
+    """
+        Parse received header buffer
 
     Args:
-        buffer (_type_): _description_
+        buffer (bytes): Received PSN data
 
     Returns:
-        _type_: _description_
+        infos header
     """
     (timestamp, version_high, version_low, frame_id, packet_count) = unpack(
         "<QBBBB", buffer
@@ -426,13 +435,14 @@ def parse_header(buffer):
 
 
 def parse_system_name(buffer):
-    """_summary_
+    """
+        Parse received system name buffer
 
     Args:
-        buffer (_type_): _description_
+        buffer (bytes): Received PSN data
 
     Returns:
-        _type_: _description_
+        system name
     """
     # TODO: may cause unicode issues?
     system_name = buffer
@@ -440,13 +450,14 @@ def parse_system_name(buffer):
 
 
 def parse_info_tracker_list(buffer):
-    """_summary_
+    """
+        Parse received tracker infos buffer
 
     Args:
-        buffer (_type_): _description_
+        buffer (bytes): Received PSN data
 
     Returns:
-        _type_: _description_
+        trackers infos
     """
     trackers: List["PsnTrackerInfo"] = []
     while buffer:
@@ -464,13 +475,14 @@ def parse_info_tracker_list(buffer):
 
 
 def parse_data_tracker_list(buffer):
-    """_summary_
+    """
+        Parse received trackers data buffer
 
     Args:
-        buffer (_type_): _description_
+        buffer (bytes): Received PSN data
 
     Returns:
-        _type_: _description_
+        trackers data
     """
     trackers: List["PsnTracker"] = []
     while buffer:
@@ -498,64 +510,63 @@ def parse_data_tracker_list(buffer):
                     status = unpack("<f", data_buffer)[0]
                     tracker.status = status
                 elif chunk_id == PsnTrackerChunkInfo.PSN_DATA_TRACKER_TIMESTAMP:
-                    timestamp = unpack("<L", data_buffer[:4])[0]
+                    timestamp = unpack("<Q", data_buffer[:8])[0]
                     tracker.timestamp = timestamp
         trackers.append(tracker)
     return trackers
 
 
 def prepare_psn_info_packet_bytes(info_packet: PsnInfoPacket):
-    """_summary_
+    """
+        Converts info variables to bytes
 
     Args:
-        info_packet (PsnInfoPacket): _description_
+        info_packet (PsnInfoPacket)
 
     Returns:
-        _type_: _description_
+        Pasn data as bytes.
     """
     trackers_packet_bytes = b""
     tot_enc_tracker_name_length = 0
 
     for tracker in info_packet.trackers:
-        encoded_tracker_name = str.encode(tracker.tracker_name)
+        encoded_tracker_name = tracker.tracker_name.encode("utf-8")
         tracker_name_len = len(encoded_tracker_name)
 
-        tot_enc_tracker_name_length = (
-            tot_enc_tracker_name_length + tracker_name_len + 16
-        )
+        tot_enc_tracker_name_length = tot_enc_tracker_name_length + tracker_name_len + 8
         trackers_packet_bytes = trackers_packet_bytes + pack(
             "<HHHH" + str(tracker_name_len) + "s",
             tracker.tracker_id,
-            tracker_name_len + 4,
+            tracker_name_len + 4 | (1 << 15),
             PasnTrackerListChunk.PSN_INFO_TRACKER_NAME,
-            tracker_name_len,
+            tracker_name_len | (1 << 15),
             encoded_tracker_name,
         )
     trackers_packet_bytes = (
         pack(
             "<HH",
             PsnInfoChunk.PSN_INFO_TRACKER_LIST,
-            4 + tot_enc_tracker_name_length + 4,
+            tot_enc_tracker_name_length | (1 << 15),
         )
         + trackers_packet_bytes
     )
 
-    encoded_system_name = str.encode(info_packet.name)
+    encoded_system_name = info_packet.name.encode("utf-8")
     system_name_lenght = len(encoded_system_name)
     info_packet_bytes = (
         pack(
             ("<HHHHQBBBBHH" + str(system_name_lenght) + "s"),
             PsnV2Chunck.PSN_INFO_PACKET,
-            (20 + system_name_lenght + tot_enc_tracker_name_length),
+            (24 + system_name_lenght + tot_enc_tracker_name_length) | (1 << 15),
             PsnInfoChunk.PSN_INFO_PACKET_HEADER,
-            12,
+            12 | (1 << 15),
             info_packet.info.timestamp,
             info_packet.info.version_high,
             info_packet.info.version_low,
             info_packet.info.frame_id,
             info_packet.info.packet_count,
             PsnInfoChunk.PSN_INFO_SYSTEM_NAME,
-            system_name_lenght,
+            system_name_lenght | (1 << 15),
             encoded_system_name,
         )
         + trackers_packet_bytes
@@ -565,59 +576,62 @@ def prepare_psn_info_packet_bytes(info_packet: PsnInfoPacket):
 
 
 def prepare_psn_data_packet_bytes(data_packet: PsnDataPacket):
-    """_summary_
+    """
+        Converts data variables to bytes
 
     Args:
-        data_packet (PsnDataPacket): _description_
+        data_packet (PsnDataPacket)
 
     Returns:
-        _type_: _description_
+        Pasn data as bytes.
     """
     trackers_packet_bytes = b""
     tot_enc_tracker_length = 0
 
     for tracker in data_packet.trackers:
-        tot_enc_tracker_length = (
-            tot_enc_tracker_length + 100  # (10 * 4) + (5 * 12)
-        )
+        tot_enc_tracker_length = tot_enc_tracker_length + 104
         trackers_packet_bytes = trackers_packet_bytes + pack(
-            "<HHHHfffHHfffHHfffHHfffHHfffHHfHHL",
+            "<HHHHfffHHfffHHfffHHfHHfffHHfffHHQ",
             tracker.tracker_id,
-            96,  # (9 * 4) + (5 * 12)
+            100 | (1 << 15),  # 28 (H) + 64 (f) + 8 (Q)
             PsnTrackerChunk.PSN_DATA_TRACKER_POS,
-            12,
+            12 | (1 << 15),
             tracker.pos.x,
             tracker.pos.y,
             tracker.pos.z,
+            PsnTrackerChunk.PSN_DATA_TRACKER_SPEED,
+            12 | (1 << 15),
+            tracker.speed.x,
+            tracker.speed.y,
+            tracker.speed.z,
             PsnTrackerChunk.PSN_DATA_TRACKER_ORI,
-            12,
+            12 | (1 << 15),
             tracker.ori.x,
             tracker.ori.y,
             tracker.ori.z,
+            PsnTrackerChunkInfo.PSN_DATA_TRACKER_STATUS,
+            4 | (1 << 15),
+            tracker.status,
             PsnTrackerChunk.PSN_DATA_TRACKER_ACCEL,
-            12,
+            12 | (1 << 15),
             tracker.accel.x,
             tracker.accel.y,
             tracker.accel.z,
-            PsnTrackerChunk.PSN_DATA_TRACKER_SPEED,
-            12,
-            tracker.speed.x,
-            tracker.speed.y,
-            tracker.speed.z,
             PsnTrackerChunk.PSN_DATA_TRACKER_TRGTPOS,
-            12,
+            12 | (1 << 15),
             tracker.trgtpos.x,
             tracker.trgtpos.y,
             tracker.trgtpos.z,
-            PsnTrackerChunkInfo.PSN_DATA_TRACKER_STATUS,
-            4,
-            tracker.status,
             PsnTrackerChunkInfo.PSN_DATA_TRACKER_TIMESTAMP,
-            4,
+            8 | (1 << 15),
             tracker.timestamp,
         )
     trackers_packet_bytes = (
-        pack("<HH", PsnDataChunk.PSN_DATA_TRACKER_LIST, 4 + tot_enc_tracker_length)
+        pack(
+            "<HH",
+            PsnDataChunk.PSN_DATA_TRACKER_LIST,
+            tot_enc_tracker_length | (1 << 15),
+        )
         + trackers_packet_bytes
     )
 
@@ -625,9 +639,9 @@ def prepare_psn_data_packet_bytes(data_packet: PsnDataPacket):
         pack(
             ("<HHHHQBBBB"),
             PsnV2Chunck.PSN_DATA_PACKET,
-            (20 + tot_enc_tracker_length),
+            (16 + 4 + tot_enc_tracker_length) | (1 << 15),
             PsnDataChunk.PSN_DATA_PACKET_HEADER,
-            12,
+            12 | (1 << 15),
             data_packet.info.timestamp,
             data_packet.info.version_high,
             data_packet.info.version_low,
@@ -641,17 +655,23 @@ def prepare_psn_data_packet_bytes(data_packet: PsnDataPacket):
 
 
 def send_psn_packet(
-    psn_packet, mcast_ip="236.10.10.10", ip_addr="0.0.0.0", mcast_port=56565
+    psn_packet, mcast_ip="236.10.10.10", ip_addr="127.0.0.1", port=56565
 ):
-    """_summary_
+    """Send psn packet.
+        If mcast_ip is specified, it does via multicast with the help
+        of multicast_expert. If not, it does via simple unicast.
 
     Args:
-        psn_packet (_type_): _description_
-        mcast_ip (str, optional): _description_. Default '236.10.10.10'.
-        ip_addr (str, optional): _description_. Default "0.0.0.0".
-        mcast_port (int, optional): _description_. Default to 56565.
-    """
-    with multicast_expert.McastTxSocket(
-        socket.AF_INET, mcast_ips=[mcast_ip], iface_ip=ip_addr
-    ) as mcast_tx_sock:
-        mcast_tx_sock.sendto(psn_packet, (mcast_ip, mcast_port))
+        psn_packet (_type_): as bytes
+        mcast_ip (str, optional): multicastip. Default: "236.10.10.10"
+        ip_addr (str, optional): local ip. Default: 127.0.0.1
+        port (int, optional): udp port. Default: 56565
+    """
+    if mcast_ip:
+        with multicast_expert.McastTxSocket(
+            socket.AF_INET, mcast_ips=[mcast_ip], iface_ip=ip_addr
+        ) as mcast_tx_sock:
+            mcast_tx_sock.sendto(psn_packet, (mcast_ip, port))
+    else:
+        sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        sock.sendto(psn_packet, (ip_addr, port))
diff --git a/tests/test_own_pack_unpack.py b/tests/test_own_pack_unpack.py
old mode 100644
new mode 100755
index 9a4b12f..fdb57e2
--- a/tests/test_own_pack_unpack.py
+++ b/tests/test_own_pack_unpack.py
@@ -33,31 +33,31 @@
                 tracker_id=tracker.tracker_id,
                 info=psn_info.info,
                 pos=pypsn.PsnVector3(
-                    x=0.0,
-                    y=0.0,
-                    z=0.0,
+                    x=1.0,
+                    y=1.0,
+                    z=1.0,
                 ),
                 speed=pypsn.PsnVector3(
-                    x=0.0,
-                    y=0.0,
-                    z=0.0,
+                    x=1.0,
+                    y=1.0,
+                    z=1.0,
                 ),
                 ori=pypsn.PsnVector3(
-                    x=0.0,
-                    y=0.0,
-                    z=0.0,
+                    x=1.0,
+                    y=1.0,
+                    z=1.0,
                 ),
                 accel=pypsn.PsnVector3(
-                    x=0.0,
-                    y=0.0,
-                    z=0.0,
+                    x=1.0,
+                    y=1.0,
+                    z=1.0,
                 ),
                 trgtpos=pypsn.PsnVector3(
-                    x=0.0,
-                    y=0.0,
-                    z=0.0,
+                    x=1.0,
+                    y=1.0,
+                    z=1.0,
                 ),
-                status=0,
+                status=0.5,
                 timestamp=psn_info.info.timestamp,
             )
             for tracker in psn_info.trackers
@@ -90,9 +90,17 @@ def test_data_data(pypsn_module):
     """Test position"""
     hexdata = get_test_data()
     data = pypsn_module.parse_psn_packet(hexdata)
-    test_vector = pypsn_module.PsnVector3(0.0, 0.0, 0.0)
+    test_vector = pypsn_module.PsnVector3(1.0, 1.0, 1.0)
     if isinstance(data, pypsn_module.PsnDataPacket):
-        assert test_vector == data.trackers[0].pos
+        for tracker_id in range(0, 7):
+            assert test_vector == data.trackers[tracker_id].pos
+            assert test_vector == data.trackers[tracker_id].ori
+            assert test_vector == data.trackers[tracker_id].speed
+            assert test_vector == data.trackers[tracker_id].accel
+            assert test_vector == data.trackers[tracker_id].trgtpos
+            assert 0.5 == data.trackers[tracker_id].status
+            assert 1312 == data.trackers[tracker_id].timestamp
+            assert tracker_id == data.trackers[tracker_id].tracker_id
 
 
 def test_data_info(pypsn_module):
@@ -128,4 +136,8 @@ def test_info_data(pypsn_module):
     hexdata = get_test_info()
     data = pypsn_module.parse_psn_packet(hexdata)
     if isinstance(data, pypsn_module.PsnInfoPacket):
-        assert data.trackers[0].tracker_name == b"tracker_0"
+        for tracker_id in range(0, 7):
+            assert tracker_id == data.trackers[tracker_id].tracker_id
+            assert ("tracker_" + str(tracker_id)).encode("UTF-8") == data.trackers[
+                tracker_id
+            ].tracker_name