Repository: XKNX/xknx

Issue:
Feature request: Rounding of sensor values according to KNX specification
XKNX sensors are sometimes displayed with lots of decimals, which does not make sense. Example: power = 21.123123123W

Sensors values should be rounded by XKNX according to the KNX standard. Example 0 decimals for DPT14.000 ![Unbenannt](https://user-images.githubusercontent.com/25910703/106315107-0e8bd580-626b-11eb-9d0e-32ce263c5328.png)
For detailed specification see KNX System 3 Specifications -> 7 Interworking ->2 Datapoint Types

My proposal is to add an attribute resolution to each applicable dpt class (https://github.com/XKNX/xknx/blob/master/xknx/dpt).

```
class DPTAcceleration(DPT4ByteFloat):
    """DPT 14.000 DPT_Value_Acceleration (ms-2)."""

    dpt_main_number = 14
    dpt_sub_number = 0
    value_type = "acceleration"
    unit = "m/s²"
    resolution = 0
```

This attribute could be used afterwards in https://github.com/XKNX/xknx/blob/master/xknx/devices/sensor.py for rounding.

Commit https://github.com/XKNX/xknx/pull/304/commits/7687ef3f818950240e96a96979bdeb78b86cac23 would not be required.

Thanks for your comments

 

Discussion:

Patch:
diff --git a/changelog.md b/changelog.md
index c944afa2..5c01aff5 100644
--- a/changelog.md
+++ b/changelog.md
@@ -2,6 +2,10 @@
 
 ## Unreleased changes
 
+### Internals
+
+- Round DPT 14 values to precision of 7 digits
+
 ## 0.18.0
 
 ## Devices
diff --git a/xknx/dpt/dpt_4byte_float.py b/xknx/dpt/dpt_4byte_float.py
index b90ebad9..d013fc36 100644
--- a/xknx/dpt/dpt_4byte_float.py
+++ b/xknx/dpt/dpt_4byte_float.py
@@ -5,7 +5,9 @@ They correspond to the the following KDN DPT 14 class.
 """
 from __future__ import annotations
 
+from math import ceil, log10
 import struct
+from typing import cast
 
 from xknx.exceptions import ConversionError
 
@@ -35,9 +37,17 @@ class DPT4ByteFloat(DPTBase):
         """Parse/deserialize from KNX/IP raw data (big endian)."""
         cls.test_bytesarray(raw)
         try:
-            return struct.unpack(">f", bytes(raw))[0]  # type: ignore
+            raw_float = cast(float, struct.unpack(">f", bytes(raw))[0])
         except struct.error:
             raise ConversionError("Could not parse %s" % cls.__name__, raw=raw)
+        try:
+            # round to 7 digit precicion independent of exponent - same value as ETS 5.7 group monitor
+            return round(raw_float, 7 - ceil(log10(abs(raw_float))))
+        except (ValueError, OverflowError):
+            # account for 0 and special values
+            # ValueError: log10(0.0); ceil(float('nan'))
+            # OverflowError: ceil(float('inf'))
+            return raw_float
 
     @classmethod
     def to_knx(cls, value: float) -> tuple[int, ...]:


Test patch:
diff --git a/requirements/testing.txt b/requirements/testing.txt
index 4c767e25..57df16a6 100644
--- a/requirements/testing.txt
+++ b/requirements/testing.txt
@@ -4,6 +4,7 @@ isort==5.8.0
 flake8==3.9.0
 flake8-isort==4.0.0
 pydocstyle==6.0.0
+astroid==2.5.2
 pylint==2.7.4
 pylint-strict-informational==0.1
 pytest==6.2.3
diff --git a/test/devices_tests/sensor_expose_loop_test.py b/test/devices_tests/sensor_expose_loop_test.py
index a30076d5..78e65ca9 100644
--- a/test/devices_tests/sensor_expose_loop_test.py
+++ b/test/devices_tests/sensor_expose_loop_test.py
@@ -14,111 +14,111 @@ class TestSensorExposeLoop:
     """Process incoming Telegrams and send the values to the bus again."""
 
     test_cases = [
-        ("absolute_temperature", DPTArray((0x44, 0xD7, 0xD2, 0x8B)), 1726.5795),
-        ("acceleration", DPTArray((0x45, 0x94, 0xD8, 0x5D)), 4763.0454),
-        ("acceleration_angular", DPTArray((0x45, 0xEA, 0x62, 0x34)), 7500.2754),
-        ("activation_energy", DPTArray((0x46, 0x0, 0x3E, 0xEE)), 8207.7324),
+        ("absolute_temperature", DPTArray((0x44, 0xD7, 0xD2, 0x87)), 1726.579),
+        ("acceleration", DPTArray((0x45, 0x94, 0xD8, 0x5C)), 4763.045),
+        ("acceleration_angular", DPTArray((0x45, 0xEA, 0x62, 0x33)), 7500.275),
+        ("activation_energy", DPTArray((0x46, 0x0, 0x3E, 0xEE)), 8207.732),
         ("active_energy", DPTArray((0x26, 0x37, 0x49, 0x7F)), 641157503),
         ("active_energy_kwh", DPTArray((0x37, 0x5, 0x5, 0xEA)), 923076074),
-        ("activity", DPTArray((0x45, 0x76, 0x0, 0xA3)), 3936.0398),
-        ("amplitude", DPTArray((0x45, 0x9A, 0xED, 0x8)), 4957.6289),
+        ("activity", DPTArray((0x45, 0x76, 0x0, 0xA4)), 3936.04),
+        ("amplitude", DPTArray((0x45, 0x9A, 0xED, 0x8)), 4957.629),
         ("angle", DPTArray((0xE4,)), 322),
         ("angle_deg", DPTArray((0x44, 0x5C, 0x20, 0x2B)), 880.5026),
         ("angle_rad", DPTArray((0x44, 0x36, 0x75, 0x1)), 729.8282),
         ("angular_frequency", DPTArray((0x43, 0xBC, 0x20, 0x8D)), 376.2543),
         ("angular_momentum", DPTArray((0xC2, 0x75, 0xB7, 0xB5)), -61.4294),
-        ("angular_velocity", DPTArray((0xC4, 0xD9, 0x10, 0xB3)), -1736.5219),
+        ("angular_velocity", DPTArray((0xC4, 0xD9, 0x10, 0xB4)), -1736.522),
         ("apparant_energy", DPTArray((0xD3, 0xBD, 0x1E, 0xA5)), -742580571),
         ("apparant_energy_kvah", DPTArray((0x49, 0x40, 0xC9, 0x9)), 1228982537),
-        ("area", DPTArray((0x45, 0x63, 0x1E, 0xCD)), 3633.9250),
+        ("area", DPTArray((0x45, 0x63, 0x1E, 0xCD)), 3633.925),
         ("brightness", DPTArray((0xC3, 0x56)), 50006),
-        ("capacitance", DPTArray((0x45, 0xC9, 0x1D, 0x9D)), 6435.7017),
-        ("charge_density_surface", DPTArray((0x45, 0xDB, 0x66, 0x99)), 7020.8247),
-        ("charge_density_volume", DPTArray((0xC4, 0x8C, 0x33, 0xD7)), -1121.6200),
+        ("capacitance", DPTArray((0x45, 0xC9, 0x1D, 0x9E)), 6435.702),
+        ("charge_density_surface", DPTArray((0x45, 0xDB, 0x66, 0x9A)), 7020.825),
+        ("charge_density_volume", DPTArray((0xC4, 0x8C, 0x33, 0xD7)), -1121.62),
         ("color_temperature", DPTArray((0x6C, 0x95)), 27797),
-        ("common_temperature", DPTArray((0x45, 0xD9, 0xC6, 0x3F)), 6968.7808),
-        ("compressibility", DPTArray((0x45, 0x89, 0x94, 0xAB)), 4402.5835),
-        ("conductance", DPTArray((0x45, 0xA6, 0x28, 0xF9)), 5317.1216),
+        ("common_temperature", DPTArray((0x45, 0xD9, 0xC6, 0x3F)), 6968.781),
+        ("compressibility", DPTArray((0x45, 0x89, 0x94, 0xAA)), 4402.583),
+        ("conductance", DPTArray((0x45, 0xA6, 0x28, 0xFA)), 5317.122),
         ("counter_pulses", DPTArray((0x9D,)), -99),
         ("current", DPTArray((0xCA, 0xCC)), 51916),
         ("delta_time_hrs", DPTArray((0x47, 0x80)), 18304),
         ("delta_time_min", DPTArray((0xB9, 0x7B)), -18053),
         ("delta_time_ms", DPTArray((0x58, 0x77)), 22647),
         ("delta_time_sec", DPTArray((0xA3, 0x6A)), -23702),
-        ("density", DPTArray((0x44, 0xA5, 0xCB, 0x27)), 1326.3485),
-        ("electrical_conductivity", DPTArray((0xC4, 0xC6, 0xF5, 0x6E)), -1591.6697),
-        ("electric_charge", DPTArray((0x46, 0x14, 0xF6, 0xA0)), 9533.6562),
-        ("electric_current", DPTArray((0x45, 0xAD, 0x45, 0x90)), 5544.6953),
-        ("electric_current_density", DPTArray((0x45, 0x7C, 0x57, 0xF6)), 4037.4976),
-        ("electric_dipole_moment", DPTArray((0x45, 0x58, 0xF1, 0x73)), 3471.0906),
-        ("electric_displacement", DPTArray((0xC5, 0x34, 0x8B, 0x0)), -2888.6875),
-        ("electric_field_strength", DPTArray((0xC6, 0x17, 0x1C, 0x39)), -9671.0557),
-        ("electric_flux", DPTArray((0x45, 0x8F, 0x6C, 0xFD)), 4589.6235),
-        ("electric_flux_density", DPTArray((0xC6, 0x0, 0x50, 0xA8)), -8212.1641),
-        ("electric_polarization", DPTArray((0x45, 0xF8, 0x89, 0xC6)), 7953.2217),
-        ("electric_potential", DPTArray((0xC6, 0x18, 0xA4, 0xAF)), -9769.1709),
-        ("electric_potential_difference", DPTArray((0xC6, 0xF, 0x1D, 0x6)), -9159.2559),
-        ("electromagnetic_moment", DPTArray((0x45, 0x82, 0x48, 0xAE)), 4169.0850),
-        ("electromotive_force", DPTArray((0x45, 0xBC, 0xEF, 0xEB)), 6045.9897),
-        ("energy", DPTArray((0x45, 0x4B, 0xB3, 0xF8)), 3259.2480),
+        ("density", DPTArray((0x44, 0xA5, 0xCB, 0x2B)), 1326.349),
+        ("electrical_conductivity", DPTArray((0xC4, 0xC6, 0xF5, 0x71)), -1591.67),
+        ("electric_charge", DPTArray((0x46, 0x14, 0xF6, 0xA0)), 9533.656),
+        ("electric_current", DPTArray((0x45, 0xAD, 0x45, 0x8F)), 5544.695),
+        ("electric_current_density", DPTArray((0x45, 0x7C, 0x57, 0xF8)), 4037.498),
+        ("electric_dipole_moment", DPTArray((0x39, 0x01, 0x74, 0x2F)), 0.0001234568),
+        ("electric_displacement", DPTArray((0xC5, 0x34, 0x8B, 0x02)), -2888.688),
+        ("electric_field_strength", DPTArray((0xC6, 0x17, 0x1C, 0x39)), -9671.056),
+        ("electric_flux", DPTArray((0x45, 0x8F, 0x6C, 0xFE)), 4589.624),
+        ("electric_flux_density", DPTArray((0xC6, 0x0, 0x50, 0xA8)), -8212.164),
+        ("electric_polarization", DPTArray((0x45, 0xF8, 0x89, 0xC7)), 7953.222),
+        ("electric_potential", DPTArray((0xC6, 0x18, 0xA4, 0xAF)), -9769.171),
+        ("electric_potential_difference", DPTArray((0xC6, 0xF, 0x1D, 0x6)), -9159.256),
+        ("electromagnetic_moment", DPTArray((0x45, 0x82, 0x48, 0xAE)), 4169.085),
+        ("electromotive_force", DPTArray((0x45, 0xBC, 0xEF, 0xEC)), 6045.99),
+        ("energy", DPTArray((0x45, 0x4B, 0xB3, 0xF8)), 3259.248),
         ("enthalpy", DPTArray((0x76, 0xDD)), 287866.88),
         ("flow_rate_m3h", DPTArray((0x99, 0xEA, 0xC0, 0x55)), -1712668587),
-        ("force", DPTArray((0x45, 0x9E, 0x2C, 0xE1)), 5061.6099),
-        ("frequency", DPTArray((0x45, 0xC2, 0x3C, 0x44)), 6215.5332),
-        ("heatcapacity", DPTArray((0xC5, 0xB3, 0x56, 0x7E)), -5738.8115),
-        ("heatflowrate", DPTArray((0x44, 0xEC, 0x80, 0x7A)), 1892.0149),
-        ("heat_quantity", DPTArray((0xC5, 0xA6, 0xB6, 0xD5)), -5334.8540),
+        ("force", DPTArray((0x45, 0x9E, 0x2C, 0xE1)), 5061.61),
+        ("frequency", DPTArray((0x45, 0xC2, 0x3C, 0x44)), 6215.533),
+        ("heatcapacity", DPTArray((0xC5, 0xB3, 0x56, 0x7F)), -5738.812),
+        ("heatflowrate", DPTArray((0x44, 0xEC, 0x80, 0x7B)), 1892.015),
+        ("heat_quantity", DPTArray((0xC5, 0xA6, 0xB6, 0xD5)), -5334.854),
         ("humidity", DPTArray((0x7E, 0xE1)), 577044.48),
-        ("impedance", DPTArray((0x45, 0xDD, 0x79, 0x6D)), 7087.1782),
+        ("impedance", DPTArray((0x45, 0xDD, 0x79, 0x6D)), 7087.178),
         ("illuminance", DPTArray((0x7C, 0x5E)), 366346.24),
         ("kelvin_per_percent", DPTArray((0xFA, 0xBD)), -441384.96),
-        ("length", DPTArray((0xC5, 0x9D, 0xAE, 0xC5)), -5045.8462),
+        ("length", DPTArray((0xC5, 0x9D, 0xAE, 0xC5)), -5045.846),
         ("length_mm", DPTArray((0x56, 0xB9)), 22201),
-        ("light_quantity", DPTArray((0x45, 0x4A, 0xF5, 0x68)), 3247.3379),
+        ("light_quantity", DPTArray((0x45, 0x4A, 0xF5, 0x68)), 3247.338),
         ("long_delta_timesec", DPTArray((0x45, 0xB2, 0x17, 0x54)), 1169299284),
-        ("luminance", DPTArray((0x45, 0x18, 0xD9, 0x76)), 2445.5913),
-        ("luminous_flux", DPTArray((0x45, 0xBD, 0x16, 0x9)), 6050.7544),
-        ("luminous_intensity", DPTArray((0x46, 0xB, 0xBE, 0x7E)), 8943.6230),
+        ("luminance", DPTArray((0x45, 0x18, 0xD9, 0x75)), 2445.591),
+        ("luminous_flux", DPTArray((0x45, 0xBD, 0x16, 0x8)), 6050.754),
+        ("luminous_intensity", DPTArray((0x46, 0xB, 0xBE, 0x7E)), 8943.623),
         ("magnetic_field_strength", DPTArray((0x44, 0x15, 0xF1, 0xAD)), 599.7762),
-        ("magnetic_flux", DPTArray((0xC5, 0xCB, 0x3C, 0x98)), -6503.5742),
-        ("magnetic_flux_density", DPTArray((0x45, 0xB6, 0xBD, 0x42)), 5847.6572),
+        ("magnetic_flux", DPTArray((0xC5, 0xCB, 0x3C, 0x98)), -6503.574),
+        ("magnetic_flux_density", DPTArray((0x45, 0xB6, 0xBD, 0x42)), 5847.657),
         ("magnetic_moment", DPTArray((0xC3, 0x8E, 0x7F, 0x73)), -284.9957),
-        ("magnetic_polarization", DPTArray((0x45, 0x8C, 0xFA, 0xCB)), 4511.3491),
-        ("magnetization", DPTArray((0x45, 0xF7, 0x9D, 0xA2)), 7923.7041),
-        ("magnetomotive_force", DPTArray((0xC6, 0x4, 0xC2, 0xDA)), -8496.7129),
-        ("mass", DPTArray((0x45, 0x8F, 0x70, 0xA4)), 4590.0801),
-        ("mass_flux", DPTArray((0xC6, 0x7, 0x34, 0xFF)), -8653.2490),
-        ("mol", DPTArray((0xC4, 0xA0, 0xF4, 0x68)), -1287.6377),
-        ("momentum", DPTArray((0xC5, 0x27, 0xAA, 0x5B)), -2682.6472),
+        ("magnetic_polarization", DPTArray((0x45, 0x8C, 0xFA, 0xCB)), 4511.349),
+        ("magnetization", DPTArray((0x45, 0xF7, 0x9D, 0xA2)), 7923.704),
+        ("magnetomotive_force", DPTArray((0xC6, 0x4, 0xC2, 0xDA)), -8496.713),
+        ("mass", DPTArray((0x45, 0x8F, 0x70, 0xA4)), 4590.08),
+        ("mass_flux", DPTArray((0xC6, 0x7, 0x34, 0xFF)), -8653.249),
+        ("mol", DPTArray((0xC4, 0xA0, 0xF4, 0x6A)), -1287.638),
+        ("momentum", DPTArray((0xC5, 0x27, 0xAA, 0x5A)), -2682.647),
         ("percent", DPTArray((0xE3,)), 89),
         ("percentU8", DPTArray((0x6B,)), 107),
         ("percentV8", DPTArray((0x20,)), 32),
         ("percentV16", DPTArray((0x8A, 0x2F)), -30161),
-        ("phaseanglerad", DPTArray((0x45, 0x54, 0xAC, 0x2E)), 3402.7612),
-        ("phaseangledeg", DPTArray((0xC5, 0x25, 0x13, 0x38)), -2641.2012),
-        ("power", DPTArray((0x45, 0xCB, 0xE2, 0x5C)), 6524.2949),
+        ("phaseanglerad", DPTArray((0x45, 0x54, 0xAC, 0x2D)), 3402.761),
+        ("phaseangledeg", DPTArray((0xC5, 0x25, 0x13, 0x37)), -2641.201),
+        ("power", DPTArray((0x45, 0xCB, 0xE2, 0x5C)), 6524.295),
         ("power_2byte", DPTArray((0x6D, 0x91)), 116736.00),
         ("power_density", DPTArray((0x65, 0x3E)), 54968.32),
-        ("powerfactor", DPTArray((0xC5, 0x35, 0x28, 0x21)), -2898.5081),
+        ("powerfactor", DPTArray((0xC5, 0x35, 0x28, 0x21)), -2898.508),
         ("ppm", DPTArray((0xF3, 0xC8)), -176947.20),
-        ("pressure", DPTArray((0xC5, 0xE6, 0xE6, 0x63)), -7388.7983),
+        ("pressure", DPTArray((0xC5, 0xE6, 0xE6, 0x62)), -7388.798),
         ("pressure_2byte", DPTArray((0x7C, 0xF4)), 415498.24),
         ("pulse", DPTArray((0xFC,)), 252),
         ("pulse_2byte_signed", DPTArray((0x80, 0x44)), -32700),
         ("rain_amount", DPTArray((0xF0, 0x1)), -335380.48),
-        ("reactance", DPTArray((0x45, 0xB0, 0x50, 0x91)), 5642.0708),
+        ("reactance", DPTArray((0x45, 0xB0, 0x50, 0x91)), 5642.071),
         ("reactive_energy", DPTArray((0x1A, 0x49, 0x6D, 0xA7)), 441019815),
         ("reactive_energy_kvarh", DPTArray((0xCC, 0x62, 0x5, 0x31)), -865991375),
-        ("resistance", DPTArray((0xC5, 0xFC, 0x5F, 0xC2)), -8075.9697),
-        ("resistivity", DPTArray((0xC5, 0x57, 0x76, 0xC3)), -3447.4226),
+        ("resistance", DPTArray((0xC5, 0xFC, 0x5F, 0xC3)), -8075.97),
+        ("resistivity", DPTArray((0xC5, 0x57, 0x76, 0xC5)), -3447.423),
         ("rotation_angle", DPTArray((0x2D, 0xDC)), 11740),
         ("scene_number", DPTArray((0x1,)), 2),
-        ("self_inductance", DPTArray((0xC4, 0xA1, 0xB0, 0x6)), -1293.5007),
-        ("solid_angle", DPTArray((0xC5, 0xC6, 0xE5, 0x47)), -6364.6597),
-        ("sound_intensity", DPTArray((0xC4, 0xF2, 0x56, 0xE6)), -1938.7156),
-        ("speed", DPTArray((0xC5, 0xCD, 0x1C, 0x6A)), -6563.5518),
-        ("stress", DPTArray((0x45, 0xDC, 0xA8, 0xF2)), 7061.1182),
-        ("surface_tension", DPTArray((0x46, 0xB, 0xAC, 0x11)), 8939.0166),
+        ("self_inductance", DPTArray((0xC4, 0xA1, 0xB0, 0x8)), -1293.501),
+        ("solid_angle", DPTArray((0xC5, 0xC6, 0xE5, 0x48)), -6364.66),
+        ("sound_intensity", DPTArray((0xC4, 0xF2, 0x56, 0xE9)), -1938.716),
+        ("speed", DPTArray((0xC5, 0xCD, 0x1C, 0x6A)), -6563.552),
+        ("stress", DPTArray((0x45, 0xDC, 0xA8, 0xF2)), 7061.118),
+        ("surface_tension", DPTArray((0x46, 0xB, 0xAC, 0x11)), 8939.017),
         (
             "string",
             DPTArray(
@@ -143,11 +143,11 @@ class TestSensorExposeLoop:
         ),
         ("temperature", DPTArray((0x77, 0x88)), 315883.52),
         ("temperature_a", DPTArray((0xF1, 0xDB)), -257720.32),
-        ("temperature_difference", DPTArray((0xC6, 0xC, 0x50, 0xBC)), -8980.1836),
+        ("temperature_difference", DPTArray((0xC6, 0xC, 0x50, 0xBC)), -8980.184),
         ("temperature_difference_2byte", DPTArray((0xA9, 0xF4)), -495.36),
         ("temperature_f", DPTArray((0x67, 0xA9)), 80322.56),
-        ("thermal_capacity", DPTArray((0x45, 0x83, 0xEA, 0xB3)), 4221.3374),
-        ("thermal_conductivity", DPTArray((0xC5, 0x9C, 0x4D, 0x22)), -5001.6416),
+        ("thermal_capacity", DPTArray((0x45, 0x83, 0xEA, 0xB2)), 4221.337),
+        ("thermal_conductivity", DPTArray((0xC5, 0x9C, 0x4D, 0x23)), -5001.642),
         ("thermoelectric_power", DPTArray((0x41, 0xCF, 0x9E, 0x4F)), 25.9523),
         ("time_1", DPTArray((0x5E, 0x1E)), 32071.68),
         ("time_2", DPTArray((0xFB, 0x29)), -405995.52),
@@ -157,14 +157,14 @@ class TestSensorExposeLoop:
         ("time_period_min", DPTArray((0x0, 0x54)), 84),
         ("time_period_msec", DPTArray((0x93, 0xC7)), 37831),
         ("time_period_sec", DPTArray((0xE0, 0xF5)), 57589),
-        ("time_seconds", DPTArray((0x45, 0xEC, 0x91, 0x7C)), 7570.1855),
-        ("torque", DPTArray((0xC5, 0x9, 0x23, 0x5F)), -2194.2107),
+        ("time_seconds", DPTArray((0x45, 0xEC, 0x91, 0x7D)), 7570.186),
+        ("torque", DPTArray((0xC5, 0x9, 0x23, 0x60)), -2194.211),
         ("voltage", DPTArray((0x6D, 0xBF)), 120504.32),
-        ("volume", DPTArray((0x46, 0x16, 0x98, 0x43)), 9638.0654),
+        ("volume", DPTArray((0x46, 0x16, 0x98, 0x43)), 9638.065),
         ("volume_flow", DPTArray((0x7C, 0xF5)), 415825.92),
-        ("volume_flux", DPTArray((0xC5, 0x4, 0x2D, 0x72)), -2114.8403),
-        ("weight", DPTArray((0x45, 0x20, 0x10, 0xE8)), 2561.0566),
-        ("work", DPTArray((0x45, 0x64, 0x5D, 0xBE)), 3653.8589),
+        ("volume_flux", DPTArray((0xC5, 0x4, 0x2D, 0x71)), -2114.84),
+        ("weight", DPTArray((0x45, 0x20, 0x10, 0xE9)), 2561.057),
+        ("work", DPTArray((0x45, 0x64, 0x5D, 0xBE)), 3653.859),
         ("wind_speed_ms", DPTArray((0x7D, 0x98)), 469237.76),
         ("wind_speed_kmh", DPTArray((0x7F, 0x55)), 615055.36),
         # # Generic DPT Without Min/Max and Unit.
@@ -203,10 +203,7 @@ class TestSensorExposeLoop:
         )
         await xknx.telegrams.join()
         xknx.knxip_interface.send_telegram.assert_called_with(outgoing_telegram)
-        if isinstance(test_value, float):
-            assert round(expose.resolve_state(), 4) == test_value
-        else:
-            assert expose.resolve_state() == test_value
+        assert expose.resolve_state() == test_value
 
         # init sensor after expose is set - with same group address
         sensor = Sensor(
@@ -237,10 +234,7 @@ class TestSensorExposeLoop:
             ]
         )
         # test if Sensor has successfully read from ExposeSensor
-        if isinstance(test_value, float):
-            assert round(sensor.resolve_state(), 4) == test_value
-        else:
-            assert sensor.resolve_state() == test_value
+        assert sensor.resolve_state() == test_value
         assert expose.resolve_state() == sensor.resolve_state()
         await xknx.telegram_queue.stop()
 
diff --git a/test/devices_tests/sensor_test.py b/test/devices_tests/sensor_test.py
index fc58954e..008a8197 100644
--- a/test/devices_tests/sensor_test.py
+++ b/test/devices_tests/sensor_test.py
@@ -16,15 +16,16 @@ class TestSensor:
     @pytest.mark.parametrize(
         "value_type,raw_payload,expected_state",
         [
+            # DPT-14 values are according to ETS group monitor values
             (
                 "absolute_temperature",
                 DPTArray((0x44, 0xD7, 0xD2, 0x8B)),
-                1726.5794677734375,
+                1726.579,
             ),
             (
                 "acceleration",
                 DPTArray((0x45, 0x94, 0xD8, 0x5D)),
-                4763.04541015625,
+                4763.045,
             ),
             (
                 "volume_liquid_litre",
@@ -49,12 +50,12 @@ class TestSensor:
             (
                 "activity",
                 DPTArray((0x45, 0x76, 0x0, 0xA3)),
-                3936.039794921875,
+                3936.04,
             ),
             (
                 "amplitude",
                 DPTArray((0x45, 0x9A, 0xED, 0x8)),
-                4957.62890625,
+                4957.629,
             ),
             (
                 "angle",
@@ -64,27 +65,27 @@ class TestSensor:
             (
                 "angle_deg",
                 DPTArray((0x44, 0x5C, 0x20, 0x2B)),
-                880.5026245117188,
+                880.5026,
             ),
             (
                 "angle_rad",
                 DPTArray((0x44, 0x36, 0x75, 0x1)),
-                729.8281860351562,
+                729.8282,
             ),
             (
                 "angular_frequency",
                 DPTArray((0x43, 0xBC, 0x20, 0x8D)),
-                376.2543029785156,
+                376.2543,
             ),
             (
                 "angular_momentum",
                 DPTArray((0xC2, 0x75, 0xB7, 0xB5)),
-                -61.42940139770508,
+                -61.4294,
             ),
             (
                 "angular_velocity",
                 DPTArray((0xC4, 0xD9, 0x10, 0xB3)),
-                -1736.5218505859375,
+                -1736.522,
             ),
             (
                 "apparant_energy",
@@ -99,7 +100,7 @@ class TestSensor:
             (
                 "area",
                 DPTArray((0x45, 0x63, 0x1E, 0xCD)),
-                3633.925048828125,
+                3633.925,
             ),
             (
                 "brightness",
@@ -109,17 +110,17 @@ class TestSensor:
             (
                 "capacitance",
                 DPTArray((0x45, 0xC9, 0x1D, 0x9D)),
-                6435.70166015625,
+                6435.702,
             ),
             (
                 "charge_density_surface",
                 DPTArray((0x45, 0xDB, 0x66, 0x99)),
-                7020.82470703125,
+                7020.825,
             ),
             (
                 "charge_density_volume",
                 DPTArray((0xC4, 0x8C, 0x33, 0xD7)),
-                -1121.6199951171875,
+                -1121.62,
             ),
             (
                 "color_temperature",
@@ -129,17 +130,17 @@ class TestSensor:
             (
                 "common_temperature",
                 DPTArray((0x45, 0xD9, 0xC6, 0x3F)),
-                6968.78076171875,
+                6968.781,
             ),
             (
                 "compressibility",
                 DPTArray((0x45, 0x89, 0x94, 0xAB)),
-                4402.58349609375,
+                4402.583,
             ),
             (
                 "conductance",
                 DPTArray((0x45, 0xA6, 0x28, 0xF9)),
-                5317.12158203125,
+                5317.122,
             ),
             (
                 "counter_pulses",
@@ -174,82 +175,82 @@ class TestSensor:
             (
                 "density",
                 DPTArray((0x44, 0xA5, 0xCB, 0x27)),
-                1326.3485107421875,
+                1326.349,
             ),
             (
                 "electrical_conductivity",
                 DPTArray((0xC4, 0xC6, 0xF5, 0x6E)),
-                -1591.669677734375,
+                -1591.67,
             ),
             (
                 "electric_charge",
                 DPTArray((0x46, 0x14, 0xF6, 0xA0)),
-                9533.65625,
+                9533.656,
             ),
             (
                 "electric_current",
                 DPTArray((0x45, 0xAD, 0x45, 0x90)),
-                5544.6953125,
+                5544.695,
             ),
             (
                 "electric_current_density",
                 DPTArray((0x45, 0x7C, 0x57, 0xF6)),
-                4037.49755859375,
+                4037.498,
             ),
             (
                 "electric_dipole_moment",
                 DPTArray((0x45, 0x58, 0xF1, 0x73)),
-                3471.090576171875,
+                3471.091,
             ),
             (
                 "electric_displacement",
                 DPTArray((0xC5, 0x34, 0x8B, 0x0)),
-                -2888.6875,
+                -2888.688,
             ),
             (
                 "electric_field_strength",
                 DPTArray((0xC6, 0x17, 0x1C, 0x39)),
-                -9671.0556640625,
+                -9671.056,
             ),
             (
                 "electric_flux",
                 DPTArray((0x45, 0x8F, 0x6C, 0xFD)),
-                4589.62353515625,
+                4589.624,
             ),
             (
                 "electric_flux_density",
                 DPTArray((0xC6, 0x0, 0x50, 0xA8)),
-                -8212.1640625,
+                -8212.164,
             ),
             (
                 "electric_polarization",
                 DPTArray((0x45, 0xF8, 0x89, 0xC6)),
-                7953.2216796875,
+                7953.222,
             ),
             (
                 "electric_potential",
                 DPTArray((0xC6, 0x18, 0xA4, 0xAF)),
-                -9769.1708984375,
+                -9769.171,
             ),
             (
                 "electric_potential_difference",
                 DPTArray((0xC6, 0xF, 0x1D, 0x6)),
-                -9159.255859375,
+                -9159.256,
             ),
             (
                 "electromagnetic_moment",
                 DPTArray((0x45, 0x82, 0x48, 0xAE)),
-                4169.0849609375,
+                4169.085,
             ),
             (
                 "electromotive_force",
                 DPTArray((0x45, 0xBC, 0xEF, 0xEB)),
-                6045.98974609375,
+                6045.99,
             ),
             (
                 "energy",
                 DPTArray((0x45, 0x4B, 0xB3, 0xF8)),
-                3259.248046875,
+                3259.248,
             ),
             (
                 "enthalpy",
@@ -264,27 +265,27 @@ class TestSensor:
             (
                 "force",
                 DPTArray((0x45, 0x9E, 0x2C, 0xE1)),
-                5061.60986328125,
+                5061.61,
             ),
             (
                 "frequency",
                 DPTArray((0x45, 0xC2, 0x3C, 0x44)),
-                6215.533203125,
+                6215.533,
             ),
             (
                 "heatcapacity",
                 DPTArray((0xC5, 0xB3, 0x56, 0x7E)),
-                -5738.8115234375,
+                -5738.812,
             ),
             (
                 "heatflowrate",
                 DPTArray((0x44, 0xEC, 0x80, 0x7A)),
-                1892.014892578125,
+                1892.015,
             ),
             (
                 "heat_quantity",
                 DPTArray((0xC5, 0xA6, 0xB6, 0xD5)),
-                -5334.85400390625,
+                -5334.854,
             ),
             (
                 "humidity",
@@ -294,7 +295,7 @@ class TestSensor:
             (
                 "impedance",
                 DPTArray((0x45, 0xDD, 0x79, 0x6D)),
-                7087.17822265625,
+                7087.178,
             ),
             (
                 "illuminance",
@@ -309,7 +310,7 @@ class TestSensor:
             (
                 "length",
                 DPTArray((0xC5, 0x9D, 0xAE, 0xC5)),
-                -5045.84619140625,
+                -5045.846,
             ),
             (
                 "length_mm",
@@ -319,7 +320,7 @@ class TestSensor:
             (
                 "light_quantity",
                 DPTArray((0x45, 0x4A, 0xF5, 0x68)),
-                3247.337890625,
+                3247.338,
             ),
             (
                 "long_delta_timesec",
@@ -329,72 +330,72 @@ class TestSensor:
             (
                 "luminance",
                 DPTArray((0x45, 0x18, 0xD9, 0x76)),
-                2445.59130859375,
+                2445.591,
             ),
             (
                 "luminous_flux",
                 DPTArray((0x45, 0xBD, 0x16, 0x9)),
-                6050.75439453125,
+                6050.754,
             ),
             (
                 "luminous_intensity",
                 DPTArray((0x46, 0xB, 0xBE, 0x7E)),
-                8943.623046875,
+                8943.623,
             ),
             (
                 "magnetic_field_strength",
                 DPTArray((0x44, 0x15, 0xF1, 0xAD)),
-                599.7761840820312,
+                599.7762,
             ),
             (
                 "magnetic_flux",
                 DPTArray((0xC5, 0xCB, 0x3C, 0x98)),
-                -6503.57421875,
+                -6503.574,
             ),
             (
                 "magnetic_flux_density",
                 DPTArray((0x45, 0xB6, 0xBD, 0x42)),
-                5847.6572265625,
+                5847.657,
             ),
             (
                 "magnetic_moment",
                 DPTArray((0xC3, 0x8E, 0x7F, 0x73)),
-                -284.9956970214844,
+                -284.9957,
             ),
             (
                 "magnetic_polarization",
                 DPTArray((0x45, 0x8C, 0xFA, 0xCB)),
-                4511.34912109375,
+                4511.349,
             ),
             (
                 "magnetization",
                 DPTArray((0x45, 0xF7, 0x9D, 0xA2)),
-                7923.7041015625,
+                7923.704,
             ),
             (
                 "magnetomotive_force",
                 DPTArray((0xC6, 0x4, 0xC2, 0xDA)),
-                -8496.712890625,
+                -8496.713,
             ),
             (
                 "mass",
                 DPTArray((0x45, 0x8F, 0x70, 0xA4)),
-                4590.080078125,
+                4590.08,
             ),
             (
                 "mass_flux",
                 DPTArray((0xC6, 0x7, 0x34, 0xFF)),
-                -8653.2490234375,
+                -8653.249,
             ),
             (
                 "mol",
                 DPTArray((0xC4, 0xA0, 0xF4, 0x68)),
-                -1287.6376953125,
+                -1287.638,
             ),
             (
                 "momentum",
                 DPTArray((0xC5, 0x27, 0xAA, 0x5B)),
-                -2682.647216796875,
+                -2682.647,
             ),
             (
                 "percent",
@@ -419,17 +420,17 @@ class TestSensor:
             (
                 "phaseanglerad",
                 DPTArray((0x45, 0x54, 0xAC, 0x2E)),
-                3402.76123046875,
+                3402.761,
             ),
             (
                 "phaseangledeg",
                 DPTArray((0xC5, 0x25, 0x13, 0x38)),
-                -2641.201171875,
+                -2641.201,
             ),
             (
                 "power",
                 DPTArray((0x45, 0xCB, 0xE2, 0x5C)),
-                6524.294921875,
+                6524.295,
             ),
             (
                 "power_2byte",
@@ -444,7 +445,7 @@ class TestSensor:
             (
                 "powerfactor",
                 DPTArray((0xC5, 0x35, 0x28, 0x21)),
-                -2898.508056640625,
+                -2898.508,
             ),
             (
                 "ppm",
@@ -454,7 +455,7 @@ class TestSensor:
             (
                 "pressure",
                 DPTArray((0xC5, 0xE6, 0xE6, 0x63)),
-                -7388.79833984375,
+                -7388.798,
             ),
             (
                 "pressure_2byte",
@@ -474,7 +475,7 @@ class TestSensor:
             (
                 "reactance",
                 DPTArray((0x45, 0xB0, 0x50, 0x91)),
-                5642.07080078125,
+                5642.071,
             ),
             (
                 "reactive_energy",
@@ -489,12 +490,12 @@ class TestSensor:
             (
                 "resistance",
                 DPTArray((0xC5, 0xFC, 0x5F, 0xC2)),
-                -8075.9697265625,
+                -8075.97,
             ),
             (
                 "resistivity",
                 DPTArray((0xC5, 0x57, 0x76, 0xC3)),
-                -3447.422607421875,
+                -3447.423,
             ),
             (
                 "rotation_angle",
@@ -509,32 +510,32 @@ class TestSensor:
             (
                 "self_inductance",
                 DPTArray((0xC4, 0xA1, 0xB0, 0x6)),
-                -1293.500732421875,
+                -1293.501,
             ),
             (
                 "solid_angle",
                 DPTArray((0xC5, 0xC6, 0xE5, 0x47)),
-                -6364.65966796875,
+                -6364.66,
             ),
             (
                 "sound_intensity",
                 DPTArray((0xC4, 0xF2, 0x56, 0xE6)),
-                -1938.715576171875,
+                -1938.716,
             ),
             (
                 "speed",
                 DPTArray((0xC5, 0xCD, 0x1C, 0x6A)),
-                -6563.5517578125,
+                -6563.552,
             ),
             (
                 "stress",
                 DPTArray((0x45, 0xDC, 0xA8, 0xF2)),
-                7061.1181640625,
+                7061.118,
             ),
             (
                 "surface_tension",
                 DPTArray((0x46, 0xB, 0xAC, 0x11)),
-                8939.0166015625,
+                8939.017,
             ),
             (
                 "temperature",
@@ -549,7 +550,7 @@ class TestSensor:
             (
                 "temperature_difference",
                 DPTArray((0xC6, 0xC, 0x50, 0xBC)),
-                -8980.18359375,
+                -8980.184,
             ),
             (
                 "temperature_difference_2byte",
@@ -564,17 +565,17 @@ class TestSensor:
             (
                 "thermal_capacity",
                 DPTArray((0x45, 0x83, 0xEA, 0xB3)),
-                4221.33740234375,
+                4221.337,
             ),
             (
                 "thermal_conductivity",
                 DPTArray((0xC5, 0x9C, 0x4D, 0x22)),
-                -5001.6416015625,
+                -5001.642,
             ),
             (
                 "thermoelectric_power",
                 DPTArray((0x41, 0xCF, 0x9E, 0x4F)),
-                25.952299118041992,
+                25.9523,
             ),
             (
                 "time_1",
@@ -619,12 +620,12 @@ class TestSensor:
             (
                 "time_seconds",
                 DPTArray((0x45, 0xEC, 0x91, 0x7C)),
-                7570.185546875,
+                7570.186,
             ),
             (
                 "torque",
                 DPTArray((0xC5, 0x9, 0x23, 0x5F)),
-                -2194.210693359375,
+                -2194.211,
             ),
             (
                 "voltage",
@@ -634,7 +635,7 @@ class TestSensor:
             (
                 "volume",
                 DPTArray((0x46, 0x16, 0x98, 0x43)),
-                9638.0654296875,
+                9638.065,
             ),
             (
                 "volume_flow",
@@ -644,17 +645,17 @@ class TestSensor:
             (
                 "volume_flux",
                 DPTArray((0xC5, 0x4, 0x2D, 0x72)),
-                -2114.84033203125,
+                -2114.84,
             ),
             (
                 "weight",
                 DPTArray((0x45, 0x20, 0x10, 0xE8)),
-                2561.056640625,
+                2561.057,
             ),
             (
                 "work",
                 DPTArray((0x45, 0x64, 0x5D, 0xBE)),
-                3653.85888671875,
+                3653.859,
             ),
             (
                 "wind_speed_ms",
diff --git a/test/dpt_tests/dpt_1byte_uint_test.py b/test/dpt_tests/dpt_1byte_uint_test.py
index 86757acd..e9ce08dd 100644
--- a/test/dpt_tests/dpt_1byte_uint_test.py
+++ b/test/dpt_tests/dpt_1byte_uint_test.py
@@ -9,48 +9,48 @@ class TestDPTValue1Ucount:
 
     def test_value_50(self):
         """Test parsing and streaming of DPTValue1Ucount 50."""
-        assert DPTValue1Ucount().to_knx(50) == (0x32,)
-        assert DPTValue1Ucount().from_knx((0x32,)) == 50
+        assert DPTValue1Ucount.to_knx(50) == (0x32,)
+        assert DPTValue1Ucount.from_knx((0x32,)) == 50
 
     def test_value_max(self):
         """Test parsing and streaming of DPTValue1Ucount 255."""
-        assert DPTValue1Ucount().to_knx(255) == (0xFF,)
-        assert DPTValue1Ucount().from_knx((0xFF,)) == 255
+        assert DPTValue1Ucount.to_knx(255) == (0xFF,)
+        assert DPTValue1Ucount.from_knx((0xFF,)) == 255
 
     def test_value_min(self):
         """Test parsing and streaming of DPTValue1Ucount 0."""
-        assert DPTValue1Ucount().to_knx(0) == (0x00,)
-        assert DPTValue1Ucount().from_knx((0x00,)) == 0
+        assert DPTValue1Ucount.to_knx(0) == (0x00,)
+        assert DPTValue1Ucount.from_knx((0x00,)) == 0
 
     def test_to_knx_min_exceeded(self):
         """Test parsing of DPTValue1Ucount with wrong value (underflow)."""
         with pytest.raises(ConversionError):
-            DPTValue1Ucount().to_knx(DPTValue1Ucount.value_min - 1)
+            DPTValue1Ucount.to_knx(DPTValue1Ucount.value_min - 1)
 
     def test_to_knx_max_exceeded(self):
         """Test parsing of DPTValue1Ucount with wrong value (overflow)."""
         with pytest.raises(ConversionError):
-            DPTValue1Ucount().to_knx(DPTValue1Ucount.value_max + 1)
+            DPTValue1Ucount.to_knx(DPTValue1Ucount.value_max + 1)
 
     def test_to_knx_wrong_parameter(self):
         """Test parsing of DPTValue1Ucount with wrong value (string)."""
         with pytest.raises(ConversionError):
-            DPTValue1Ucount().to_knx("fnord")
+            DPTValue1Ucount.to_knx("fnord")
 
     def test_from_knx_wrong_parameter(self):
         """Test parsing of DPTValue1Ucount with wrong value (3 byte array)."""
         with pytest.raises(ConversionError):
-            DPTValue1Ucount().from_knx((0x01, 0x02, 0x03))
+            DPTValue1Ucount.from_knx((0x01, 0x02, 0x03))
 
     def test_from_knx_wrong_value(self):
         """Test parsing of DPTValue1Ucount with value which exceeds limits."""
         with pytest.raises(ConversionError):
-            DPTValue1Ucount().from_knx((0x256,))
+            DPTValue1Ucount.from_knx((0x256,))
 
     def test_from_knx_wrong_parameter2(self):
         """Test parsing of DPTValue1Ucount with wrong value (array containing string)."""
         with pytest.raises(ConversionError):
-            DPTValue1Ucount().from_knx("0x23")
+            DPTValue1Ucount.from_knx("0x23")
 
 
 class TestDPTTariff:
@@ -59,4 +59,4 @@ class TestDPTTariff:
     def test_from_knx_max_exceeded(self):
         """Test parsing of DPTTariff with wrong value (overflow)."""
         with pytest.raises(ConversionError):
-            DPTTariff().from_knx((0xFF,))
+            DPTTariff.from_knx((0xFF,))
diff --git a/test/dpt_tests/dpt_2byte_signed_test.py b/test/dpt_tests/dpt_2byte_signed_test.py
index 72c73c5e..436e141b 100644
--- a/test/dpt_tests/dpt_2byte_signed_test.py
+++ b/test/dpt_tests/dpt_2byte_signed_test.py
@@ -12,49 +12,49 @@ class TestDPT2ByteSigned:
 
     def test_signed_settings(self):
         """Test members of DPT2ByteSigned."""
-        assert DPT2ByteSigned().value_min == -32768
-        assert DPT2ByteSigned().value_max == 32767
+        assert DPT2ByteSigned.value_min == -32768
+        assert DPT2ByteSigned.value_max == 32767
 
     def test_signed_assert_min_exceeded(self):
         """Test initialization of DPT2ByteSigned with wrong value (Underflow)."""
         with pytest.raises(ConversionError):
-            DPT2ByteSigned().to_knx(-32769)
+            DPT2ByteSigned.to_knx(-32769)
 
     def test_signed_to_knx_exceed_limits(self):
         """Test initialization of DPT2ByteSigned with wrong value (Overflow)."""
         with pytest.raises(ConversionError):
-            DPT2ByteSigned().to_knx(32768)
+            DPT2ByteSigned.to_knx(32768)
 
     def test_signed_value_max_value(self):
         """Test DPT2ByteSigned parsing and streaming."""
-        assert DPT2ByteSigned().to_knx(32767) == (0x7F, 0xFF)
-        assert DPT2ByteSigned().from_knx((0x7F, 0xFF)) == 32767
+        assert DPT2ByteSigned.to_knx(32767) == (0x7F, 0xFF)
+        assert DPT2ByteSigned.from_knx((0x7F, 0xFF)) == 32767
 
     def test_signed_value_min_value(self):
         """Test DPT2ByteSigned parsing and streaming with null values."""
-        assert DPT2ByteSigned().to_knx(-20480) == (0xB0, 0x00)
-        assert DPT2ByteSigned().from_knx((0xB0, 0x00)) == -20480
+        assert DPT2ByteSigned.to_knx(-20480) == (0xB0, 0x00)
+        assert DPT2ByteSigned.from_knx((0xB0, 0x00)) == -20480
 
     def test_signed_value_0123(self):
         """Test DPT2ByteSigned parsing and streaming."""
-        assert DPT2ByteSigned().to_knx(291) == (0x01, 0x23)
-        assert DPT2ByteSigned().from_knx((0x01, 0x23)) == 291
+        assert DPT2ByteSigned.to_knx(291) == (0x01, 0x23)
+        assert DPT2ByteSigned.from_knx((0x01, 0x23)) == 291
 
     def test_signed_wrong_value_from_knx(self):
         """Test DPT2ByteSigned parsing with wrong value."""
         with pytest.raises(ConversionError):
-            DPT2ByteSigned().from_knx((0xFF, 0x4E, 0x12))
+            DPT2ByteSigned.from_knx((0xFF, 0x4E, 0x12))
 
     def test_from_knx_unpack_error(self):
         """Test DPT2ByteSigned parsing with unpack error."""
         with patch("struct.unpack") as unpack_mock:
             unpack_mock.side_effect = struct.error()
             with pytest.raises(ConversionError):
-                DPT2ByteSigned().from_knx((0x01, 0x23))
+                DPT2ByteSigned.from_knx((0x01, 0x23))
 
     def test_to_knx_pack_error(self):
         """Test serializing DPT2ByteSigned with pack error."""
         with patch("struct.pack") as pack_mock:
             pack_mock.side_effect = struct.error()
             with pytest.raises(ConversionError):
-                DPT2ByteSigned().to_knx(1234)
+                DPT2ByteSigned.to_knx(1234)
diff --git a/test/dpt_tests/dpt_2byte_uint_test.py b/test/dpt_tests/dpt_2byte_uint_test.py
index cd93d677..71386c78 100644
--- a/test/dpt_tests/dpt_2byte_uint_test.py
+++ b/test/dpt_tests/dpt_2byte_uint_test.py
@@ -12,47 +12,47 @@ class TestDPT2byte:
     #
     def test_current_settings(self):
         """Test members of DPTUElCurrentmA."""
-        assert DPTUElCurrentmA().value_min == 0
-        assert DPTUElCurrentmA().value_max == 65535
-        assert DPTUElCurrentmA().unit == "mA"
-        assert DPTUElCurrentmA().resolution == 1
+        assert DPTUElCurrentmA.value_min == 0
+        assert DPTUElCurrentmA.value_max == 65535
+        assert DPTUElCurrentmA.unit == "mA"
+        assert DPTUElCurrentmA.resolution == 1
 
     def test_current_assert_min_exceeded(self):
         """Test initialization of DPTUElCurrentmA with wrong value (Underflow)."""
         with pytest.raises(ConversionError):
-            DPTUElCurrentmA().to_knx(-1)
+            DPTUElCurrentmA.to_knx(-1)
 
     def test_current_to_knx_exceed_limits(self):
         """Test initialization of DPTUElCurrentmA with wrong value (Overflow)."""
         with pytest.raises(ConversionError):
-            DPTUElCurrentmA().to_knx(65536)
+            DPTUElCurrentmA.to_knx(65536)
 
     def test_current_value_max_value(self):
         """Test DPTUElCurrentmA parsing and streaming."""
-        assert DPTUElCurrentmA().to_knx(65535) == (0xFF, 0xFF)
-        assert DPTUElCurrentmA().from_knx((0xFF, 0xFF)) == 65535
+        assert DPTUElCurrentmA.to_knx(65535) == (0xFF, 0xFF)
+        assert DPTUElCurrentmA.from_knx((0xFF, 0xFF)) == 65535
 
     def test_current_value_min_value(self):
         """Test DPTUElCurrentmA parsing and streaming with null values."""
-        assert DPTUElCurrentmA().to_knx(0) == (0x00, 0x00)
-        assert DPTUElCurrentmA().from_knx((0x00, 0x00)) == 0
+        assert DPTUElCurrentmA.to_knx(0) == (0x00, 0x00)
+        assert DPTUElCurrentmA.from_knx((0x00, 0x00)) == 0
 
     def test_current_value_38(self):
         """Test DPTUElCurrentmA parsing and streaming 38mA."""
-        assert DPTUElCurrentmA().to_knx(38) == (0x00, 0x26)
-        assert DPTUElCurrentmA().from_knx((0x00, 0x26)) == 38
+        assert DPTUElCurrentmA.to_knx(38) == (0x00, 0x26)
+        assert DPTUElCurrentmA.from_knx((0x00, 0x26)) == 38
 
     def test_current_value_78(self):
         """Test DPTUElCurrentmA parsing and streaming 78mA."""
-        assert DPTUElCurrentmA().to_knx(78) == (0x00, 0x4E)
-        assert DPTUElCurrentmA().from_knx((0x00, 0x4E)) == 78
+        assert DPTUElCurrentmA.to_knx(78) == (0x00, 0x4E)
+        assert DPTUElCurrentmA.from_knx((0x00, 0x4E)) == 78
 
     def test_current_value_1234(self):
         """Test DPTUElCurrentmA parsing and streaming 4660mA."""
-        assert DPTUElCurrentmA().to_knx(4660) == (0x12, 0x34)
-        assert DPTUElCurrentmA().from_knx((0x12, 0x34)) == 4660
+        assert DPTUElCurrentmA.to_knx(4660) == (0x12, 0x34)
+        assert DPTUElCurrentmA.from_knx((0x12, 0x34)) == 4660
 
     def test_current_wrong_value_from_knx(self):
         """Test DPTUElCurrentmA parsing with wrong value."""
         with pytest.raises(ConversionError):
-            DPTUElCurrentmA().from_knx((0xFF, 0x4E, 0x12))
+            DPTUElCurrentmA.from_knx((0xFF, 0x4E, 0x12))
diff --git a/test/dpt_tests/dpt_4byte_int_test.py b/test/dpt_tests/dpt_4byte_int_test.py
index 66c8a0b5..adc5245e 100644
--- a/test/dpt_tests/dpt_4byte_int_test.py
+++ b/test/dpt_tests/dpt_4byte_int_test.py
@@ -15,87 +15,87 @@ class TestDPT4Byte:
     #
     def test_unsigned_settings(self):
         """Test members of DPT4ByteUnsigned."""
-        assert DPT4ByteUnsigned().value_min == 0
-        assert DPT4ByteUnsigned().value_max == 4294967295
+        assert DPT4ByteUnsigned.value_min == 0
+        assert DPT4ByteUnsigned.value_max == 4294967295
 
     def test_unsigned_assert_min_exceeded(self):
         """Test initialization of DPT4ByteUnsigned with wrong value (Underflow)."""
         with pytest.raises(ConversionError):
-            DPT4ByteUnsigned().to_knx(-1)
+            DPT4ByteUnsigned.to_knx(-1)
 
     def test_unsigned_to_knx_exceed_limits(self):
         """Test initialization of DPT4ByteUnsigned with wrong value (Overflow)."""
         with pytest.raises(ConversionError):
-            DPT4ByteUnsigned().to_knx(4294967296)
+            DPT4ByteUnsigned.to_knx(4294967296)
 
     def test_unsigned_value_max_value(self):
         """Test DPT4ByteUnsigned parsing and streaming."""
-        assert DPT4ByteUnsigned().to_knx(4294967295) == (0xFF, 0xFF, 0xFF, 0xFF)
-        assert DPT4ByteUnsigned().from_knx((0xFF, 0xFF, 0xFF, 0xFF)) == 4294967295
+        assert DPT4ByteUnsigned.to_knx(4294967295) == (0xFF, 0xFF, 0xFF, 0xFF)
+        assert DPT4ByteUnsigned.from_knx((0xFF, 0xFF, 0xFF, 0xFF)) == 4294967295
 
     def test_unsigned_value_min_value(self):
         """Test parsing and streaming with null values."""
-        assert DPT4ByteUnsigned().to_knx(0) == (0x00, 0x00, 0x00, 0x00)
-        assert DPT4ByteUnsigned().from_knx((0x00, 0x00, 0x00, 0x00)) == 0
+        assert DPT4ByteUnsigned.to_knx(0) == (0x00, 0x00, 0x00, 0x00)
+        assert DPT4ByteUnsigned.from_knx((0x00, 0x00, 0x00, 0x00)) == 0
 
     def test_unsigned_value_01234567(self):
         """Test DPT4ByteUnsigned parsing and streaming."""
-        assert DPT4ByteUnsigned().to_knx(19088743) == (0x01, 0x23, 0x45, 0x67)
-        assert DPT4ByteUnsigned().from_knx((0x01, 0x23, 0x45, 0x67)) == 19088743
+        assert DPT4ByteUnsigned.to_knx(19088743) == (0x01, 0x23, 0x45, 0x67)
+        assert DPT4ByteUnsigned.from_knx((0x01, 0x23, 0x45, 0x67)) == 19088743
 
     def test_unsigned_wrong_value_from_knx(self):
         """Test DPT4ByteUnsigned parsing with wrong value."""
         with pytest.raises(ConversionError):
-            DPT4ByteUnsigned().from_knx((0xFF, 0x4E, 0x12))
+            DPT4ByteUnsigned.from_knx((0xFF, 0x4E, 0x12))
 
     # ####################################################################
     # DPT4ByteSigned
     #
     def test_signed_settings(self):
         """Test members of DPT4ByteSigned."""
-        assert DPT4ByteSigned().value_min == -2147483648
-        assert DPT4ByteSigned().value_max == 2147483647
+        assert DPT4ByteSigned.value_min == -2147483648
+        assert DPT4ByteSigned.value_max == 2147483647
 
     def test_signed_assert_min_exceeded(self):
         """Test initialization of DPT4ByteSigned with wrong value (Underflow)."""
         with pytest.raises(ConversionError):
-            DPT4ByteSigned().to_knx(-2147483649)
+            DPT4ByteSigned.to_knx(-2147483649)
 
     def test_signed_to_knx_exceed_limits(self):
         """Test initialization of DPT4ByteSigned with wrong value (Overflow)."""
         with pytest.raises(ConversionError):
-            DPT4ByteSigned().to_knx(2147483648)
+            DPT4ByteSigned.to_knx(2147483648)
 
     def test_signed_value_max_value(self):
         """Test DPT4ByteSigned parsing and streaming."""
-        assert DPT4ByteSigned().to_knx(2147483647) == (0x7F, 0xFF, 0xFF, 0xFF)
-        assert DPT4ByteSigned().from_knx((0x7F, 0xFF, 0xFF, 0xFF)) == 2147483647
+        assert DPT4ByteSigned.to_knx(2147483647) == (0x7F, 0xFF, 0xFF, 0xFF)
+        assert DPT4ByteSigned.from_knx((0x7F, 0xFF, 0xFF, 0xFF)) == 2147483647
 
     def test_signed_value_min_value(self):
         """Test DPT4ByteSigned parsing and streaming with null values."""
-        assert DPT4ByteSigned().to_knx(-2147483648) == (0x80, 0x00, 0x00, 0x00)
-        assert DPT4ByteSigned().from_knx((0x80, 0x00, 0x00, 0x00)) == -2147483648
+        assert DPT4ByteSigned.to_knx(-2147483648) == (0x80, 0x00, 0x00, 0x00)
+        assert DPT4ByteSigned.from_knx((0x80, 0x00, 0x00, 0x00)) == -2147483648
 
     def test_signed_value_01234567(self):
         """Test DPT4ByteSigned parsing and streaming."""
-        assert DPT4ByteSigned().to_knx(19088743) == (0x01, 0x23, 0x45, 0x67)
-        assert DPT4ByteSigned().from_knx((0x01, 0x23, 0x45, 0x67)) == 19088743
+        assert DPT4ByteSigned.to_knx(19088743) == (0x01, 0x23, 0x45, 0x67)
+        assert DPT4ByteSigned.from_knx((0x01, 0x23, 0x45, 0x67)) == 19088743
 
     def test_signed_wrong_value_from_knx(self):
         """Test DPT4ByteSigned parsing with wrong value."""
         with pytest.raises(ConversionError):
-            DPT4ByteSigned().from_knx((0xFF, 0x4E, 0x12))
+            DPT4ByteSigned.from_knx((0xFF, 0x4E, 0x12))
 
     def test_from_knx_unpack_error(self):
         """Test DPT4ByteSigned parsing with unpack error."""
         with patch("struct.unpack") as unpack_mock:
             unpack_mock.side_effect = struct.error()
             with pytest.raises(ConversionError):
-                DPT4ByteSigned().from_knx((0x01, 0x23, 0x45, 0x67))
+                DPT4ByteSigned.from_knx((0x01, 0x23, 0x45, 0x67))
 
     def test_to_knx_pack_error(self):
         """Test serializing DPT4ByteSigned with pack error."""
         with patch("struct.pack") as pack_mock:
             pack_mock.side_effect = struct.error()
             with pytest.raises(ConversionError):
-                DPT4ByteSigned().to_knx(19088743)
+                DPT4ByteSigned.to_knx(19088743)
diff --git a/test/dpt_tests/dpt_date_test.py b/test/dpt_tests/dpt_date_test.py
index 0db250f5..c1350bc5 100644
--- a/test/dpt_tests/dpt_date_test.py
+++ b/test/dpt_tests/dpt_date_test.py
@@ -11,53 +11,53 @@ class TestDPTDate:
 
     def test_from_knx(self):
         """Test parsing of DPTDate object from binary values. Example 1."""
-        assert DPTDate().from_knx((0x04, 0x01, 0x02)) == time.strptime(
+        assert DPTDate.from_knx((0x04, 0x01, 0x02)) == time.strptime(
             "2002-01-04", "%Y-%m-%d"
         )
 
     def test_from_knx_old_date(self):
         """Test parsing of DPTDate object from binary values. Example 2."""
-        assert DPTDate().from_knx((0x1F, 0x01, 0x5A)) == time.strptime(
+        assert DPTDate.from_knx((0x1F, 0x01, 0x5A)) == time.strptime(
             "1990-01-31", "%Y-%m-%d"
         )
 
     def test_from_knx_future_date(self):
         """Test parsing of DPTDate object from binary values. Example 3."""
-        assert DPTDate().from_knx((0x04, 0x0C, 0x59)) == time.strptime(
+        assert DPTDate.from_knx((0x04, 0x0C, 0x59)) == time.strptime(
             "2089-12-4", "%Y-%m-%d"
         )
 
     def test_to_knx(self):
         """Testing KNX/Byte representation of DPTDate object. Example 1."""
-        raw = DPTDate().to_knx(time.strptime("2002-1-04", "%Y-%m-%d"))
+        raw = DPTDate.to_knx(time.strptime("2002-1-04", "%Y-%m-%d"))
         assert raw == (0x04, 0x01, 0x02)
 
     def test_to_knx_old_date(self):
         """Testing KNX/Byte representation of DPTDate object. Example 2."""
-        raw = DPTDate().to_knx(time.strptime("1990-01-31", "%Y-%m-%d"))
+        raw = DPTDate.to_knx(time.strptime("1990-01-31", "%Y-%m-%d"))
         assert raw == (0x1F, 0x01, 0x5A)
 
     def test_to_knx_future_date(self):
         """Testing KNX/Byte representation of DPTDate object. Example 3."""
-        raw = DPTDate().to_knx(time.strptime("2089-12-04", "%Y-%m-%d"))
+        raw = DPTDate.to_knx(time.strptime("2089-12-04", "%Y-%m-%d"))
         assert raw == (0x04, 0x0C, 0x59)
 
     def test_from_knx_wrong_parameter(self):
         """Test parsing from DPTDate object from wrong binary values."""
         with pytest.raises(ConversionError):
-            DPTDate().from_knx((0xF8, 0x23))
+            DPTDate.from_knx((0xF8, 0x23))
 
     def test_to_knx_wrong_parameter(self):
         """Test parsing from DPTDate object from wrong string value."""
         with pytest.raises(ConversionError):
-            DPTDate().to_knx("hello")
+            DPTDate.to_knx("hello")
 
     def test_from_knx_wrong_range_month(self):
         """Test Exception when parsing DPTDAte from KNX with wrong month."""
         with pytest.raises(ConversionError):
-            DPTDate().from_knx((0x04, 0x00, 0x59))
+            DPTDate.from_knx((0x04, 0x00, 0x59))
 
     def test_from_knx_wrong_range_year(self):
         """Test Exception when parsing DPTDate from KNX with wrong year."""
         with pytest.raises(ConversionError):
-            DPTDate().from_knx((0x04, 0x01, 0x64))
+            DPTDate.from_knx((0x04, 0x01, 0x64))
diff --git a/test/dpt_tests/dpt_datetime_test.py b/test/dpt_tests/dpt_datetime_test.py
index 7dacd7a0..4f15acec 100644
--- a/test/dpt_tests/dpt_datetime_test.py
+++ b/test/dpt_tests/dpt_datetime_test.py
@@ -14,13 +14,13 @@ class TestDPTDateTime:
     #
     def test_from_knx(self):
         """Test parsing of DPTDateTime object from binary values. Example 1."""
-        assert DPTDateTime().from_knx(
+        assert DPTDateTime.from_knx(
             (0x75, 0x0B, 0x1C, 0x17, 0x07, 0x18, 0x20, 0x80)
         ) == time.strptime("2017-11-28 23:7:24", "%Y-%m-%d %H:%M:%S")
 
     def test_to_knx(self):
         """Testing KNX/Byte representation of DPTDateTime object."""
-        raw = DPTDateTime().to_knx(
+        raw = DPTDateTime.to_knx(
             time.strptime("2017-11-28 23:7:24", "%Y-%m-%d %H:%M:%S")
         )
         assert raw == (0x75, 0x0B, 0x1C, 0x57, 0x07, 0x18, 0x20, 0x80)
@@ -30,13 +30,13 @@ class TestDPTDateTime:
     #
     def test_from_knx_date_in_past(self):
         """Test parsing of DPTDateTime object from binary values. Example 1."""
-        assert DPTDateTime().from_knx(
+        assert DPTDateTime.from_knx(
             (0x00, 0x1, 0x1, 0x20, 0x00, 0x00, 0x00, 0x00)
         ) == time.strptime("1900 1 1 0 0 0", "%Y %m %d %H %M %S")
 
     def test_to_knx_date_in_past(self):
         """Testing KNX/Byte representation of DPTDateTime object."""
-        raw = DPTDateTime().to_knx(
+        raw = DPTDateTime.to_knx(
             time.strptime("1900-1-1 1 0:0:0", "%Y-%m-%d %w %H:%M:%S")
         )
         assert raw == (0x00, 0x1, 0x1, 0x20, 0x00, 0x00, 0x20, 0x80)
@@ -46,13 +46,13 @@ class TestDPTDateTime:
     #
     def test_from_knx_date_in_future(self):
         """Test parsing of DPTDateTime object from binary values. Example 1."""
-        assert DPTDateTime().from_knx(
+        assert DPTDateTime.from_knx(
             (0xFF, 0x0C, 0x1F, 0xF7, 0x3B, 0x3B, 0x20, 0x80)
         ) == time.strptime("2155-12-31 0 23:59:59", "%Y-%m-%d %w %H:%M:%S")
 
     def test_to_knx_date_in_future(self):
         """Testing KNX/Byte representation of DPTDateTime object."""
-        raw = DPTDateTime().to_knx(
+        raw = DPTDateTime.to_knx(
             time.strptime("2155-12-31 0 23:59:59", "%Y-%m-%d %w %H:%M:%S")
         )
         assert raw == (0xFF, 0x0C, 0x1F, 0xF7, 0x3B, 0x3B, 0x20, 0x80)
@@ -63,13 +63,13 @@ class TestDPTDateTime:
     def test_from_knx_wrong_size(self):
         """Test parsing DPTDateTime from KNX with wrong binary values (wrong size)."""
         with pytest.raises(ConversionError):
-            DPTDateTime().from_knx((0xF8, 0x23))
+            DPTDateTime.from_knx((0xF8, 0x23))
 
     def test_from_knx_wrong_bytes(self):
         """Test parsing DPTDateTime from KNX with wrong binary values (wrong bytes)."""
         with pytest.raises(ConversionError):
             # (second byte exceeds value...)
-            DPTDateTime().from_knx((0xFF, 0x0D, 0x1F, 0xF7, 0x3B, 0x3B, 0x00, 0x00))
+            DPTDateTime.from_knx((0xFF, 0x0D, 0x1F, 0xF7, 0x3B, 0x3B, 0x00, 0x00))
 
     #
     # TEST WRONG PARAMETER
@@ -77,4 +77,4 @@ class TestDPTDateTime:
     def test_to_knx_wrong_parameter(self):
         """Test parsing from DPTDateTime object from wrong string value."""
         with pytest.raises(ConversionError):
-            DPTDateTime().to_knx("hello")
+            DPTDateTime.to_knx("hello")
diff --git a/test/dpt_tests/dpt_float_test.py b/test/dpt_tests/dpt_float_test.py
index 5652868b..cc5965d8 100644
--- a/test/dpt_tests/dpt_float_test.py
+++ b/test/dpt_tests/dpt_float_test.py
@@ -1,4 +1,5 @@
 """Unit test for KNX 2 and 4 byte float objects."""
+import math
 import struct
 from unittest.mock import patch
 
@@ -29,36 +30,36 @@ class TestDPTFloat:
     #
     def test_value_from_documentation(self):
         """Test parsing and streaming of DPT2ByteFloat -30.00. Example from the internet[tm]."""
-        assert DPT2ByteFloat().to_knx(-30.00) == (0x8A, 0x24)
-        assert DPT2ByteFloat().from_knx((0x8A, 0x24)) == -30.00
+        assert DPT2ByteFloat.to_knx(-30.00) == (0x8A, 0x24)
+        assert DPT2ByteFloat.from_knx((0x8A, 0x24)) == -30.00
 
     def test_value_taken_from_live_thermostat(self):
         """Test parsing and streaming of DPT2ByteFloat 19.96."""
-        assert DPT2ByteFloat().to_knx(16.96) == (0x06, 0xA0)
-        assert DPT2ByteFloat().from_knx((0x06, 0xA0)) == 16.96
+        assert DPT2ByteFloat.to_knx(16.96) == (0x06, 0xA0)
+        assert DPT2ByteFloat.from_knx((0x06, 0xA0)) == 16.96
 
     def test_zero_value(self):
         """Test parsing and streaming of DPT2ByteFloat zero value."""
-        assert DPT2ByteFloat().to_knx(0.00) == (0x00, 0x00)
-        assert DPT2ByteFloat().from_knx((0x00, 0x00)) == 0.00
+        assert DPT2ByteFloat.to_knx(0.00) == (0x00, 0x00)
+        assert DPT2ByteFloat.from_knx((0x00, 0x00)) == 0.00
 
     def test_room_temperature(self):
         """Test parsing and streaming of DPT2ByteFloat 21.00. Room temperature."""
-        assert DPT2ByteFloat().to_knx(21.00) == (0x0C, 0x1A)
-        assert DPT2ByteFloat().from_knx((0x0C, 0x1A)) == 21.00
+        assert DPT2ByteFloat.to_knx(21.00) == (0x0C, 0x1A)
+        assert DPT2ByteFloat.from_knx((0x0C, 0x1A)) == 21.00
 
     def test_high_temperature(self):
         """Test parsing and streaming of DPT2ByteFloat 500.00, 499.84, 500.16. Testing rounding issues."""
-        assert DPT2ByteFloat().to_knx(500.00) == (0x2E, 0x1A)
-        assert round(abs(DPT2ByteFloat().from_knx((0x2E, 0x1A)) - 499.84), 7) == 0
-        assert round(abs(DPT2ByteFloat().from_knx((0x2E, 0x1B)) - 500.16), 7) == 0
-        assert DPT2ByteFloat().to_knx(499.84) == (0x2E, 0x1A)
-        assert DPT2ByteFloat().to_knx(500.16) == (0x2E, 0x1B)
+        assert DPT2ByteFloat.to_knx(500.00) == (0x2E, 0x1A)
+        assert round(abs(DPT2ByteFloat.from_knx((0x2E, 0x1A)) - 499.84), 7) == 0
+        assert round(abs(DPT2ByteFloat.from_knx((0x2E, 0x1B)) - 500.16), 7) == 0
+        assert DPT2ByteFloat.to_knx(499.84) == (0x2E, 0x1A)
+        assert DPT2ByteFloat.to_knx(500.16) == (0x2E, 0x1B)
 
     def test_minor_negative_temperature(self):
         """Test parsing and streaming of DPT2ByteFloat -10.00. Testing negative values."""
-        assert DPT2ByteFloat().to_knx(-10.00) == (0x84, 0x18)
-        assert DPT2ByteFloat().from_knx((0x84, 0x18)) == -10.00
+        assert DPT2ByteFloat.to_knx(-10.00) == (0x84, 0x18)
+        assert DPT2ByteFloat.from_knx((0x84, 0x18)) == -10.00
 
     def test_very_cold_temperature(self):
         """
@@ -66,203 +67,217 @@ class TestDPTFloat:
 
         Testing rounding issues of negative values.
         """
-        assert DPT2ByteFloat().to_knx(-1000.00) == (0xB1, 0xE6)
-        assert DPT2ByteFloat().from_knx((0xB1, 0xE6)) == -999.68
-        assert DPT2ByteFloat().from_knx((0xB1, 0xE5)) == -1000.32
-        assert DPT2ByteFloat().to_knx(-999.68) == (0xB1, 0xE6)
-        assert DPT2ByteFloat().to_knx(-1000.32) == (0xB1, 0xE5)
+        assert DPT2ByteFloat.to_knx(-1000.00) == (0xB1, 0xE6)
+        assert DPT2ByteFloat.from_knx((0xB1, 0xE6)) == -999.68
+        assert DPT2ByteFloat.from_knx((0xB1, 0xE5)) == -1000.32
+        assert DPT2ByteFloat.to_knx(-999.68) == (0xB1, 0xE6)
+        assert DPT2ByteFloat.to_knx(-1000.32) == (0xB1, 0xE5)
 
     def test_max(self):
         """Test parsing and streaming of DPT2ByteFloat with maximum value."""
-        assert DPT2ByteFloat().to_knx(DPT2ByteFloat.value_max) == (0x7F, 0xFF)
-        assert DPT2ByteFloat().from_knx((0x7F, 0xFF)) == DPT2ByteFloat.value_max
+        assert DPT2ByteFloat.to_knx(DPT2ByteFloat.value_max) == (0x7F, 0xFF)
+        assert DPT2ByteFloat.from_knx((0x7F, 0xFF)) == DPT2ByteFloat.value_max
 
     def test_min(self):
         """Test parsing and streaming of DPT2ByteFloat with minimum value."""
-        assert DPT2ByteFloat().to_knx(DPT2ByteFloat.value_min) == (0xF8, 0x00)
-        assert DPT2ByteFloat().from_knx((0xF8, 0x00)) == DPT2ByteFloat.value_min
+        assert DPT2ByteFloat.to_knx(DPT2ByteFloat.value_min) == (0xF8, 0x00)
+        assert DPT2ByteFloat.from_knx((0xF8, 0x00)) == DPT2ByteFloat.value_min
 
     def test_close_to_max(self):
         """Test parsing and streaming of DPT2ByteFloat with maximum value -1."""
-        assert DPT2ByteFloat().to_knx(670433.28) == (0x7F, 0xFE)
-        assert DPT2ByteFloat().from_knx((0x7F, 0xFE)) == 670433.28
+        assert DPT2ByteFloat.to_knx(670433.28) == (0x7F, 0xFE)
+        assert DPT2ByteFloat.from_knx((0x7F, 0xFE)) == 670433.28
 
     def test_close_to_min(self):
         """Test parsing and streaming of DPT2ByteFloat with minimum value +1."""
-        assert DPT2ByteFloat().to_knx(-670760.96) == (0xF8, 0x01)
-        assert DPT2ByteFloat().from_knx((0xF8, 0x01)) == -670760.96
+        assert DPT2ByteFloat.to_knx(-670760.96) == (0xF8, 0x01)
+        assert DPT2ByteFloat.from_knx((0xF8, 0x01)) == -670760.96
 
     def test_to_knx_min_exceeded(self):
         """Test parsing of DPT2ByteFloat with wrong value (underflow)."""
         with pytest.raises(ConversionError):
-            DPT2ByteFloat().to_knx(DPT2ByteFloat.value_min - 1)
+            DPT2ByteFloat.to_knx(DPT2ByteFloat.value_min - 1)
 
     def test_to_knx_max_exceeded(self):
         """Test parsing of DPT2ByteFloat with wrong value (overflow)."""
         with pytest.raises(ConversionError):
-            DPT2ByteFloat().to_knx(DPT2ByteFloat.value_max + 1)
+            DPT2ByteFloat.to_knx(DPT2ByteFloat.value_max + 1)
 
     def test_to_knx_wrong_parameter(self):
         """Test parsing of DPT2ByteFloat with wrong value (string)."""
         with pytest.raises(ConversionError):
-            DPT2ByteFloat().to_knx("fnord")
+            DPT2ByteFloat.to_knx("fnord")
 
     def test_from_knx_wrong_parameter(self):
         """Test parsing of DPT2ByteFloat with wrong value (wrong number of bytes)."""
         with pytest.raises(ConversionError):
-            DPT2ByteFloat().from_knx((0xF8, 0x01, 0x23))
+            DPT2ByteFloat.from_knx((0xF8, 0x01, 0x23))
 
     def test_from_knx_wrong_parameter2(self):
         """Test parsing of DPT2ByteFloat with wrong value (second parameter is a string)."""
         with pytest.raises(ConversionError):
-            DPT2ByteFloat().from_knx((0xF8, "0x23"))
+            DPT2ByteFloat.from_knx((0xF8, "0x23"))
 
     #
     # DPTTemperature
     #
     def test_temperature_settings(self):
         """Test attributes of DPTTemperature."""
-        assert DPTTemperature().value_min == -273
-        assert DPTTemperature().value_max == 670760
-        assert DPTTemperature().unit == "°C"
-        assert DPTTemperature().resolution == 0.01
+        assert DPTTemperature.value_min == -273
+        assert DPTTemperature.value_max == 670760
+        assert DPTTemperature.unit == "°C"
+        assert DPTTemperature.resolution == 0.01
 
     def test_temperature_assert_min_exceeded(self):
         """Testing parsing of DPTTemperature with wrong value."""
         with pytest.raises(ConversionError):
-            DPTTemperature().to_knx(-274)
+            DPTTemperature.to_knx(-274)
 
     def test_temperature_assert_min_exceeded_from_knx(self):
         """Testing parsing of DPTTemperature with wrong value."""
         with pytest.raises(ConversionError):
-            DPTTemperature().from_knx((0xB1, 0xE6))  # -1000
+            DPTTemperature.from_knx((0xB1, 0xE6))  # -1000
 
     #
     # DPTLux
     #
     def test_lux_settings(self):
         """Test attributes of DPTLux."""
-        assert DPTLux().value_min == 0
-        assert DPTLux().value_max == 670760
-        assert DPTLux().unit == "lx"
-        assert DPTLux().resolution == 0.01
+        assert DPTLux.value_min == 0
+        assert DPTLux.value_max == 670760
+        assert DPTLux.unit == "lx"
+        assert DPTLux.resolution == 0.01
 
     def test_lux_assert_min_exceeded(self):
         """Test parsing of DPTLux with wrong value."""
         with pytest.raises(ConversionError):
-            DPTLux().to_knx(-1)
+            DPTLux.to_knx(-1)
 
     #
     # DPTHumidity
     #
     def test_humidity_settings(self):
         """Test attributes of DPTHumidity."""
-        assert DPTHumidity().value_min == 0
-        assert DPTHumidity().value_max == 670760
-        assert DPTHumidity().unit == "%"
-        assert DPTHumidity().resolution == 0.01
+        assert DPTHumidity.value_min == 0
+        assert DPTHumidity.value_max == 670760
+        assert DPTHumidity.unit == "%"
+        assert DPTHumidity.resolution == 0.01
 
     def test_humidity_assert_min_exceeded(self):
         """Test parsing of DPTHumidity with wrong value."""
         with pytest.raises(ConversionError):
-            DPTHumidity().to_knx(-1)
+            DPTHumidity.to_knx(-1)
 
     #
     # DPTEnthalpy
     #
     def test_enthalpy_settings(self):
         """Test attributes of DPTEnthalpy."""
-        assert DPTEnthalpy().unit == "H"
+        assert DPTEnthalpy.unit == "H"
 
     #
     # DPTPartsPerMillion
     #
     def test_partspermillion_settings(self):
         """Test attributes of DPTPartsPerMillion."""
-        assert DPTPartsPerMillion().unit == "ppm"
+        assert DPTPartsPerMillion.unit == "ppm"
 
     #
     # DPTVoltage
     #
     def test_voltage_settings(self):
         """Test attributes of DPTVoltage."""
-        assert DPTVoltage().unit == "mV"
+        assert DPTVoltage.unit == "mV"
 
     # ####################################################################
     # DPT4ByteFloat
     #
     def test_4byte_float_values_from_power_meter(self):
         """Test parsing DPT4ByteFloat value from power meter."""
-        assert DPT4ByteFloat().from_knx((0x43, 0xC6, 0x80, 00)) == 397
-        assert DPT4ByteFloat().to_knx(397) == (0x43, 0xC6, 0x80, 00)
-        assert DPT4ByteFloat().from_knx((0x42, 0x38, 0x00, 00)) == 46
-        assert DPT4ByteFloat().to_knx(46) == (0x42, 0x38, 0x00, 00)
+        assert DPT4ByteFloat.from_knx((0x43, 0xC6, 0x80, 00)) == 397
+        assert DPT4ByteFloat.to_knx(397) == (0x43, 0xC6, 0x80, 00)
+        assert DPT4ByteFloat.from_knx((0x42, 0x38, 0x00, 00)) == 46
+        assert DPT4ByteFloat.to_knx(46) == (0x42, 0x38, 0x00, 00)
 
     def test_14_033(self):
         """Test parsing DPTFrequency unit."""
-        assert DPTFrequency().unit == "Hz"
+        assert DPTFrequency.unit == "Hz"
 
     def test_14_055(self):
         """Test DPTPhaseAngleDeg object."""
-        assert DPT4ByteFloat().from_knx((0x42, 0xEF, 0x00, 0x00)) == 119.5
-        assert DPT4ByteFloat().to_knx(119.5) == (0x42, 0xEF, 0x00, 0x00)
-        assert DPTPhaseAngleDeg().unit == "°"
+        assert DPT4ByteFloat.from_knx((0x42, 0xEF, 0x00, 0x00)) == 119.5
+        assert DPT4ByteFloat.to_knx(119.5) == (0x42, 0xEF, 0x00, 0x00)
+        assert DPTPhaseAngleDeg.unit == "°"
 
     def test_14_057(self):
         """Test DPT4ByteFloat object."""
-        assert round(DPT4ByteFloat().from_knx((0x3F, 0x71, 0xEB, 0x86)), 7) == 0.9450001
-        assert DPT4ByteFloat().to_knx(0.945000052452) == (0x3F, 0x71, 0xEB, 0x86)
-        assert DPT4ByteFloat().unit == ""
+        assert DPT4ByteFloat.from_knx((0x3F, 0x71, 0xEB, 0x86)) == 0.9450001
+        assert DPT4ByteFloat.to_knx(0.945000052452) == (0x3F, 0x71, 0xEB, 0x86)
+        assert DPT4ByteFloat.unit == ""
 
     def test_4byte_float_values_from_voltage_meter(self):
         """Test parsing DPT4ByteFloat from voltage meter."""
-        assert round(DPT4ByteFloat().from_knx((0x43, 0x65, 0xE3, 0xD7)), 2) == 229.89
-        assert DPT4ByteFloat().to_knx(229.89) == (0x43, 0x65, 0xE3, 0xD7)
+        assert DPT4ByteFloat.from_knx((0x43, 0x65, 0xE3, 0xD7)) == 229.89
+        assert DPT4ByteFloat.to_knx(229.89) == (0x43, 0x65, 0xE3, 0xD7)
 
     def test_4byte_float_zero_value(self):
         """Test parsing and streaming of DPT4ByteFloat zero value."""
-        assert DPT4ByteFloat().from_knx((0x00, 0x00, 0x00, 0x00)) == 0.00
-        assert DPT4ByteFloat().to_knx(0.00) == (0x00, 0x00, 0x00, 0x00)
+        assert DPT4ByteFloat.from_knx((0x00, 0x00, 0x00, 0x00)) == 0.00
+        assert DPT4ByteFloat.to_knx(0.00) == (0x00, 0x00, 0x00, 0x00)
+
+    def test_4byte_float_special_value(self):
+        """Test parsing and streaming of DPT4ByteFloat special value."""
+        assert math.isnan(DPT4ByteFloat.from_knx((0x7F, 0xC0, 0x00, 0x00)))
+        assert DPT4ByteFloat.to_knx(float("nan")) == (0x7F, 0xC0, 0x00, 0x00)
+
+        assert math.isinf(DPT4ByteFloat.from_knx((0x7F, 0x80, 0x00, 0x00)))
+        assert DPT4ByteFloat.to_knx(float("inf")) == (0x7F, 0x80, 0x00, 0x00)
+
+        assert DPT4ByteFloat.from_knx((0xFF, 0x80, 0x00, 0x00)) == float("-inf")
+        assert DPT4ByteFloat.to_knx(float("-inf")) == (0xFF, 0x80, 0x00, 0x00)
+
+        assert DPT4ByteFloat.from_knx((0x80, 0x00, 0x00, 0x00)) == float("-0")
+        assert DPT4ByteFloat.to_knx(float("-0")) == (0x80, 0x00, 0x00, 0x00)
 
     def test_4byte_float_to_knx_wrong_parameter(self):
         """Test parsing of DPT4ByteFloat with wrong value (string)."""
         with pytest.raises(ConversionError):
-            DPT4ByteFloat().to_knx("fnord")
+            DPT4ByteFloat.to_knx("fnord")
 
     def test_4byte_float_from_knx_wrong_parameter(self):
         """Test parsing of DPT4ByteFloat with wrong value (wrong number of bytes)."""
         with pytest.raises(ConversionError):
-            DPT4ByteFloat().from_knx((0xF8, 0x01, 0x23))
+            DPT4ByteFloat.from_knx((0xF8, 0x01, 0x23))
 
     def test_4byte_float_from_knx_wrong_parameter2(self):
         """Test parsing of DPT4ByteFloat with wrong value (second parameter is a string)."""
         with pytest.raises(ConversionError):
-            DPT4ByteFloat().from_knx((0xF8, "0x23", 0x00, 0x00))
+            DPT4ByteFloat.from_knx((0xF8, "0x23", 0x00, 0x00))
 
     def test_4byte_flaot_from_knx_unpack_error(self):
         """Test DPT4ByteFloat parsing with unpack error."""
         with patch("struct.unpack") as unpack_mock:
             unpack_mock.side_effect = struct.error()
             with pytest.raises(ConversionError):
-                DPT4ByteFloat().from_knx((0x01, 0x23, 0x02, 0x02))
+                DPT4ByteFloat.from_knx((0x01, 0x23, 0x02, 0x02))
 
     #
     # DPTElectricCurrent
     #
     def test_electric_current_settings(self):
         """Test attributes of DPTElectricCurrent."""
-        assert DPTElectricCurrent().unit == "A"
+        assert DPTElectricCurrent.unit == "A"
 
     #
     # DPTElectricPotential
     #
     def test_electric_potential_settings(self):
         """Test attributes of DPTElectricPotential."""
-        assert DPTElectricPotential().unit == "V"
+        assert DPTElectricPotential.unit == "V"
 
     #
     # DPTPower
     #
     def test_power_settings(self):
         """Test attributes of DPTPower."""
-        assert DPTPower().unit == "W"
+        assert DPTPower.unit == "W"
diff --git a/test/dpt_tests/dpt_scaling_test.py b/test/dpt_tests/dpt_scaling_test.py
index b331db00..55359298 100644
--- a/test/dpt_tests/dpt_scaling_test.py
+++ b/test/dpt_tests/dpt_scaling_test.py
@@ -9,53 +9,53 @@ class TestDPTScaling:
 
     def test_value_30_pct(self):
         """Test parsing and streaming of DPTScaling 30%."""
-        assert DPTScaling().to_knx(30) == (0x4C,)
-        assert DPTScaling().from_knx((0x4C,)) == 30
+        assert DPTScaling.to_knx(30) == (0x4C,)
+        assert DPTScaling.from_knx((0x4C,)) == 30
 
     def test_value_99_pct(self):
         """Test parsing and streaming of DPTScaling 99%."""
-        assert DPTScaling().to_knx(99) == (0xFC,)
-        assert DPTScaling().from_knx((0xFC,)) == 99
+        assert DPTScaling.to_knx(99) == (0xFC,)
+        assert DPTScaling.from_knx((0xFC,)) == 99
 
     def test_value_max(self):
         """Test parsing and streaming of DPTScaling 100%."""
-        assert DPTScaling().to_knx(100) == (0xFF,)
-        assert DPTScaling().from_knx((0xFF,)) == 100
+        assert DPTScaling.to_knx(100) == (0xFF,)
+        assert DPTScaling.from_knx((0xFF,)) == 100
 
     def test_value_min(self):
         """Test parsing and streaming of DPTScaling 0."""
-        assert DPTScaling().to_knx(0) == (0x00,)
-        assert DPTScaling().from_knx((0x00,)) == 0
+        assert DPTScaling.to_knx(0) == (0x00,)
+        assert DPTScaling.from_knx((0x00,)) == 0
 
     def test_to_knx_min_exceeded(self):
         """Test parsing of DPTScaling with wrong value (underflow)."""
         with pytest.raises(ConversionError):
-            DPTScaling().to_knx(-1)
+            DPTScaling.to_knx(-1)
 
     def test_to_knx_max_exceeded(self):
         """Test parsing of DPTScaling with wrong value (overflow)."""
         with pytest.raises(ConversionError):
-            DPTScaling().to_knx(101)
+            DPTScaling.to_knx(101)
 
     def test_to_knx_wrong_parameter(self):
         """Test parsing of DPTScaling with wrong value (string)."""
         with pytest.raises(ConversionError):
-            DPTScaling().to_knx("fnord")
+            DPTScaling.to_knx("fnord")
 
     def test_from_knx_wrong_parameter(self):
         """Test parsing of DPTScaling with wrong value (3 byte array)."""
         with pytest.raises(ConversionError):
-            DPTScaling().from_knx((0x01, 0x02, 0x03))
+            DPTScaling.from_knx((0x01, 0x02, 0x03))
 
     def test_from_knx_wrong_value(self):
         """Test parsing of DPTScaling with value which exceeds limits."""
         with pytest.raises(ConversionError):
-            DPTScaling().from_knx((0x256,))
+            DPTScaling.from_knx((0x256,))
 
     def test_from_knx_wrong_parameter2(self):
         """Test parsing of DPTScaling with wrong value (array containing string)."""
         with pytest.raises(ConversionError):
-            DPTScaling().from_knx("0x23")
+            DPTScaling.from_knx("0x23")
 
 
 class TestDPTAngle:
@@ -63,30 +63,30 @@ class TestDPTAngle:
 
     def test_value_30_deg(self):
         """Test parsing and streaming of DPTAngle 30°."""
-        assert DPTAngle().to_knx(30) == (0x15,)
-        assert DPTAngle().from_knx((0x15,)) == 30
+        assert DPTAngle.to_knx(30) == (0x15,)
+        assert DPTAngle.from_knx((0x15,)) == 30
 
     def test_value_270_deg(self):
         """Test parsing and streaming of DPTAngle 270°."""
-        assert DPTAngle().to_knx(270) == (0xBF,)
-        assert DPTAngle().from_knx((0xBF,)) == 270
+        assert DPTAngle.to_knx(270) == (0xBF,)
+        assert DPTAngle.from_knx((0xBF,)) == 270
 
     def test_value_max(self):
         """Test parsing and streaming of DPTAngle 360°."""
-        assert DPTAngle().to_knx(360) == (0xFF,)
-        assert DPTAngle().from_knx((0xFF,)) == 360
+        assert DPTAngle.to_knx(360) == (0xFF,)
+        assert DPTAngle.from_knx((0xFF,)) == 360
 
     def test_value_min(self):
         """Test parsing and streaming of DPTAngle 0°."""
-        assert DPTAngle().to_knx(0) == (0x00,)
-        assert DPTAngle().from_knx((0x00,)) == 0
+        assert DPTAngle.to_knx(0) == (0x00,)
+        assert DPTAngle.from_knx((0x00,)) == 0
 
     def test_to_knx_min_exceeded(self):
         """Test parsing of DPTAngle with wrong value (underflow)."""
         with pytest.raises(ConversionError):
-            DPTAngle().to_knx(-1)
+            DPTAngle.to_knx(-1)
 
     def test_to_knx_max_exceeded(self):
         """Test parsing of DPTAngle with wrong value (overflow)."""
         with pytest.raises(ConversionError):
-            DPTAngle().to_knx(361)
+            DPTAngle.to_knx(361)
diff --git a/test/dpt_tests/dpt_scene_number_test.py b/test/dpt_tests/dpt_scene_number_test.py
index b83c88ff..3d021b5f 100644
--- a/test/dpt_tests/dpt_scene_number_test.py
+++ b/test/dpt_tests/dpt_scene_number_test.py
@@ -9,45 +9,45 @@ class TestDPTSceneNumber:
 
     def test_value_50(self):
         """Test parsing and streaming of DPTSceneNumber 50."""
-        assert DPTSceneNumber().to_knx(50) == (0x31,)
-        assert DPTSceneNumber().from_knx((0x31,)) == 50
+        assert DPTSceneNumber.to_knx(50) == (0x31,)
+        assert DPTSceneNumber.from_knx((0x31,)) == 50
 
     def test_value_max(self):
         """Test parsing and streaming of DPTSceneNumber 64."""
-        assert DPTSceneNumber().to_knx(64) == (0x3F,)
-        assert DPTSceneNumber().from_knx((0x3F,)) == 64
+        assert DPTSceneNumber.to_knx(64) == (0x3F,)
+        assert DPTSceneNumber.from_knx((0x3F,)) == 64
 
     def test_value_min(self):
         """Test parsing and streaming of DPTSceneNumber 0."""
-        assert DPTSceneNumber().to_knx(1) == (0x00,)
-        assert DPTSceneNumber().from_knx((0x00,)) == 1
+        assert DPTSceneNumber.to_knx(1) == (0x00,)
+        assert DPTSceneNumber.from_knx((0x00,)) == 1
 
     def test_to_knx_min_exceeded(self):
         """Test parsing of DPTSceneNumber with wrong value (underflow)."""
         with pytest.raises(ConversionError):
-            DPTSceneNumber().to_knx(DPTSceneNumber.value_min - 1)
+            DPTSceneNumber.to_knx(DPTSceneNumber.value_min - 1)
 
     def test_to_knx_max_exceeded(self):
         """Test parsing of DPTSceneNumber with wrong value (overflow)."""
         with pytest.raises(ConversionError):
-            DPTSceneNumber().to_knx(DPTSceneNumber.value_max + 1)
+            DPTSceneNumber.to_knx(DPTSceneNumber.value_max + 1)
 
     def test_to_knx_wrong_parameter(self):
         """Test parsing of DPTSceneNumber with wrong value (string)."""
         with pytest.raises(ConversionError):
-            DPTSceneNumber().to_knx("fnord")
+            DPTSceneNumber.to_knx("fnord")
 
     def test_from_knx_wrong_parameter(self):
         """Test parsing of DPTSceneNumber with wrong value (3 byte array)."""
         with pytest.raises(ConversionError):
-            DPTSceneNumber().from_knx((0x01, 0x02, 0x03))
+            DPTSceneNumber.from_knx((0x01, 0x02, 0x03))
 
     def test_from_knx_wrong_value(self):
         """Test parsing of DPTSceneNumber with value which exceeds limits."""
         with pytest.raises(ConversionError):
-            DPTSceneNumber().from_knx((0x64,))
+            DPTSceneNumber.from_knx((0x64,))
 
     def test_from_knx_wrong_parameter2(self):
         """Test parsing of DPTSceneNumber with wrong value (array containing string)."""
         with pytest.raises(ConversionError):
-            DPTSceneNumber().from_knx("0x23")
+            DPTSceneNumber.from_knx("0x23")
diff --git a/test/dpt_tests/dpt_string_test.py b/test/dpt_tests/dpt_string_test.py
index 5536dd42..cf3c8bc3 100644
--- a/test/dpt_tests/dpt_string_test.py
+++ b/test/dpt_tests/dpt_string_test.py
@@ -98,7 +98,7 @@ class TestDPTString:
     def test_to_knx_too_long(self):
         """Test serializing DPTString to KNX with wrong value (to long)."""
         with pytest.raises(ConversionError):
-            DPTString().to_knx("AAAAABBBBBCCCCx")
+            DPTString.to_knx("AAAAABBBBBCCCCx")
 
     def test_from_knx_wrong_parameter_too_large(self):
         """Test parsing of KNX string with too many elements."""
@@ -120,7 +120,7 @@ class TestDPTString:
             0x00,
         )
         with pytest.raises(ConversionError):
-            DPTString().from_knx(raw)
+            DPTString.from_knx(raw)
 
     def test_from_knx_wrong_parameter_too_small(self):
         """Test parsing of KNX string with too less elements."""
@@ -140,4 +140,4 @@ class TestDPTString:
             0x00,
         )
         with pytest.raises(ConversionError):
-            DPTString().from_knx(raw)
+            DPTString.from_knx(raw)
diff --git a/test/dpt_tests/dpt_time_test.py b/test/dpt_tests/dpt_time_test.py
index 6376c9cf..569c94c0 100644
--- a/test/dpt_tests/dpt_time_test.py
+++ b/test/dpt_tests/dpt_time_test.py
@@ -14,13 +14,13 @@ class TestDPTTime:
     #
     def test_from_knx(self):
         """Test parsing of DPTTime object from binary values. Example 1."""
-        assert DPTTime().from_knx((0x4D, 0x17, 0x2A)) == time.strptime(
+        assert DPTTime.from_knx((0x4D, 0x17, 0x2A)) == time.strptime(
             "13 23 42 2", "%H %M %S %w"
         )
 
     def test_to_knx(self):
         """Testing KNX/Byte representation of DPTTime object."""
-        raw = DPTTime().to_knx(time.strptime("13 23 42 2", "%H %M %S %w"))
+        raw = DPTTime.to_knx(time.strptime("13 23 42 2", "%H %M %S %w"))
         assert raw == (0x4D, 0x17, 0x2A)
 
     #
@@ -28,12 +28,12 @@ class TestDPTTime:
     #
     def test_to_knx_max(self):
         """Testing KNX/Byte representation of DPTTime object. Maximum values."""
-        raw = DPTTime().to_knx(time.strptime("23 59 59 0", "%H %M %S %w"))
+        raw = DPTTime.to_knx(time.strptime("23 59 59 0", "%H %M %S %w"))
         assert raw == (0xF7, 0x3B, 0x3B)
 
     def test_from_knx_max(self):
         """Test parsing of DPTTime object from binary values. Example 2."""
-        assert DPTTime().from_knx((0xF7, 0x3B, 0x3B)) == time.strptime(
+        assert DPTTime.from_knx((0xF7, 0x3B, 0x3B)) == time.strptime(
             "23 59 59 0", "%H %M %S %w"
         )
 
@@ -42,37 +42,37 @@ class TestDPTTime:
     #
     def test_to_knx_min(self):
         """Testing KNX/Byte representation of DPTTime object. Minimum values."""
-        raw = DPTTime().to_knx(time.strptime("0 0 0", "%H %M %S"))
+        raw = DPTTime.to_knx(time.strptime("0 0 0", "%H %M %S"))
         assert raw == (0x0, 0x0, 0x0)
 
     def test_from_knx_min(self):
         """Test parsing of DPTTime object from binary values. Example 3."""
-        assert DPTTime().from_knx((0x0, 0x0, 0x0)) == time.strptime("0 0 0", "%H %M %S")
+        assert DPTTime.from_knx((0x0, 0x0, 0x0)) == time.strptime("0 0 0", "%H %M %S")
 
     #
     # TEST INITIALIZATION
     #
     def test_to_knx_default(self):
         """Testing default initialization of DPTTime object."""
-        assert DPTTime().to_knx(time.strptime("", "")) == (0x0, 0x0, 0x0)
+        assert DPTTime.to_knx(time.strptime("", "")) == (0x0, 0x0, 0x0)
 
     def test_from_knx_wrong_size(self):
         """Test parsing from DPTTime object from wrong binary values (wrong size)."""
         with pytest.raises(ConversionError):
-            DPTTime().from_knx((0xF8, 0x23))
+            DPTTime.from_knx((0xF8, 0x23))
 
     def test_from_knx_wrong_bytes(self):
         """Test parsing from DPTTime object from wrong binary values (wrong bytes)."""
         with pytest.raises(ConversionError):
             # this parameter exceeds limit
-            DPTTime().from_knx((0xF7, 0x3B, 0x3C))
+            DPTTime.from_knx((0xF7, 0x3B, 0x3C))
 
     def test_from_knx_wrong_type(self):
         """Test parsing from DPTTime object from wrong binary values (wrong type)."""
         with pytest.raises(ConversionError):
-            DPTTime().from_knx((0xF8, "0x23"))
+            DPTTime.from_knx((0xF8, "0x23"))
 
     def test_to_knx_wrong_parameter(self):
         """Test parsing from DPTTime object from wrong string value."""
         with pytest.raises(ConversionError):
-            DPTTime().to_knx("fnord")
+            DPTTime.to_knx("fnord")