diff --git a/docs/notebooks/sensors_testing.ipynb b/docs/notebooks/sensors_testing.ipynb
index 842558dbd..83a777daa 100644
--- a/docs/notebooks/sensors_testing.ipynb
+++ b/docs/notebooks/sensors_testing.ipynb
@@ -140,33 +140,29 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from rocketpy import Accelerometer, Gyroscope\n",
-    "\n",
-    "accel_noisy_nosecone = Accelerometer(\n",
-    "    sampling_rate=100,\n",
-    "    consider_gravity=False,\n",
-    "    orientation=(60, 60, 60),\n",
-    "    measurement_range=70,\n",
-    "    resolution=0.4882,\n",
-    "    noise_density=0.05,\n",
-    "    random_walk_density=0.02,\n",
-    "    constant_bias=1,\n",
-    "    operating_temperature=25,\n",
-    "    temperature_bias=0.02,\n",
-    "    temperature_scale_factor=0.02,\n",
-    "    cross_axis_sensitivity=0.02,\n",
-    "    name=\"Accelerometer in Nosecone\",\n",
-    ")\n",
-    "accel_clean_cdm = Accelerometer(\n",
-    "    sampling_rate=100,\n",
-    "    consider_gravity=False,\n",
-    "    orientation=[\n",
-    "        [0.25, -0.0581, 0.9665],\n",
-    "        [0.433, 0.8995, -0.0581],\n",
-    "        [-0.8661, 0.433, 0.25],\n",
-    "    ],\n",
-    "    name=\"Accelerometer in CDM\",\n",
-    ")\n",
+    "from rocketpy import Accelerometer, Gyroscope, Barometer\n",
+    "accel_noisy_nosecone = Accelerometer(sampling_rate=100,\n",
+    "                  consider_gravity=False,\n",
+    "                  orientation=(60,60,60),\n",
+    "                  measurement_range=70,\n",
+    "                  resolution=0.4882,\n",
+    "                  noise_density=0.05,\n",
+    "                  random_walk_density=0.02,\n",
+    "                  constant_bias=1 ,\n",
+    "                  operating_temperature=25,\n",
+    "                  temperature_bias=0.02,\n",
+    "                  temperature_scale_factor=0.02,\n",
+    "                  cross_axis_sensitivity=0.02,\n",
+    "                  name='Accelerometer in Nosecone'\n",
+    "                )\n",
+    "accel_clean_cdm = Accelerometer(sampling_rate=100,\n",
+    "                  consider_gravity=False,\n",
+    "                  orientation=[[0.25, -0.0581, 0.9665],\n",
+    "                               [0.433, 0.8995, -0.0581],\n",
+    "                               [-0.8661, 0.433, 0.25]\n",
+    "                               ],\n",
+    "                  name='Accelerometer in CDM'\n",
+    "                  )\n",
     "calisto.add_sensor(accel_noisy_nosecone, 1.278)\n",
     "calisto.add_sensor(accel_clean_cdm, -0.10482544178314143)  # , 127/2000)"
    ]
@@ -175,12 +171,100 @@
    "cell_type": "code",
    "execution_count": null,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Identification of the Sensor:\n",
+      "\n",
+      "Name:                      Accelerometer in Nosecone\n",
+      "Type:                      Accelerometer\n",
+      "\n",
+      "Orientation of the Sensor:\n",
+      "\n",
+      "Orientation:               (60, 60, 60)\n",
+      "Normal Vector:             (0.9665063509461097, -0.05801270189221941, 0.2500000000000002)\n",
+      "Rotation Matrix:\n",
+      "                           [0.25, -0.06, 0.97]\n",
+      "                           [0.43, 0.9, -0.06]\n",
+      "                           [-0.87, 0.43, 0.25]\n",
+      "\n",
+      "Quantization of the Sensor:\n",
+      "\n",
+      "Measurement Range:         -70 to 70 (m/s^2)\n",
+      "Resolution:                0.4882 m/s^2/LSB\n",
+      "\n",
+      "Noise of the Sensor:\n",
+      "\n",
+      "Noise Density:             (0.05, 0.05, 0.05) m/s^2/√Hz\n",
+      "Noise Variance:            (1, 1, 1) (m/s^2)^2\n",
+      "Random Walk Density:       (0.02, 0.02, 0.02) m/s^2/√Hz\n",
+      "Random Walk Variance:      (1, 1, 1) (m/s^2)^2\n",
+      "Constant Bias:             (1, 1, 1) m/s^2\n",
+      "Operating Temperature:     25 °C\n",
+      "Temperature Bias:          (0.02, 0.02, 0.02) m/s^2/°C\n",
+      "Temperature Scale Factor:  (0.02, 0.02, 0.02) %/°C\n",
+      "Cross Axis Sensitivity:    0.02 %\n",
+      "Identification of the Sensor:\n",
+      "\n",
+      "Name:                      Accelerometer in CDM\n",
+      "Type:                      Accelerometer\n",
+      "\n",
+      "Orientation of the Sensor:\n",
+      "\n",
+      "Orientation:               [[0.25, -0.0581, 0.9665], [0.433, 0.8995, -0.0581], [-0.8661, 0.433, 0.25]]\n",
+      "Normal Vector:             (0.9665010341566599, -0.05810006216709978, 0.25000026750042936)\n",
+      "Rotation Matrix:\n",
+      "                           [0.25, -0.06, 0.97]\n",
+      "                           [0.43, 0.9, -0.06]\n",
+      "                           [-0.87, 0.43, 0.25]\n",
+      "\n",
+      "Quantization of the Sensor:\n",
+      "\n",
+      "Measurement Range:         -inf to inf (m/s^2)\n",
+      "Resolution:                0 m/s^2/LSB\n",
+      "\n",
+      "Noise of the Sensor:\n",
+      "\n",
+      "Noise Density:             (0, 0, 0) m/s^2/√Hz\n",
+      "Noise Variance:            (1, 1, 1) (m/s^2)^2\n",
+      "Random Walk Density:       (0, 0, 0) m/s^2/√Hz\n",
+      "Random Walk Variance:      (1, 1, 1) (m/s^2)^2\n",
+      "Constant Bias:             (0, 0, 0) m/s^2\n",
+      "Operating Temperature:     25 °C\n",
+      "Temperature Bias:          (0, 0, 0) m/s^2/°C\n",
+      "Temperature Scale Factor:  (0, 0, 0) %/°C\n",
+      "Cross Axis Sensitivity:    0 %\n"
+     ]
+    }
+   ],
    "source": [
     "accel_noisy_nosecone.prints.all()\n",
     "accel_clean_cdm.prints.all()  # should have the same rotation matrix"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.001064225153655079"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "np.radians(0.06097560975609756097560975609756)"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -189,44 +273,88 @@
    "source": [
     "gyro_clean = Gyroscope(sampling_rate=100)\n",
     "gyro_noisy = Gyroscope(\n",
-    "    sampling_rate=100,\n",
-    "    orientation=(180, 0, 0),\n",
-    "    acceleration_sensitivity=0.02,\n",
-    "    measurement_range=70,\n",
-    "    resolution=0.4882,\n",
-    "    noise_density=0.05,\n",
-    "    random_walk_density=0.02,\n",
-    "    constant_bias=1,\n",
-    "    operating_temperature=25,\n",
-    "    temperature_bias=0.02,\n",
-    "    temperature_scale_factor=0.02,\n",
-    "    cross_axis_sensitivity=0.02,\n",
-    ")\n",
-    "calisto.add_sensor(gyro_clean, -0.10482544178314143 + 0.5, 127 / 2000)\n",
-    "calisto.add_sensor(gyro_noisy, 1.278 - 0.4, 127 / 2000 - 127 / 4000)"
+    "        sampling_rate=100,\n",
+    "        resolution=0.001064225153655079,\n",
+    "        orientation=(-60, -60, -60),\n",
+    "        noise_density=[0, 0.03, 0.05],\n",
+    "        noise_variance=1.01,\n",
+    "        random_walk_density=[0, 0.01, 0.02],\n",
+    "        random_walk_variance=[1, 1, 1.05],\n",
+    "        constant_bias=[0, 0.3, 0.5],\n",
+    "        operating_temperature=25,\n",
+    "        temperature_bias=[0, 0.01, 0.02],\n",
+    "        temperature_scale_factor=[0, 0.01, 0.02],\n",
+    "        cross_axis_sensitivity=0.5,\n",
+    "        acceleration_sensitivity=[0, 0.0008, 0.0017],\n",
+    "        name=\"Gyroscope\",\n",
+    "    )\n",
+    "calisto.add_sensor(gyro_clean, -0.10482544178314143)#+0.5, 127/2000)\n",
+    "calisto.add_sensor(gyro_noisy, 1.278-0.4, 127/2000-127/4000)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [],
+   "source": [
+    "barometer_clean = Barometer(sampling_rate=50,\n",
+    "                            measurement_range=100000,\n",
+    "                            resolution=0.16,\n",
+    "                            noise_density=19,\n",
+    "                            noise_variance=19,\n",
+    "                            random_walk_density=0.01,\n",
+    "                            constant_bias=1,\n",
+    "                            operating_temperature=25,\n",
+    "                            temperature_bias=0.02,\n",
+    "                            temperature_scale_factor=0.02,\n",
+    "                            )\n",
+    "calisto.add_sensor(barometer_clean, -0.10482544178314143+0.5, -127/2000)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "calisto.draw(plane=\"xz\")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 12,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "calisto.draw(plane=\"yz\")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 13,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -290,7 +418,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 14,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -309,7 +437,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 15,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -318,7 +446,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 16,
    "metadata": {
     "colab": {},
     "colab_type": "code",
@@ -339,18 +467,77 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 17,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Data saved to aaaa.csv\n"
+     ]
+    }
+   ],
+   "source": [
+    "barometer_clean.export_measured_data(\"aaaa.csv\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "test_flight.altitude()"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 18,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "# get first column of every row as time from [(time,(ax,ay,az)),...] = a.measured_data\n",
     "time1, ax, ay, az = zip(*accel_noisy_nosecone.measured_data)\n",
@@ -381,9 +568,30 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 19,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(0.0, 4.0)"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "# now plot the total acceleration\n",
     "\n",
@@ -400,31 +608,57 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 22,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "time1, wx, wy, wz = zip(*gyro_noisy.measured_data)\n",
     "time2, zx, zy, zz = zip(*gyro_clean.measured_data)\n",
     "\n",
-    "plt.plot(time1, wx, label=\"Noisy Gyroscope\")\n",
-    "plt.plot(time2, zx, label=\"Clean Gyroscope\")\n",
-    "plt.xlabel(\"Time (s)\")\n",
-    "plt.ylabel(\"Angular Velocity wx (rad/s)\")\n",
+    "plt.plot(time1, wx, label='Noisy Gyroscope')\n",
+    "# plt.plot(time2, zx, label='Clean Gyroscope')\n",
     "plt.legend()\n",
     "plt.show()\n",
     "\n",
-    "plt.plot(time1, wy, label=\"Noisy Gyroscope\")\n",
-    "plt.plot(time2, zy, label=\"Clean Gyroscope\")\n",
-    "plt.xlabel(\"Time (s)\")\n",
-    "plt.ylabel(\"Angular Velocity wy (rad/s)\")\n",
+    "plt.plot(time1, wy, label='Noisy Gyroscope')\n",
+    "# plt.plot(time2, zy, label='Clean Gyroscope')\n",
     "plt.legend()\n",
     "plt.show()\n",
     "\n",
-    "plt.plot(time1, wz, label=\"Noisy Gyroscope\")\n",
-    "plt.plot(time2, zz, label=\"Clean Gyroscope\")\n",
-    "plt.xlabel(\"Time (s)\")\n",
-    "plt.ylabel(\"Angular Velocity wz (rad/s)\")\n",
+    "plt.plot(time1, wz, label='Noisy Gyroscope')\n",
+    "plt.xlim(0,4)\n",
+    "# plt.plot(time2, zz, label='Clean Gyroscope')\n",
     "plt.legend()\n",
     "plt.show()\n",
     "\n",
@@ -441,6 +675,48 @@
     "plt.show()"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "t,p = zip(*barometer_clean.measured_data)\n",
+    "plt.plot(t,p)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "test_flight.pressure()"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
diff --git a/rocketpy/__init__.py b/rocketpy/__init__.py
index fe55dda41..43a6ebc67 100644
--- a/rocketpy/__init__.py
+++ b/rocketpy/__init__.py
@@ -37,5 +37,5 @@
     Tail,
     TrapezoidalFins,
 )
-from .sensors import Accelerometer, Gyroscope, Sensors
+from .sensors import Accelerometer, Barometer, Gyroscope
 from .simulation import Flight
diff --git a/rocketpy/control/controller.py b/rocketpy/control/controller.py
index c2617f8eb..93a13ecfd 100644
--- a/rocketpy/control/controller.py
+++ b/rocketpy/control/controller.py
@@ -101,6 +101,7 @@ def __init_controller_function(self, controller_function):
         sig = signature(controller_function)
         if len(sig.parameters) == 6:
 
+            # pylint: disable=unused-argument
             def new_controller_function(
                 time,
                 sampling_rate,
diff --git a/rocketpy/plots/rocket_plots.py b/rocketpy/plots/rocket_plots.py
index 0d7b5b130..e57fe87e4 100644
--- a/rocketpy/plots/rocket_plots.py
+++ b/rocketpy/plots/rocket_plots.py
@@ -218,7 +218,7 @@ def draw(self, vis_args=None, plane="xz"):
         self._draw_motor(last_radius, last_x, ax, vis_args)
         self._draw_rail_buttons(ax, vis_args)
         self._draw_center_of_mass_and_pressure(ax)
-        self._draw_sensor(ax, self.rocket.sensors, plane, vis_args)
+        self._draw_sensors(ax, self.rocket.sensors, plane, vis_args)
 
         plt.title("Rocket Representation")
         plt.xlim()
@@ -555,7 +555,7 @@ def _draw_center_of_mass_and_pressure(self, ax):
             cp, 0, label="Static Center of Pressure", color="red", s=10, zorder=10
         )
 
-    def _draw_sensor(self, ax, sensors, plane, vis_args):
+    def _draw_sensors(self, ax, sensors, plane, vis_args):
         """Draw the sensor as a small thick line at the position of the sensor,
         with a vector pointing in the direction normal of the sensor. Get the
         normal vector from the sensor orientation matrix."""
@@ -591,19 +591,20 @@ def _draw_sensor(self, ax, sensors, plane, vis_args):
                 zorder=10,
                 label=sensor.name,
             )
-            ax.quiver(
-                x_pos,
-                y_pos,
-                normal_x,
-                normal_y,
-                color=colors[(i + 1) % len(colors)],
-                scale_units="xy",
-                angles="xy",
-                minshaft=2,
-                headwidth=2,
-                headlength=4,
-                zorder=10,
-            )
+            if abs(sensor.normal_vector) != 0:
+                ax.quiver(
+                    x_pos,
+                    y_pos,
+                    normal_x,
+                    normal_y,
+                    color=colors[(i + 1) % len(colors)],
+                    scale_units="xy",
+                    angles="xy",
+                    minshaft=2,
+                    headwidth=2,
+                    headlength=4,
+                    zorder=10,
+                )
 
     def all(self):
         """Prints out all graphs available about the Rocket. It simply calls
diff --git a/rocketpy/prints/sensors_prints.py b/rocketpy/prints/sensors_prints.py
index 2d646a4f4..a454aa0fa 100644
--- a/rocketpy/prints/sensors_prints.py
+++ b/rocketpy/prints/sensors_prints.py
@@ -1,7 +1,7 @@
-from abc import ABC, abstractmethod
+from abc import ABC
 
 
-class _SensorsPrints(ABC):
+class _SensorPrints(ABC):
     def __init__(self, sensor):
         self.sensor = sensor
         self.units = sensor.units
@@ -32,14 +32,14 @@ def quantization(self):
         print("\nQuantization:\n")
         self._print_aligned(
             "Measurement Range:",
-            f"{self.sensor.measurement_range[0]} to {self.sensor.measurement_range[1]} ({self.units})",
+            f"{self.sensor.measurement_range[0]} "
+            + f"to {self.sensor.measurement_range[1]} ({self.units})",
         )
         self._print_aligned("Resolution:", f"{self.sensor.resolution} {self.units}/LSB")
 
-    @abstractmethod
     def noise(self):
         """Prints the noise of the sensor."""
-        pass
+        self._general_noise()
 
     def _general_noise(self):
         """Prints the noise of the sensor."""
@@ -62,45 +62,52 @@ def _general_noise(self):
             "Constant Bias:", f"{self.sensor.constant_bias} {self.units}"
         )
         self._print_aligned(
-            "Operating Temperature:", f"{self.sensor.operating_temperature} °C"
-        )
-        self._print_aligned(
-            "Temperature Bias:", f"{self.sensor.temperature_bias} {self.units}/°C"
+            "Operating Temperature:", f"{self.sensor.operating_temperature} K"
         )
         self._print_aligned(
-            "Temperature Scale Factor:", f"{self.sensor.temperature_scale_factor} %/°C"
+            "Temperature Bias:", f"{self.sensor.temperature_bias} {self.units}/K"
         )
         self._print_aligned(
-            "Cross Axis Sensitivity:", f"{self.sensor.cross_axis_sensitivity} %"
+            "Temperature Scale Factor:", f"{self.sensor.temperature_scale_factor} %/K"
         )
 
     def all(self):
         """Prints all information of the sensor."""
         self.identity()
-        self.orientation()
         self.quantization()
         self.noise()
 
 
-class _AccelerometerPrints(_SensorsPrints):
-    """Class that contains all accelerometer prints."""
+class _InertialSensorPrints(_SensorPrints):
 
-    def __init__(self, accelerometer):
-        """Initialize the class."""
-        super().__init__(accelerometer)
+    def orientation(self):
+        """Prints the orientation of the sensor."""
+        print("\nOrientation of the Sensor:\n")
+        self._print_aligned("Orientation:", self.sensor.orientation)
+        self._print_aligned("Normal Vector:", self.sensor.normal_vector)
+        print("Rotation Matrix:")
+        for row in self.sensor.rotation_matrix:
+            value = " ".join(f"{val:.2f}" for val in row)
+            value = [float(val) for val in value.split()]
+            self._print_aligned("", value)
 
-    def noise(self):
-        """Prints the noise of the sensor."""
-        self._general_noise()
+    def _general_noise(self):
+        super()._general_noise()
+        self._print_aligned(
+            "Cross Axis Sensitivity:", f"{self.sensor.cross_axis_sensitivity} %"
+        )
+
+    def all(self):
+        """Prints all information of the sensor."""
+        self.identity()
+        self.orientation()
+        self.quantization()
+        self.noise()
 
 
-class _GyroscopePrints(_SensorsPrints):
+class _GyroscopePrints(_InertialSensorPrints):
     """Class that contains all gyroscope prints."""
 
-    def __init__(self, gyroscope):
-        """Initialize the class."""
-        super().__init__(gyroscope)
-
     def noise(self):
         """Prints the noise of the sensor."""
         self._general_noise()
diff --git a/rocketpy/rocket/rocket.py b/rocketpy/rocket/rocket.py
index c7bbd380a..117a6d95f 100644
--- a/rocketpy/rocket/rocket.py
+++ b/rocketpy/rocket/rocket.py
@@ -286,7 +286,7 @@ def __init__(
         self.thrust_eccentricity_y = 0
         self.thrust_eccentricity_x = 0
 
-        # Parachute, Aerodynamic, Buttons, Controllers, Sensors data initialization
+        # Parachute, Aerodynamic, Buttons, Controllers, Sensor data initialization
         self.parachutes = []
         self._controllers = []
         self.air_brakes = []
diff --git a/rocketpy/sensors/__init__.py b/rocketpy/sensors/__init__.py
index 5bfe07805..40bac14cc 100644
--- a/rocketpy/sensors/__init__.py
+++ b/rocketpy/sensors/__init__.py
@@ -1,3 +1,4 @@
 from .accelerometer import Accelerometer
+from .barometer import Barometer
 from .gyroscope import Gyroscope
-from .sensors import Sensors
+from .sensor import InertialSensor, ScalarSensor, Sensor
diff --git a/rocketpy/sensors/accelerometer.py b/rocketpy/sensors/accelerometer.py
index f4a637b66..bf67c88c1 100644
--- a/rocketpy/sensors/accelerometer.py
+++ b/rocketpy/sensors/accelerometer.py
@@ -1,20 +1,18 @@
-import json
-
 import numpy as np
 
 from ..mathutils.vector_matrix import Matrix, Vector
-from ..prints.sensors_prints import _AccelerometerPrints
-from ..sensors.sensors import Sensors
+from ..prints.sensors_prints import _InertialSensorPrints
+from ..sensors.sensor import InertialSensor
 
 
-class Accelerometer(Sensors):
+class Accelerometer(InertialSensor):
     """Class for the accelerometer sensor
 
     Attributes
     ----------
     consider_gravity : bool
         Whether the sensor considers the effect of gravity on the acceleration.
-    prints : _AccelerometerPrints
+    prints : _InertialSensorPrints
         Object that contains the print functions for the sensor.
     sampling_rate : float
         Sample rate of the sensor in Hz.
@@ -35,11 +33,11 @@ class Accelerometer(Sensors):
     constant_bias : float, list
         The constant bias of the sensor in m/s^2.
     operating_temperature : float
-        The operating temperature of the sensor in degrees Celsius.
+        The operating temperature of the sensor in Kelvin.
     temperature_bias : float, list
-        The temperature bias of the sensor in m/s^2/°C.
+        The temperature bias of the sensor in m/s^2/K.
     temperature_scale_factor : float, list
-        The temperature scale factor of the sensor in %/°C.
+        The temperature scale factor of the sensor in %/K.
     cross_axis_sensitivity : float
         The cross axis sensitivity of the sensor in percentage.
     name : str
@@ -145,15 +143,16 @@ def __init__(
             is applied to all axes. The values of each axis can be set
             individually by passing a list of length 3.
         operating_temperature : float, optional
-            The operating temperature of the sensor in degrees Celsius. At 25°C,
-            the temperature bias and scale factor are 0. Default is 25.
+            The operating temperature of the sensor in Kelvin.
+            At 298.15 K (25 °C), the sensor is assumed to operate ideally, no
+            temperature related noise is applied. Default is 298.15.
         temperature_bias : float, list, optional
-            The temperature bias of the sensor in m/s^2/°C. Default is 0,
+            The temperature bias of the sensor in m/s^2/K. Default is 0,
             meaning no temperature bias is applied. If a float or int is given,
             the same temperature bias is applied to all axes. The values of each
             axis can be set individually by passing a list of length 3.
         temperature_scale_factor : float, list, optional
-            The temperature scale factor of the sensor in %/°C. Default is 0,
+            The temperature scale factor of the sensor in %/K. Default is 0,
             meaning no temperature scale factor is applied. If a float or int is
             given, the same temperature scale factor is applied to all axes. The
             values of each axis can be set individually by passing a list of
@@ -192,29 +191,38 @@ def __init__(
             name=name,
         )
         self.consider_gravity = consider_gravity
-        self.prints = _AccelerometerPrints(self)
+        self.prints = _InertialSensorPrints(self)
 
-    def measure(self, t, u, u_dot, relative_position, gravity, *args):
+    def measure(self, time, **kwargs):
         """Measure the acceleration of the rocket
 
         Parameters
         ----------
-        t : float
-            Current time
-        u : list
-            State vector of the rocket
-        u_dot : list
-            Derivative of the state vector of the rocket
-        relative_position : Vector
-            Position of the sensor relative to the rocket cdm
-        gravity : float
-            Acceleration due to gravity
+        time : float
+            Current time in seconds.
+        kwargs : dict
+            Keyword arguments dictionary containing the following keys:
+            - u : np.array
+                State vector of the rocket.
+            - u_dot : np.array
+                Derivative of the state vector of the rocket.
+            - relative_position : np.array
+                Position of the sensor relative to the rocket center of mass.
+            - gravity : float
+                Gravitational acceleration in m/s^2.
+            - pressure : Function
+                Atmospheric pressure profile as a function of altitude in Pa.
         """
+        u = kwargs["u"]
+        u_dot = kwargs["u_dot"]
+        relative_position = kwargs["relative_position"]
+        gravity = kwargs["gravity"]
+
         # Linear acceleration of rocket cdm in inertial frame
         gravity = (
             Vector([0, 0, -gravity]) if self.consider_gravity else Vector([0, 0, 0])
         )
-        a_I = Vector(u_dot[3:6]) + gravity
+        inertial_acceleration = Vector(u_dot[3:6]) + gravity
 
         # Vector from rocket cdm to sensor in rocket frame
         r = relative_position
@@ -225,7 +233,7 @@ def measure(self, t, u, u_dot, relative_position, gravity, *args):
 
         # Measured acceleration at sensor position in inertial frame
         A = (
-            a_I
+            inertial_acceleration
             + Vector.cross(omega_dot, r)
             + Vector.cross(omega, Vector.cross(omega, r))
         )
@@ -241,17 +249,16 @@ def measure(self, t, u, u_dot, relative_position, gravity, *args):
         A = self.quantize(A)
 
         self.measurement = tuple([*A])
-        self._save_data((t, *A))
+        self._save_data((time, *A))
 
-    def export_measured_data(self, filename, format="csv"):
-        """
-        Export the measured values to a file
+    def export_measured_data(self, filename, file_format="csv"):
+        """Export the measured values to a file
 
         Parameters
         ----------
         filename : str
             Name of the file to export the values to
-        format : str
+        file_format : str
             Format of the file to export the values to. Options are "csv" and
             "json". Default is "csv".
 
@@ -259,46 +266,8 @@ def export_measured_data(self, filename, format="csv"):
         -------
         None
         """
-        if format.lower() not in ["json", "csv"]:
-            raise ValueError("Invalid format")
-        if format.lower() == "csv":
-            # if sensor has been added multiple times to the simulated rocket
-            if isinstance(self.measured_data[0], list):
-                print("Data saved to", end=" ")
-                for i, data in enumerate(self.measured_data):
-                    with open(filename + f"_{i+1}", "w") as f:
-                        f.write("t,ax,ay,az\n")
-                        for t, ax, ay, az in data:
-                            f.write(f"{t},{ax},{ay},{az}\n")
-                    print(filename + f"_{i+1},", end=" ")
-            else:
-                with open(filename, "w") as f:
-                    f.write("t,ax,ay,az\n")
-                    for t, ax, ay, az in self.measured_data:
-                        f.write(f"{t},{ax},{ay},{az}\n")
-                print(f"Data saved to {filename}")
-            return
-        if format.lower() == "json":
-            if isinstance(self.measured_data[0], list):
-                print("Data saved to", end=" ")
-                for i, data in enumerate(self.measured_data):
-                    dict = {"t": [], "ax": [], "ay": [], "az": []}
-                    for t, ax, ay, az in data:
-                        dict["t"].append(t)
-                        dict["ax"].append(ax)
-                        dict["ay"].append(ay)
-                        dict["az"].append(az)
-                    with open(filename + f"_{i+1}", "w") as f:
-                        json.dump(dict, f)
-                    print(filename + f"_{i+1},", end=" ")
-            else:
-                dict = {"t": [], "ax": [], "ay": [], "az": []}
-                for t, ax, ay, az in self.measured_data:
-                    dict["t"].append(t)
-                    dict["ax"].append(ax)
-                    dict["ay"].append(ay)
-                    dict["az"].append(az)
-                with open(filename, "w") as f:
-                    json.dump(dict, f)
-                print(f"Data saved to {filename}")
-            return
+        self._generic_export_measured_data(
+            filename=filename,
+            file_format=file_format,
+            data_labels=("t", "ax", "ay", "az"),
+        )
diff --git a/rocketpy/sensors/barometer.py b/rocketpy/sensors/barometer.py
new file mode 100644
index 000000000..fbed17f56
--- /dev/null
+++ b/rocketpy/sensors/barometer.py
@@ -0,0 +1,195 @@
+import numpy as np
+
+from ..mathutils.vector_matrix import Matrix
+from ..prints.sensors_prints import _SensorPrints
+from ..sensors.sensor import ScalarSensor
+
+
+class Barometer(ScalarSensor):
+    """Class for the barometer sensor
+
+    Attributes
+    ----------
+    prints : _SensorPrints
+        Object that contains the print functions for the sensor.
+    sampling_rate : float
+        Sample rate of the sensor in Hz.
+    orientation : tuple, list
+        Orientation of the sensor in the rocket.
+    measurement_range : float, tuple
+        The measurement range of the sensor in Pa.
+    resolution : float
+        The resolution of the sensor in Pa/LSB.
+    noise_density : float
+        The noise density of the sensor in Pa/√Hz.
+    noise_variance : float
+        The variance of the noise of the sensor in Pa^2.
+    random_walk_density : float
+        The random walk density of the sensor in Pa/√Hz.
+    random_walk_variance : float
+        The variance of the random walk of the sensor in Pa^2.
+    constant_bias : float
+        The constant bias of the sensor in Pa.
+    operating_temperature : float
+        The operating temperature of the sensor in Kelvin.
+    temperature_bias : float
+        The temperature bias of the sensor in Pa/K.
+    temperature_scale_factor : float
+        The temperature scale factor of the sensor in %/K.
+    name : str
+        The name of the sensor.
+    measurement : float
+        The measurement of the sensor after quantization, noise and temperature
+        drift.
+    measured_data : list
+        The stored measured data of the sensor after quantization, noise and
+        temperature drift.
+    """
+
+    units = "Pa"
+
+    def __init__(
+        self,
+        sampling_rate,
+        measurement_range=np.inf,
+        resolution=0,
+        noise_density=0,
+        noise_variance=1,
+        random_walk_density=0,
+        random_walk_variance=1,
+        constant_bias=0,
+        operating_temperature=25,
+        temperature_bias=0,
+        temperature_scale_factor=0,
+        name="Barometer",
+    ):
+        """
+        Initialize the barometer sensor
+
+        Parameters
+        ----------
+        sampling_rate : float
+            Sample rate of the sensor in Hz.
+        measurement_range : float, tuple, optional
+            The measurement range of the sensor in the Pa. If a float, the same
+            range is applied both for positive and negative values. If a tuple,
+            the first value is the positive range and the second value is the
+            negative range. Default is np.inf.
+        resolution : float, optional
+            The resolution of the sensor in Pa/LSB. Default is 0, meaning no
+            quantization is applied.
+        noise_density : float, optional
+            The noise density of the sensor for a Gaussian white noise in Pa/√Hz.
+            Sometimes called "white noise drift", "angular random walk" for
+            gyroscopes, "velocity random walk" for accelerometers or
+            "(rate) noise density". Default is 0, meaning no noise is applied.
+        noise_variance : float, optional
+            The noise variance of the sensor for a Gaussian white noise in Pa^2.
+            Default is 1, meaning the noise is normally distributed with a
+            standard deviation of 1 Pa.
+        random_walk_density : float, optional
+            The random walk of the sensor for a Gaussian random walk in Pa/√Hz.
+            Sometimes called "bias (in)stability" or "bias drift"". Default is 0,
+            meaning no random walk is applied.
+        random_walk_variance : float, optional
+            The random walk variance of the sensor for a Gaussian random walk in
+            Pa^2. Default is 1, meaning the noise is normally distributed with a
+            standard deviation of 1 Pa.
+        constant_bias : float, optional
+            The constant bias of the sensor in Pa. Default is 0, meaning no
+            constant bias is applied.
+        operating_temperature : float, optional
+            The operating temperature of the sensor in Kelvin.
+            At 298.15 K (25 °C), the sensor is assumed to operate ideally, no
+            temperature related noise is applied. Default is 298.15.
+        temperature_bias : float, optional
+            The temperature bias of the sensor in Pa/K. Default is 0, meaning no
+            temperature bias is applied.
+        temperature_scale_factor : float, optional
+            The temperature scale factor of the sensor in %/K. Default is 0,
+            meaning no temperature scale factor is applied.
+        name : str, optional
+            The name of the sensor. Default is "Barometer".
+
+        Returns
+        -------
+        None
+
+        See Also
+        --------
+        TODO link to documentation on noise model
+        """
+        super().__init__(
+            sampling_rate=sampling_rate,
+            measurement_range=measurement_range,
+            resolution=resolution,
+            noise_density=noise_density,
+            noise_variance=noise_variance,
+            random_walk_density=random_walk_density,
+            random_walk_variance=random_walk_variance,
+            constant_bias=constant_bias,
+            operating_temperature=operating_temperature,
+            temperature_bias=temperature_bias,
+            temperature_scale_factor=temperature_scale_factor,
+            name=name,
+        )
+        self.prints = _SensorPrints(self)
+
+    def measure(self, time, **kwargs):
+        """Measures the pressure at barometer location
+
+        Parameters
+        ----------
+        time : float
+            Current time in seconds.
+        kwargs : dict
+            Keyword arguments dictionary containing the following keys:
+            - u : np.array
+                State vector of the rocket.
+            - u_dot : np.array
+                Derivative of the state vector of the rocket.
+            - relative_position : np.array
+                Position of the sensor relative to the rocket center of mass.
+            - gravity : float
+                Gravitational acceleration in m/s^2.
+            - pressure : Function
+                Atmospheric pressure profile as a function of altitude in Pa.
+            - elevation : float
+                Elevation of the launch site in meters.
+        """
+        u = kwargs["u"]
+        relative_position = kwargs["relative_position"]
+        pressure = kwargs["pressure"]
+
+        # Calculate the altitude of the sensor
+        relative_altitude = (Matrix.transformation(u[6:10]) @ relative_position).z
+
+        # Calculate the pressure at the sensor location and add noise
+        P = pressure(relative_altitude + u[2])
+        P = self.apply_noise(P)
+        P = self.apply_temperature_drift(P)
+        P = self.quantize(P)
+
+        self.measurement = P
+        self._save_data((time, P))
+
+    def export_measured_data(self, filename, file_format="csv"):
+        """Export the measured values to a file
+
+        Parameters
+        ----------
+        filename : str
+            Name of the file to export the values to
+        file_format : str
+            file_format of the file to export the values to. Options are "csv" and
+            "json". Default is "csv".
+
+        Returns
+        -------
+        None
+        """
+        self._generic_export_measured_data(
+            filename=filename,
+            file_format=file_format,
+            data_labels=("t", "pressure"),
+        )
diff --git a/rocketpy/sensors/gyroscope.py b/rocketpy/sensors/gyroscope.py
index 26df61d4d..049cde52d 100644
--- a/rocketpy/sensors/gyroscope.py
+++ b/rocketpy/sensors/gyroscope.py
@@ -1,13 +1,11 @@
-import json
-
 import numpy as np
 
 from ..mathutils.vector_matrix import Matrix, Vector
 from ..prints.sensors_prints import _GyroscopePrints
-from ..sensors.sensors import Sensors
+from ..sensors.sensor import InertialSensor
 
 
-class Gyroscope(Sensors):
+class Gyroscope(InertialSensor):
     """Class for the gyroscope sensor
 
     Attributes
@@ -35,11 +33,11 @@ class Gyroscope(Sensors):
     constant_bias : float, list
         The constant bias of the sensor in rad/s.
     operating_temperature : float
-        The operating temperature of the sensor in degrees Celsius.
+        The operating temperature of the sensor in Kelvin.
     temperature_bias : float, list
-        The temperature bias of the sensor in rad/s/°C.
+        The temperature bias of the sensor in rad/s/K.
     temperature_scale_factor : float, list
-        The temperature scale factor of the sensor in %/°C.
+        The temperature scale factor of the sensor in %/K.
     cross_axis_sensitivity : float
         The cross axis sensitivity of the sensor in percentage.
     name : str
@@ -143,15 +141,16 @@ def __init__(
             is applied to all axes. The values of each axis can be set
             individually by passing a list of length 3.
         operating_temperature : float, optional
-            The operating temperature of the sensor in degrees Celsius. At 25°C,
-            the temperature bias and scale factor are 0. Default is 25.
+            The operating temperature of the sensor in Kelvin.
+            At 298.15 K (25 °C), the sensor is assumed to operate ideally, no
+            temperature related noise is applied. Default is 298.15.
         temperature_sensitivity : float, list, optional
-            The temperature bias of the sensor in rad/s/°C. Default is 0,
+            The temperature bias of the sensor in rad/s/K. Default is 0,
             meaning no temperature bias is applied. If a float or int is given,
             the same temperature bias is applied to all axes. The values of each
             axis can be set individually by passing a list of length 3.
         temperature_scale_factor : float, list, optional
-            The temperature scale factor of the sensor in %/°C. Default is 0,
+            The temperature scale factor of the sensor in %/K. Default is 0,
             meaning no temperature scale factor is applied. If a float or int is
             given, the same temperature scale factor is applied to all axes. The
             values of each axis can be set individually by passing a list of
@@ -196,20 +195,30 @@ def __init__(
         )
         self.prints = _GyroscopePrints(self)
 
-    def measure(self, t, u, u_dot, relative_position, *args):
+    def measure(self, time, **kwargs):
         """Measure the angular velocity of the rocket
 
         Parameters
         ----------
-        t : float
-            Time at which the measurement is taken
-        u : list
-            State vector of the rocket
-        u_dot : list
-            Time derivative of the state vector of the rocket
-        relative_position : Vector
-            Vector from the rocket's center of mass to the sensor
+        time : float
+            Current time in seconds.
+        kwargs : dict
+            Keyword arguments dictionary containing the following keys:
+            - u : np.array
+                State vector of the rocket.
+            - u_dot : np.array
+                Derivative of the state vector of the rocket.
+            - relative_position : np.array
+                Position of the sensor relative to the rocket center of mass.
+            - gravity : float
+                Gravitational acceleration in m/s^2.
+            - pressure : Function
+                Atmospheric pressure profile as a function of altitude in Pa.
         """
+        u = kwargs["u"]
+        u_dot = kwargs["u_dot"]
+        relative_position = kwargs["relative_position"]
+
         # Angular velocity of the rocket in the rocket frame
         omega = Vector(u[10:13])
 
@@ -233,7 +242,7 @@ def measure(self, t, u, u_dot, relative_position, *args):
         W = self.quantize(W)
 
         self.measurement = tuple([*W])
-        self._save_data((t, *W))
+        self._save_data((time, *W))
 
     def apply_acceleration_sensitivity(
         self, omega, u_dot, relative_position, rotation_matrix
@@ -258,14 +267,14 @@ def apply_acceleration_sensitivity(
             The angular velocity with the acceleration sensitivity applied
         """
         # Linear acceleration of rocket cdm in inertial frame
-        a_I = Vector(u_dot[3:6])
+        inertial_acceleration = Vector(u_dot[3:6])
 
         # Angular velocity and accel of rocket
         omega_dot = Vector(u_dot[10:13])
 
         # Acceleration felt in sensor
         A = (
-            a_I
+            inertial_acceleration
             + Vector.cross(omega_dot, relative_position)
             + Vector.cross(omega, Vector.cross(omega, relative_position))
         )
@@ -274,62 +283,23 @@ def apply_acceleration_sensitivity(
 
         return self.acceleration_sensitivity & A
 
-    def export_measured_data(self, filename, format="csv"):
-        """
-        Export the measured values to a file
+    def export_measured_data(self, filename, file_format="csv"):
+        """Export the measured values to a file
 
         Parameters
         ----------
         filename : str
             Name of the file to export the values to
-        format : str
-            Format of the file to export the values to. Options are "csv" and
+        file_format : str
+            file_Format of the file to export the values to. Options are "csv" and
             "json". Default is "csv".
 
         Returns
         -------
         None
         """
-        if format.lower() not in ["csv", "json"]:
-            raise ValueError("Invalid format")
-        if format.lower() == "csv":
-            # if sensor has been added multiple times to the simulated rocket
-            if isinstance(self.measured_data[0], list):
-                print("Data saved to", end=" ")
-                for i, data in enumerate(self.measured_data):
-                    with open(filename + f"_{i+1}", "w") as f:
-                        f.write("t,wx,wy,wz\n")
-                        for t, wx, wy, wz in data:
-                            f.write(f"{t},{wx},{wy},{wz}\n")
-                    print(filename + f"_{i+1},", end=" ")
-            else:
-                with open(filename, "w") as f:
-                    f.write("t,wx,wy,wz\n")
-                    for t, wx, wy, wz in self.measured_data:
-                        f.write(f"{t},{wx},{wy},{wz}\n")
-                print(f"Data saved to {filename}")
-            return
-        if format.lower() == "json":
-            if isinstance(self.measured_data[0], list):
-                print("Data saved to", end=" ")
-                for i, data in enumerate(self.measured_data):
-                    dict = {"t": [], "wx": [], "wy": [], "wz": []}
-                    for t, wx, wy, wz in data:
-                        dict["t"].append(t)
-                        dict["wx"].append(wx)
-                        dict["wy"].append(wy)
-                        dict["wz"].append(wz)
-                    with open(filename + f"_{i+1}", "w") as f:
-                        json.dump(dict, f)
-                    print(filename + f"_{i+1},", end=" ")
-            else:
-                dict = {"t": [], "wx": [], "wy": [], "wz": []}
-                for t, wx, wy, wz in self.measured_data:
-                    dict["t"].append(t)
-                    dict["wx"].append(wx)
-                    dict["wy"].append(wy)
-                    dict["wz"].append(wz)
-                with open(filename, "w") as f:
-                    json.dump(dict, f)
-                print(f"Data saved to {filename}")
-            return
+        self._generic_export_measured_data(
+            filename=filename,
+            file_format=file_format,
+            data_labels=("t", "wx", "wy", "wz"),
+        )
diff --git a/rocketpy/sensors/sensor.py b/rocketpy/sensors/sensor.py
new file mode 100644
index 000000000..8b0de3b6e
--- /dev/null
+++ b/rocketpy/sensors/sensor.py
@@ -0,0 +1,778 @@
+import json
+from abc import ABC, abstractmethod
+
+import numpy as np
+
+from rocketpy.mathutils.vector_matrix import Matrix, Vector
+
+
+class Sensor(ABC):
+    """Abstract class for sensors
+
+    Attributes
+    ----------
+    sampling_rate : float
+        Sample rate of the sensor in Hz.
+    measurement_range : float, tuple
+        The measurement range of the sensor in the sensor units.
+    resolution : float
+        The resolution of the sensor in sensor units/LSB.
+    noise_density : float, list
+        The noise density of the sensor in sensor units/√Hz.
+    noise_variance : float, list
+        The variance of the noise of the sensor in sensor units^2.
+    random_walk_density : float, list
+        The random walk density of the sensor in sensor units/√Hz.
+    random_walk_variance : float, list
+        The variance of the random walk of the sensor in sensor units^2.
+    constant_bias : float, list
+        The constant bias of the sensor in sensor units.
+    operating_temperature : float
+        The operating temperature of the sensor in Kelvin.
+    temperature_bias : float, list
+        The temperature bias of the sensor in sensor units/K.
+    temperature_scale_factor : float, list
+        The temperature scale factor of the sensor in %/K.
+    name : str
+        The name of the sensor.
+    measurement : float
+        The measurement of the sensor after quantization, noise and temperature
+        drift.
+    measured_data : list
+        The stored measured data of the sensor after quantization, noise and
+        temperature drift.
+    """
+
+    def __init__(
+        self,
+        sampling_rate,
+        measurement_range=np.inf,
+        resolution=0,
+        noise_density=0,
+        noise_variance=1,
+        random_walk_density=0,
+        random_walk_variance=1,
+        constant_bias=0,
+        operating_temperature=25,
+        temperature_bias=0,
+        temperature_scale_factor=0,
+        name="Sensor",
+    ):
+        """
+        Initialize the accelerometer sensor
+
+        Parameters
+        ----------
+        sampling_rate : float
+            Sample rate of the sensor
+        measurement_range : float, tuple, optional
+            The measurement range of the sensor in the sensor units. If a float,
+            the same range is applied both for positive and negative values. If
+            a tuple, the first value is the positive range and the second value
+            is the negative range. Default is np.inf.
+        resolution : float, optional
+            The resolution of the sensor in sensor units/LSB. Default is 0,
+            meaning no quantization is applied.
+        noise_density : float, list, optional
+            The noise density of the sensor for a Gaussian white noise in sensor
+            units/√Hz. Sometimes called "white noise drift",
+            "angular random walk" for gyroscopes, "velocity random walk" for
+            accelerometers or "(rate) noise density". Default is 0, meaning no
+            noise is applied.
+        noise_variance : float, list, optional
+            The noise variance of the sensor for a Gaussian white noise in
+            sensor units^2. Default is 1, meaning the noise is normally
+            distributed with a standard deviation of 1 unit.
+        random_walk_density : float, list, optional
+            The random walk density of the sensor for a Gaussian random walk in
+            sensor units/√Hz. Sometimes called "bias (in)stability" or
+            "bias drift". Default is 0, meaning no random walk is applied.
+        random_walk_variance : float, list, optional
+            The random walk variance of the sensor for a Gaussian random walk in
+            sensor units^2. Default is 1, meaning the noise is normally
+            distributed with a standard deviation of 1 unit.
+        constant_bias : float, list, optional
+            The constant bias of the sensor in sensor units. Default is 0,
+            meaning no constant bias is applied.
+        operating_temperature : float, optional
+            The operating temperature of the sensor in Kelvin.
+            At 298.15 K (25 °C), the sensor is assumed to operate ideally, no
+            temperature related noise is applied. Default is 298.15.
+        temperature_bias : float, list, optional
+            The temperature bias of the sensor in sensor units/K. Default is 0,
+            meaning no temperature bias is applied.
+        temperature_scale_factor : float, list, optional
+            The temperature scale factor of the sensor in %/K. Default is 0,
+            meaning no temperature scale factor is applied.
+        name : str, optional
+            The name of the sensor. Default is "Sensor".
+
+        Returns
+        -------
+        None
+
+        See Also
+        --------
+        TODO link to documentation on noise model
+        """
+        self.sampling_rate = sampling_rate
+        self.resolution = resolution
+        self.operating_temperature = operating_temperature
+        self.noise_density = noise_density
+        self.noise_variance = noise_variance
+        self.random_walk_density = random_walk_density
+        self.random_walk_variance = random_walk_variance
+        self.constant_bias = constant_bias
+        self.temperature_bias = temperature_bias
+        self.temperature_scale_factor = temperature_scale_factor
+        self.name = name
+        self.measurement = None
+        self.measured_data = []
+        self._counter = 0
+        self._save_data = self._save_data_single
+        self._random_walk_drift = 0
+        self.normal_vector = Vector([0, 0, 0])
+
+        # handle measurement range
+        if isinstance(measurement_range, (tuple, list)):
+            if len(measurement_range) != 2:
+                raise ValueError("Invalid measurement range format")
+            self.measurement_range = measurement_range
+        elif isinstance(measurement_range, (int, float)):
+            self.measurement_range = (-measurement_range, measurement_range)
+        else:
+            raise ValueError("Invalid measurement range format")
+
+        # map which rocket(s) the sensor is attached to and how many times
+        self._attached_rockets = {}
+
+    def __repr__(self):
+        return f"{self.name}"
+
+    def __call__(self, *args, **kwargs):
+        return self.measure(*args, **kwargs)
+
+    def _reset(self, simulated_rocket):
+        """Reset the sensor data for a new simulation."""
+        self._random_walk_drift = (
+            Vector([0, 0, 0]) if isinstance(self._random_walk_drift, Vector) else 0
+        )
+        self.measured_data = []
+        if self._attached_rockets[simulated_rocket] > 1:
+            self.measured_data = [
+                [] for _ in range(self._attached_rockets[simulated_rocket])
+            ]
+            self._save_data = self._save_data_multiple
+        else:
+            self._save_data = self._save_data_single
+
+    def _save_data_single(self, data):
+        """Save the measured data to the sensor data list for a sensor that is
+        added only once to the simulated rocket."""
+        self.measured_data.append(data)
+
+    def _save_data_multiple(self, data):
+        """Save the measured data to the sensor data list for a sensor that is
+        added multiple times to the simulated rocket."""
+        self.measured_data[self._counter].append(data)
+        # counter for cases where the sensor is added multiple times in a rocket
+        self._counter += 1
+        if self._counter == len(self.measured_data):
+            self._counter = 0
+
+    @abstractmethod
+    def measure(self, time, **kwargs):
+        """Measure the sensor data at a given time"""
+        pass
+
+    @abstractmethod
+    def quantize(self, value):
+        """Quantize the sensor measurement"""
+        pass
+
+    @abstractmethod
+    def apply_noise(self, value):
+        """Add noise to the sensor measurement"""
+        pass
+
+    @abstractmethod
+    def apply_temperature_drift(self, value):
+        """Apply temperature drift to the sensor measurement"""
+        pass
+
+    @abstractmethod
+    def export_measured_data(self, filename, file_format="csv"):
+        """Export the measured values to a file"""
+        pass
+
+    def _generic_export_measured_data(self, filename, file_format, data_labels):
+        """Export the measured values to a file given the data labels of each
+        sensor.
+
+        Parameters
+        ----------
+        sensor : Sensor
+            Sensor object to export the measured values from.
+        filename : str
+            Name of the file to export the values to
+        file_format : str
+            file_format of the file to export the values to. Options are "csv"
+            and "json". Default is "csv".
+        data_labels : tuple
+            Tuple of strings representing the labels for the data columns
+
+        Returns
+        -------
+        None
+        """
+        if file_format.lower() not in ["json", "csv"]:
+            raise ValueError("Invalid file_format")
+
+        if file_format.lower() == "csv":
+            # if sensor has been added multiple times to the simulated rocket
+            if isinstance(self.measured_data[0], list):
+                print("Data saved to", end=" ")
+                for i, data in enumerate(self.measured_data):
+                    with open(filename + f"_{i+1}", "w") as f:
+                        f.write(",".join(data_labels) + "\n")
+                        for entry in data:
+                            f.write(",".join(map(str, entry)) + "\n")
+                    print(filename + f"_{i+1},", end=" ")
+            else:
+                with open(filename, "w") as f:
+                    f.write(",".join(data_labels) + "\n")
+                    for entry in self.measured_data:
+                        f.write(",".join(map(str, entry)) + "\n")
+                print(f"Data saved to {filename}")
+            return
+
+        if file_format.lower() == "json":
+            if isinstance(self.measured_data[0], list):
+                print("Data saved to", end=" ")
+                for i, data in enumerate(self.measured_data):
+                    data_dict = {label: [] for label in data_labels}
+                    for entry in data:
+                        for label, value in zip(data_labels, entry):
+                            data_dict[label].append(value)
+                    with open(filename + f"_{i+1}", "w") as f:
+                        json.dump(data_dict, f)
+                    print(filename + f"_{i+1},", end=" ")
+            else:
+                data_dict = {label: [] for label in data_labels}
+                for entry in self.measured_data:
+                    for label, value in zip(data_labels, entry):
+                        data_dict[label].append(value)
+                with open(filename, "w") as f:
+                    json.dump(data_dict, f)
+                print(f"Data saved to {filename}")
+            return
+
+
+class InertialSensor(Sensor):
+    """Model of an inertial sensor (accelerometer, gyroscope, magnetometer).
+    Inertial sensors measurements are handled as vectors. The measurements are
+    affected by the sensor's orientation in the rocket.
+
+    Attributes
+    ----------
+    sampling_rate : float
+        Sample rate of the sensor in Hz.
+    orientation : tuple, list
+        Orientation of the sensor in the rocket.
+    measurement_range : float, tuple
+        The measurement range of the sensor in the sensor units.
+    resolution : float
+        The resolution of the sensor in sensor units/LSB.
+    noise_density : float, list
+        The noise density of the sensor in sensor units/√Hz.
+    noise_variance : float, list
+        The variance of the noise of the sensor in sensor units^2.
+    random_walk_density : float, list
+        The random walk density of the sensor in sensor units/√Hz.
+    random_walk_variance : float, list
+        The variance of the random walk of the sensor in sensor units^2.
+    constant_bias : float, list
+        The constant bias of the sensor in sensor units.
+    operating_temperature : float
+        The operating temperature of the sensor in Kelvin.
+    temperature_bias : float, list
+        The temperature bias of the sensor in sensor units/K.
+    temperature_scale_factor : float, list
+        The temperature scale factor of the sensor in %/K.
+    cross_axis_sensitivity : float
+        The cross axis sensitivity of the sensor in percentage.
+    name : str
+        The name of the sensor.
+    rotation_matrix : Matrix
+        The rotation matrix of the sensor from the sensor frame to the rocket
+        frame of reference.
+    normal_vector : Vector
+        The normal vector of the sensor in the rocket frame of reference.
+    measurement : float
+        The measurement of the sensor after quantization, noise and temperature
+        drift.
+    measured_data : list
+        The stored measured data of the sensor after quantization, noise and
+        temperature drift.
+    """
+
+    def __init__(
+        self,
+        sampling_rate,
+        orientation=(0, 0, 0),
+        measurement_range=np.inf,
+        resolution=0,
+        noise_density=0,
+        noise_variance=1,
+        random_walk_density=0,
+        random_walk_variance=1,
+        constant_bias=0,
+        operating_temperature=298.15,
+        temperature_bias=0,
+        temperature_scale_factor=0,
+        cross_axis_sensitivity=0,
+        name="Sensor",
+    ):
+        """
+        Initialize the accelerometer sensor
+
+        Parameters
+        ----------
+        sampling_rate : float
+            Sample rate of the sensor
+        orientation : tuple, list, optional
+            Orientation of the sensor in the rocket. The orientation can be
+            given as:
+            - A list of length 3, where the elements are the Euler angles for
+              the rotation yaw (ψ), pitch (θ) and roll (φ) in radians. The
+              standard rotation sequence is z-y-x (3-2-1) is used, meaning the
+              sensor is first rotated by ψ around the x axis, then by θ around
+              the new y axis and finally by φ around the new z axis.
+              TODO: x and y are not defined in the rocket class. User has no
+              way to know which axis is which.
+            - A list of lists (matrix) of shape 3x3, representing the rotation
+              matrix from the sensor frame to the rocket frame. The sensor frame
+              of reference is defined as to have z axis along the sensor's normal
+              vector pointing upwards, x and y axes perpendicular to the z axis
+              and each other.
+            The rocket frame of reference is defined as to have z axis
+            along the rocket's axis of symmetry pointing upwards, x and y axes
+            perpendicular to the z axis and each other. Default is (0, 0, 0),
+            meaning the sensor is aligned with the rocket's axis of symmetry.
+        measurement_range : float, tuple, optional
+            The measurement range of the sensor in the sensor units. If a float,
+            the same range is applied both for positive and negative values. If
+            a tuple, the first value is the positive range and the second value
+            is the negative range. Default is np.inf.
+        resolution : float, optional
+            The resolution of the sensor in sensor units/LSB. Default is 0,
+            meaning no quantization is applied.
+        noise_density : float, list, optional
+            The noise density of the sensor for a Gaussian white noise in sensor
+            units/√Hz. Sometimes called "white noise drift",
+            "angular random walk" for gyroscopes, "velocity random walk" for
+            accelerometers or "(rate) noise density". Default is 0, meaning no
+            noise is applied. If a float or int is given, the same noise density
+            is applied to all axes. The values of each axis can be set
+            individually by passing a list of length 3.
+        noise_variance : float, list, optional
+            The noise variance of the sensor for a Gaussian white noise in
+            sensor units^2. Default is 1, meaning the noise is normally
+            distributed with a standard deviation of 1 unit. If a float or int
+            is given, the same noise variance is applied to all axes. The values
+            of each axis can be set individually by passing a list of length 3.
+        random_walk_density : float, list, optional
+            The random walk density of the sensor for a Gaussian random walk in
+            sensor units/√Hz. Sometimes called "bias (in)stability" or
+            "bias drift". Default is 0, meaning no random walk is applied.
+            If a float or int is given, the same random walk is applied to all
+            axes. The values of each axis can be set individually by passing a
+            list of length 3.
+        random_walk_variance : float, list, optional
+            The random walk variance of the sensor for a Gaussian random walk in
+            sensor units^2. Default is 1, meaning the noise is normally
+            distributed with a standard deviation of 1 unit. If a float or int
+            is given, the same random walk variance is applied to all axes. The
+            values of each axis can be set individually by passing a list of
+            length 3.
+        constant_bias : float, list, optional
+            The constant bias of the sensor in sensor units. Default is 0,
+            meaning no constant bias is applied. If a float or int is given, the
+            same constant bias is applied to all axes. The values of each axis
+            can be set individually by passing a list of length 3.
+        operating_temperature : float, optional
+            The operating temperature of the sensor in Kelvin.
+            At 298.15 K (25 °C), the sensor is assumed to operate ideally, no
+            temperature related noise is applied. Default is 298.15.
+        temperature_bias : float, list, optional
+            The temperature bias of the sensor in sensor units/K. Default is 0,
+            meaning no temperature bias is applied. If a float or int is given,
+            the same temperature bias is applied to all axes. The values of each
+            axis can be set individually by passing a list of length 3.
+        temperature_scale_factor : float, list, optional
+            The temperature scale factor of the sensor in %/K. Default is 0,
+            meaning no temperature scale factor is applied. If a float or int is
+            given, the same temperature scale factor is applied to all axes. The
+            values of each axis can be set individually by passing a list of
+            length 3.
+        cross_axis_sensitivity : float, optional
+            Skewness of the sensor's axes in percentage. Default is 0, meaning
+            no cross-axis sensitivity is applied.
+        name : str, optional
+            The name of the sensor. Default is "Sensor".
+
+        Returns
+        -------
+        None
+
+        See Also
+        --------
+        TODO link to documentation on noise model
+        """
+        super().__init__(
+            sampling_rate=sampling_rate,
+            measurement_range=measurement_range,
+            resolution=resolution,
+            noise_density=self._vectorize_input(noise_density, "noise_density"),
+            noise_variance=self._vectorize_input(noise_variance, "noise_variance"),
+            random_walk_density=self._vectorize_input(
+                random_walk_density, "random_walk_density"
+            ),
+            random_walk_variance=self._vectorize_input(
+                random_walk_variance, "random_walk_variance"
+            ),
+            constant_bias=self._vectorize_input(constant_bias, "constant_bias"),
+            operating_temperature=operating_temperature,
+            temperature_bias=self._vectorize_input(
+                temperature_bias, "temperature_bias"
+            ),
+            temperature_scale_factor=self._vectorize_input(
+                temperature_scale_factor, "temperature_scale_factor"
+            ),
+            name=name,
+        )
+
+        self.orientation = orientation
+        self.cross_axis_sensitivity = cross_axis_sensitivity
+        self._random_walk_drift = Vector([0, 0, 0])
+
+        # rotation matrix and normal vector
+        if any(isinstance(row, (tuple, list)) for row in orientation):  # matrix
+            self.rotation_matrix = Matrix(orientation)
+        elif len(orientation) == 3:  # euler angles
+            self.rotation_matrix = Matrix.transformation_euler_angles(
+                *orientation
+            ).round(12)
+        else:
+            raise ValueError("Invalid orientation format")
+        self.normal_vector = Vector(
+            [
+                self.rotation_matrix[0][2],
+                self.rotation_matrix[1][2],
+                self.rotation_matrix[2][2],
+            ]
+        ).unit_vector
+
+        # cross axis sensitivity matrix
+        _cross_axis_matrix = 0.01 * Matrix(
+            [
+                [100, self.cross_axis_sensitivity, self.cross_axis_sensitivity],
+                [self.cross_axis_sensitivity, 100, self.cross_axis_sensitivity],
+                [self.cross_axis_sensitivity, self.cross_axis_sensitivity, 100],
+            ]
+        )
+
+        # compute total rotation matrix given cross axis sensitivity
+        self._total_rotation_matrix = self.rotation_matrix @ _cross_axis_matrix
+
+    def _vectorize_input(self, value, name):
+        if isinstance(value, (int, float)):
+            return Vector([value, value, value])
+        elif isinstance(value, (tuple, list)):
+            return Vector(value)
+        else:
+            raise ValueError(f"Invalid {name} format")
+
+    def quantize(self, value):
+        """
+        Quantize the sensor measurement
+
+        Parameters
+        ----------
+        value : float
+            The value to quantize
+
+        Returns
+        -------
+        float
+            The quantized value
+        """
+        x = min(max(value.x, self.measurement_range[0]), self.measurement_range[1])
+        y = min(max(value.y, self.measurement_range[0]), self.measurement_range[1])
+        z = min(max(value.z, self.measurement_range[0]), self.measurement_range[1])
+        if self.resolution != 0:
+            x = round(x / self.resolution) * self.resolution
+            y = round(y / self.resolution) * self.resolution
+            z = round(z / self.resolution) * self.resolution
+        return Vector([x, y, z])
+
+    def apply_noise(self, value):
+        """
+        Add noise to the sensor measurement
+
+        Parameters
+        ----------
+        value : float
+            The value to add noise to
+
+        Returns
+        -------
+        float
+            The value with added noise
+        """
+        # white noise
+        white_noise = Vector(
+            [np.random.normal(0, self.noise_variance[i] ** 0.5) for i in range(3)]
+        ) & (self.noise_density * self.sampling_rate**0.5)
+
+        # random walk
+        self._random_walk_drift = self._random_walk_drift + Vector(
+            [np.random.normal(0, self.random_walk_variance[i] ** 0.5) for i in range(3)]
+        ) & (self.random_walk_density / self.sampling_rate**0.5)
+
+        # add noise
+        value += white_noise + self._random_walk_drift + self.constant_bias
+
+        return value
+
+    def apply_temperature_drift(self, value):
+        """
+        Apply temperature drift to the sensor measurement
+
+        Parameters
+        ----------
+        value : float
+            The value to apply temperature drift to
+
+        Returns
+        -------
+        float
+            The value with applied temperature drift
+        """
+        # temperature drift
+        value += (self.operating_temperature - 298.15) * self.temperature_bias
+        # temperature scale factor
+        scale_factor = (
+            Vector([1, 1, 1])
+            + (self.operating_temperature - 298.15)
+            / 100
+            * self.temperature_scale_factor
+        )
+        return value & scale_factor
+
+
+class ScalarSensor(Sensor):
+    """Model of a scalar sensor (barometer, GPS, etc.). Scalar sensors are used
+    to measure a single scalar value. The measurements are not affected by the
+    sensor's orientation in the rocket.
+
+    Attributes
+    ----------
+    sampling_rate : float
+        Sample rate of the sensor in Hz.
+    measurement_range : float, tuple
+        The measurement range of the sensor in the sensor units.
+    resolution : float
+        The resolution of the sensor in sensor units/LSB.
+    noise_density : float
+        The noise density of the sensor in sensor units/√Hz.
+    noise_variance : float
+        The variance of the noise of the sensor in sensor units^2.
+    random_walk_density : float
+        The random walk density of the sensor in sensor units/√Hz.
+    random_walk_variance : float
+        The variance of the random walk of the sensor in sensor units^2.
+    constant_bias : float
+        The constant bias of the sensor in sensor units.
+    operating_temperature : float
+        The operating temperature of the sensor in Kelvin.
+    temperature_bias : float
+        The temperature bias of the sensor in sensor units/K.
+    temperature_scale_factor : float
+        The temperature scale factor of the sensor in %/K.
+    name : str
+        The name of the sensor.
+    measurement : float
+        The measurement of the sensor after quantization, noise and temperature
+        drift.
+    measured_data : list
+        The stored measured data of the sensor after quantization, noise and
+        temperature drift.
+    """
+
+    def __init__(
+        self,
+        sampling_rate,
+        measurement_range=np.inf,
+        resolution=0,
+        noise_density=0,
+        noise_variance=1,
+        random_walk_density=0,
+        random_walk_variance=1,
+        constant_bias=0,
+        operating_temperature=25,
+        temperature_bias=0,
+        temperature_scale_factor=0,
+        name="Sensor",
+    ):
+        """
+        Initialize the accelerometer sensor
+
+        Parameters
+        ----------
+        sampling_rate : float
+            Sample rate of the sensor
+        measurement_range : float, tuple, optional
+            The measurement range of the sensor in the sensor units. If a float,
+            the same range is applied both for positive and negative values. If
+            a tuple, the first value is the positive range and the second value
+            is the negative range. Default is np.inf.
+        resolution : float, optional
+            The resolution of the sensor in sensor units/LSB. Default is 0,
+            meaning no quantization is applied.
+        noise_density : float, list, optional
+            The noise density of the sensor for a Gaussian white noise in sensor
+            units/√Hz. Sometimes called "white noise drift",
+            "angular random walk" for gyroscopes, "velocity random walk" for
+            accelerometers or "(rate) noise density". Default is 0, meaning no
+            noise is applied.
+        noise_variance : float, list, optional
+            The noise variance of the sensor for a Gaussian white noise in
+            sensor units^2. Default is 1, meaning the noise is normally
+            distributed with a standard deviation of 1 unit.
+        random_walk_density : float, list, optional
+            The random walk density of the sensor for a Gaussian random walk in
+            sensor units/√Hz. Sometimes called "bias (in)stability" or
+            "bias drift". Default is 0, meaning no random walk is applied.
+        random_walk_variance : float, list, optional
+            The random walk variance of the sensor for a Gaussian random walk in
+            sensor units^2. Default is 1, meaning the noise is normally
+            distributed with a standard deviation of 1 unit.
+        constant_bias : float, list, optional
+            The constant bias of the sensor in sensor units. Default is 0,
+            meaning no constant bias is applied.
+        operating_temperature : float, optional
+            The operating temperature of the sensor in Kelvin.
+            At 298.15 K (25 °C), the sensor is assumed to operate ideally, no
+            temperature related noise is applied. Default is 298.15.
+        temperature_bias : float, list, optional
+            The temperature bias of the sensor in sensor units/K. Default is 0,
+            meaning no temperature bias is applied.
+        temperature_scale_factor : float, list, optional
+            The temperature scale factor of the sensor in %/K. Default is 0,
+            meaning no temperature scale factor is applied.
+        name : str, optional
+            The name of the sensor. Default is "Sensor".
+
+        Returns
+        -------
+        None
+
+        See Also
+        --------
+        TODO link to documentation on noise model
+        """
+        super().__init__(
+            sampling_rate=sampling_rate,
+            measurement_range=measurement_range,
+            resolution=resolution,
+            noise_density=noise_density,
+            noise_variance=noise_variance,
+            random_walk_density=random_walk_density,
+            random_walk_variance=random_walk_variance,
+            constant_bias=constant_bias,
+            operating_temperature=operating_temperature,
+            temperature_bias=temperature_bias,
+            temperature_scale_factor=temperature_scale_factor,
+            name=name,
+        )
+
+    def quantize(self, value):
+        """
+        Quantize the sensor measurement
+
+        Parameters
+        ----------
+        value : float
+            The value to quantize
+
+        Returns
+        -------
+        float
+            The quantized value
+        """
+        value = min(max(value, self.measurement_range[0]), self.measurement_range[1])
+        if self.resolution != 0:
+            value = round(value / self.resolution) * self.resolution
+        return value
+
+    def apply_noise(self, value):
+        """
+        Add noise to the sensor measurement
+
+        Parameters
+        ----------
+        value : float
+            The value to add noise to
+
+        Returns
+        -------
+        float
+            The value with added noise
+        """
+        # white noise
+        white_noise = (
+            np.random.normal(0, self.noise_variance**0.5)
+            * self.noise_density
+            * self.sampling_rate**0.5
+        )
+
+        # random walk
+        self._random_walk_drift = (
+            self._random_walk_drift
+            + np.random.normal(0, self.random_walk_variance**0.5)
+            * self.random_walk_density
+            / self.sampling_rate**0.5
+        )
+
+        # add noise
+        value += white_noise + self._random_walk_drift + self.constant_bias
+
+        return value
+
+    def apply_temperature_drift(self, value):
+        """
+        Apply temperature drift to the sensor measurement
+
+        Parameters
+        ----------
+        value : float
+            The value to apply temperature drift to
+
+        Returns
+        -------
+        float
+            The value with applied temperature drift
+        """
+        # temperature drift
+        value += (self.operating_temperature - 298.15) * self.temperature_bias
+        # temperature scale factor
+        scale_factor = (
+            1
+            + (self.operating_temperature - 298.15)
+            / 100
+            * self.temperature_scale_factor
+        )
+        value = value * scale_factor
+
+        return value
diff --git a/rocketpy/sensors/sensors.py b/rocketpy/sensors/sensors.py
deleted file mode 100644
index eea0b9384..000000000
--- a/rocketpy/sensors/sensors.py
+++ /dev/null
@@ -1,371 +0,0 @@
-from abc import ABC, abstractmethod
-
-import numpy as np
-
-from rocketpy.mathutils.vector_matrix import Matrix, Vector
-
-
-class Sensors(ABC):
-    """Abstract class for sensors
-
-    Attributes
-    ----------
-    sampling_rate : float
-        Sample rate of the sensor in Hz.
-    orientation : tuple, list
-        Orientation of the sensor in the rocket.
-    measurement_range : float, tuple
-        The measurement range of the sensor in the sensor units.
-    resolution : float
-        The resolution of the sensor in sensor units/LSB.
-    noise_density : float, list
-        The noise density of the sensor in sensor units/√Hz.
-    noise_variance : float, list
-        The variance of the noise of the sensor in sensor units^2.
-    random_walk_density : float, list
-        The random walk density of the sensor in sensor units/√Hz.
-    random_walk_variance : float, list
-        The variance of the random walk of the sensor in sensor units^2.
-    constant_bias : float, list
-        The constant bias of the sensor in sensor units.
-    operating_temperature : float
-        The operating temperature of the sensor in degrees Celsius.
-    temperature_bias : float, list
-        The temperature bias of the sensor in sensor units/°C.
-    temperature_scale_factor : float, list
-        The temperature scale factor of the sensor in %/°C.
-    cross_axis_sensitivity : float
-        The cross axis sensitivity of the sensor in percentage.
-    name : str
-        The name of the sensor.
-    rotation_matrix : Matrix
-        The rotation matrix of the sensor from the sensor frame to the rocket
-        frame of reference.
-    normal_vector : Vector
-        The normal vector of the sensor in the rocket frame of reference.
-    _random_walk_drift : Vector
-        The random walk drift of the sensor in sensor units.
-    measurement : float
-        The measurement of the sensor after quantization, noise and temperature
-        drift.
-    measured_data : list
-        The stored measured data of the sensor after quantization, noise and
-        temperature drift.
-    """
-
-    def __init__(
-        self,
-        sampling_rate,
-        orientation=(0, 0, 0),
-        measurement_range=np.inf,
-        resolution=0,
-        noise_density=0,
-        noise_variance=1,
-        random_walk_density=0,
-        random_walk_variance=1,
-        constant_bias=0,
-        operating_temperature=25,
-        temperature_bias=0,
-        temperature_scale_factor=0,
-        cross_axis_sensitivity=0,
-        name="Sensor",
-    ):
-        """
-        Initialize the accelerometer sensor
-
-        Parameters
-        ----------
-        sampling_rate : float
-            Sample rate of the sensor
-        orientation : tuple, list, optional
-            Orientation of the sensor in the rocket. The orientation can be
-            given as:
-            - A list of length 3, where the elements are the Euler angles for
-              the rotation yaw (ψ), pitch (θ) and roll (φ) in radians. The
-              standard rotation sequence is z-y-x (3-2-1) is used, meaning the
-              sensor is first rotated by ψ around the x axis, then by θ around
-              the new y axis and finally by φ around the new z axis.
-              TODO: x and y are not defined in the rocket class. User has no
-              way to know which axis is which.
-            - A list of lists (matrix) of shape 3x3, representing the rotation
-              matrix from the sensor frame to the rocket frame. The sensor frame
-              of reference is defined as to have z axis along the sensor's normal
-              vector pointing upwards, x and y axes perpendicular to the z axis
-              and each other.
-            The rocket frame of reference is defined as to have z axis
-            along the rocket's axis of symmetry pointing upwards, x and y axes
-            perpendicular to the z axis and each other. Default is (0, 0, 0),
-            meaning the sensor is aligned with the rocket's axis of symmetry.
-        measurement_range : float, tuple, optional
-            The measurement range of the sensor in the sensor units. If a float,
-            the same range is applied both for positive and negative values. If
-            a tuple, the first value is the positive range and the second value
-            is the negative range. Default is np.inf.
-        resolution : float, optional
-            The resolution of the sensor in sensor units/LSB. Default is 0,
-            meaning no quantization is applied.
-        noise_density : float, list, optional
-            The noise density of the sensor for a Gaussian white noise in sensor
-            units/√Hz. Sometimes called "white noise drift",
-            "angular random walk" for gyroscopes, "velocity random walk" for
-            accelerometers or "(rate) noise density". Default is 0, meaning no
-            noise is applied. If a float or int is given, the same noise density
-            is applied to all axes. The values of each axis can be set
-            individually by passing a list of length 3.
-        noise_variance : float, list, optional
-            The noise variance of the sensor for a Gaussian white noise in
-            sensor units^2. Default is 1, meaning the noise is normally
-            distributed with a standard deviation of 1 unit. If a float or int
-            is given, the same noise variance is applied to all axes. The values
-            of each axis can be set individually by passing a list of length 3.
-        random_walk_density : float, list, optional
-            The random walk density of the sensor for a Gaussian random walk in
-            sensor units/√Hz. Sometimes called "bias (in)stability" or
-            "bias drift". Default is 0, meaning no random walk is applied.
-            If a float or int is given, the same random walk is applied to all
-            axes. The values of each axis can be set individually by passing a
-            list of length 3.
-        random_walk_variance : float, list, optional
-            The random walk variance of the sensor for a Gaussian random walk in
-            sensor units^2. Default is 1, meaning the noise is normally
-            distributed with a standard deviation of 1 unit. If a float or int
-            is given, the same random walk variance is applied to all axes. The
-            values of each axis can be set individually by passing a list of
-            length 3.
-        constant_bias : float, list, optional
-            The constant bias of the sensor in sensor units. Default is 0,
-            meaning no constant bias is applied. If a float or int is given, the
-            same constant bias is applied to all axes. The values of each axis
-            can be set individually by passing a list of length 3.
-        operating_temperature : float, optional
-            The operating temperature of the sensor in degrees Celsius. At 25°C,
-            the temperature bias and scale factor are 0. Default is 25.
-        temperature_bias : float, list, optional
-            The temperature bias of the sensor in sensor units/°C. Default is 0,
-            meaning no temperature bias is applied. If a float or int is given,
-            the same temperature bias is applied to all axes. The values of each
-            axis can be set individually by passing a list of length 3.
-        temperature_scale_factor : float, list, optional
-            The temperature scale factor of the sensor in %/°C. Default is 0,
-            meaning no temperature scale factor is applied. If a float or int is
-            given, the same temperature scale factor is applied to all axes. The
-            values of each axis can be set individually by passing a list of
-            length 3.
-        cross_axis_sensitivity : float, optional
-            Skewness of the sensor's axes in percentage. Default is 0, meaning
-            no cross-axis sensitivity is applied.
-        name : str, optional
-            The name of the sensor. Default is "Sensor".
-
-        Returns
-        -------
-        None
-
-        See Also
-        --------
-        TODO link to documentation on noise model
-        """
-        self.sampling_rate = sampling_rate
-        self.orientation = orientation
-        self.resolution = resolution
-        self.operating_temperature = operating_temperature
-        self.noise_density = self._vectorize_input(noise_density, "noise_density")
-        self.noise_variance = self._vectorize_input(noise_variance, "noise_variance")
-        self.random_walk_density = self._vectorize_input(
-            random_walk_density, "random_walk_density"
-        )
-        self.random_walk_variance = self._vectorize_input(
-            random_walk_variance, "random_walk_variance"
-        )
-        self.constant_bias = self._vectorize_input(constant_bias, "constant_bias")
-        self.temperature_bias = self._vectorize_input(
-            temperature_bias, "temperature_bias"
-        )
-        self.temperature_scale_factor = self._vectorize_input(
-            temperature_scale_factor, "temperature_scale_factor"
-        )
-        self.cross_axis_sensitivity = cross_axis_sensitivity
-        self.name = name
-        self._random_walk_drift = Vector([0, 0, 0])
-        self.measurement = None
-        self.measured_data = []
-        self._counter = 0
-        self._save_data = self._save_data_single
-
-        # handle measurement range
-        if isinstance(measurement_range, (tuple, list)):
-            if len(measurement_range) != 2:
-                raise ValueError("Invalid measurement range format")
-            self.measurement_range = measurement_range
-        elif isinstance(measurement_range, (int, float)):
-            self.measurement_range = (-measurement_range, measurement_range)
-        else:
-            raise ValueError("Invalid measurement range format")
-
-        # rotation matrix and normal vector
-        if any(isinstance(row, (tuple, list)) for row in orientation):  # matrix
-            self.rotation_matrix = Matrix(orientation)
-        elif len(orientation) == 3:  # euler angles
-            self.rotation_matrix = Matrix.transformation_euler_angles(
-                *orientation
-            ).round(12)
-        else:
-            raise ValueError("Invalid orientation format")
-        self.normal_vector = Vector(
-            [
-                self.rotation_matrix[0][2],
-                self.rotation_matrix[1][2],
-                self.rotation_matrix[2][2],
-            ]
-        ).unit_vector
-
-        # cross axis sensitivity matrix
-        _cross_axis_matrix = 0.01 * Matrix(
-            [
-                [100, self.cross_axis_sensitivity, self.cross_axis_sensitivity],
-                [self.cross_axis_sensitivity, 100, self.cross_axis_sensitivity],
-                [self.cross_axis_sensitivity, self.cross_axis_sensitivity, 100],
-            ]
-        )
-
-        # compute total rotation matrix given cross axis sensitivity
-        self._total_rotation_matrix = self.rotation_matrix @ _cross_axis_matrix
-
-        # map which rocket(s) the sensor is attached to and how many times
-        self._attached_rockets = {}
-
-    def __repr__(self):
-        return f"{self.name}"
-
-    def __call__(self, *args, **kwargs):
-        return self.measure(*args, **kwargs)
-
-    def _vectorize_input(self, value, name):
-        if isinstance(value, (int, float)):
-            return Vector([value, value, value])
-        elif isinstance(value, (tuple, list)):
-            return Vector(value)
-        else:
-            raise ValueError(f"Invalid {name} format")
-
-    def _reset(self, simulated_rocket):
-        """Reset the sensor data for a new simulation."""
-        self._random_walk_drift = Vector([0, 0, 0])
-        self.measured_data = []
-        if self._attached_rockets[simulated_rocket] > 1:
-            self.measured_data = [
-                [] for _ in range(self._attached_rockets[simulated_rocket])
-            ]
-            self._save_data = self._save_data_multiple
-        else:
-            self._save_data = self._save_data_single
-
-    def _save_data_single(self, data):
-        """Save the measured data to the sensor data list for a sensor that is
-        added only once to the simulated rocket."""
-        self.measured_data.append(data)
-
-    def _save_data_multiple(self, data):
-        """Save the measured data to the sensor data list for a sensor that is
-        added multiple times to the simulated rocket."""
-        self.measured_data[self._counter].append(data)
-        # counter for cases where the sensor is added multiple times in a rocket
-        self._counter += 1
-        if self._counter == len(self.measured_data):
-            self._counter = 0
-
-    @abstractmethod
-    def measure(self, *args, **kwargs):
-        pass
-
-    @abstractmethod
-    def export_measured_data(self):
-        pass
-
-    def quantize(self, value):
-        """
-        Quantize the sensor measurement
-
-        Parameters
-        ----------
-        value : float
-            The value to quantize
-
-        Returns
-        -------
-        float
-            The quantized value
-        """
-        x = min(max(value.x, self.measurement_range[0]), self.measurement_range[1])
-        y = min(max(value.y, self.measurement_range[0]), self.measurement_range[1])
-        z = min(max(value.z, self.measurement_range[0]), self.measurement_range[1])
-        if self.resolution != 0:
-            x = round(x / self.resolution) * self.resolution
-            y = round(y / self.resolution) * self.resolution
-            z = round(z / self.resolution) * self.resolution
-        return Vector([x, y, z])
-
-    def apply_noise(self, value):
-        """
-        Add noise to the sensor measurement
-
-        Parameters
-        ----------
-        value : float
-            The value to add noise to
-
-        Returns
-        -------
-        float
-            The value with added noise
-        """
-        # white noise
-        white_noise = (
-            Vector(
-                [np.random.normal(0, self.noise_variance[i] ** 0.5) for i in range(3)]
-            )
-            & self.noise_density
-        ) * self.sampling_rate**0.5
-
-        # random walk
-        self._random_walk_drift = (
-            self._random_walk_drift
-            + (
-                Vector(
-                    [
-                        np.random.normal(0, self.random_walk_variance[i] ** 0.5)
-                        for i in range(3)
-                    ]
-                )
-                & self.random_walk_density
-            )
-            / self.sampling_rate**0.5
-        )
-
-        # add noise
-        value += white_noise + self._random_walk_drift + self.constant_bias
-
-        return value
-
-    def apply_temperature_drift(self, value):
-        """
-        Apply temperature drift to the sensor measurement
-
-        Parameters
-        ----------
-        value : float
-            The value to apply temperature drift to
-
-        Returns
-        -------
-        float
-            The value with applied temperature drift
-        """
-        # temperature drift
-        value += (self.operating_temperature - 25) * self.temperature_bias
-        # temperature scale factor
-        scale_factor = (
-            Vector([1, 1, 1])
-            + (self.operating_temperature - 25) / 100 * self.temperature_scale_factor
-        )
-        return value & scale_factor
diff --git a/rocketpy/simulation/flight.py b/rocketpy/simulation/flight.py
index 5d8028224..8204c4696 100644
--- a/rocketpy/simulation/flight.py
+++ b/rocketpy/simulation/flight.py
@@ -706,7 +706,7 @@ def __init__(
                     callback(self)
 
                 if self.sensors:
-                    # u_dot for all sensors
+                    # udot for all sensors
                     u_dot = phase.derivative(self.t, self.y_sol)
                     for sensor, position in node._component_sensors:
                         relative_position = position - self.rocket._csys * Vector(
@@ -714,10 +714,13 @@ def __init__(
                         )
                         sensor.measure(
                             self.t,
-                            self.y_sol,
-                            u_dot,
-                            relative_position,
-                            self.env.gravity(self.solution[-1][3]),
+                            u=self.y_sol,
+                            u_dot=u_dot,
+                            relative_position=relative_position,
+                            gravity=self.env.gravity.get_value_opt(
+                                self.solution[-1][3]
+                            ),
+                            pressure=self.env.pressure,
                         )
 
                 for controller in node._controllers:
diff --git a/tests/fixtures/flight/flight_fixtures.py b/tests/fixtures/flight/flight_fixtures.py
index 9976ddac2..c8fe437ca 100644
--- a/tests/fixtures/flight/flight_fixtures.py
+++ b/tests/fixtures/flight/flight_fixtures.py
@@ -161,14 +161,14 @@ def flight_calisto_air_brakes(calisto_air_brakes_clamp_on, example_plain_env):
 
 
 @pytest.fixture
-def flight_calisto_accel_gyro(calisto_accel_gyro, example_plain_env):
+def flight_calisto_with_sensors(calisto_with_sensors, example_plain_env):
     """A rocketpy.Flight object of the Calisto rocket. This uses the calisto
-    with an ideal accelerometer and a gyroscope. The environment is the simplest
-    possible, with no parameters set.
+    with a set of ideal sensors. The environment is the simplest possible, with
+    no parameters set.
 
     Parameters
     ----------
-    calisto_accel_gyro : rocketpy.Rocket
+    calisto_with_sensors : rocketpy.Rocket
         An object of the Rocket class.
     example_plain_env : rocketpy.Environment
         An object of the Environment class.
@@ -180,7 +180,7 @@ def flight_calisto_accel_gyro(calisto_accel_gyro, example_plain_env):
         condition.
     """
     return Flight(
-        rocket=calisto_accel_gyro,
+        rocket=calisto_with_sensors,
         environment=example_plain_env,
         rail_length=5.2,
         inclination=85,
diff --git a/tests/fixtures/rockets/rocket_fixtures.py b/tests/fixtures/rockets/rocket_fixtures.py
index 0161f3950..a973e433b 100644
--- a/tests/fixtures/rockets/rocket_fixtures.py
+++ b/tests/fixtures/rockets/rocket_fixtures.py
@@ -244,27 +244,19 @@ def calisto_air_brakes_clamp_off(calisto_robust, controller_function):
 
 
 @pytest.fixture
-def calisto_accel_gyro(
+def calisto_with_sensors(
     calisto,
     calisto_nose_cone,
     calisto_tail,
     calisto_trapezoidal_fins,
     ideal_accelerometer,
     ideal_gyroscope,
+    ideal_barometer,
 ):
     """Create an object class of the Rocket class to be used in the tests. This
     is the same Calisto rocket that was defined in the calisto fixture, but with
-    an ideal accelerometer and a gyroscope added at the center of dry mass.
-    Meaning the readings will be the same as the values saved on a Flight object.
-
-    Parameters
-    ----------
-    calisto : rocketpy.Rocket
-        An object of the Rocket class. This is a pytest fixture.
-    accelerometer : rocketpy.Accelerometer
-        An object of the Accelerometer class. This is a pytest fixture.
-    gyroscope : rocketpy.Gyroscope
-        An object of the Gyroscope class. This is a pytest fixture.
+    a set of ideal sensors added at the center of dry mass, meaning the readings
+    will be the same as the values saved on a Flight object.
 
     Returns
     -------
@@ -278,6 +270,7 @@ def calisto_accel_gyro(
     calisto.add_sensor(ideal_accelerometer, -0.1180124376577797)
     calisto.add_sensor(ideal_accelerometer, -0.1180124376577797)
     calisto.add_sensor(ideal_gyroscope, -0.1180124376577797)
+    calisto.add_sensor(ideal_barometer, -0.1180124376577797)
     return calisto
 
 
diff --git a/tests/fixtures/sensors/sensors_fixtures.py b/tests/fixtures/sensors/sensors_fixtures.py
index c32a41124..5f148d00b 100644
--- a/tests/fixtures/sensors/sensors_fixtures.py
+++ b/tests/fixtures/sensors/sensors_fixtures.py
@@ -1,6 +1,8 @@
+import numpy as np
 import pytest
 
 from rocketpy import Accelerometer, Gyroscope
+from rocketpy.sensors.barometer import Barometer
 
 
 @pytest.fixture
@@ -16,7 +18,7 @@ def noisy_rotated_accelerometer():
         random_walk_density=[0, 0.01, 0.02],
         random_walk_variance=[1, 1, 1.05],
         constant_bias=[0, 0.3, 0.5],
-        operating_temperature=25,
+        operating_temperature=25 + 273.15,
         temperature_bias=[0, 0.01, 0.02],
         temperature_scale_factor=[0, 0.01, 0.02],
         cross_axis_sensitivity=0.5,
@@ -38,7 +40,7 @@ def noisy_rotated_gyroscope():
         random_walk_density=[0, 0.01, 0.02],
         random_walk_variance=[1, 1, 1.05],
         constant_bias=[0, 0.3, 0.5],
-        operating_temperature=25,
+        operating_temperature=25 + 273.15,
         temperature_bias=[0, 0.01, 0.02],
         temperature_scale_factor=[0, 0.01, 0.02],
         cross_axis_sensitivity=0.5,
@@ -47,6 +49,22 @@ def noisy_rotated_gyroscope():
     )
 
 
+@pytest.fixture
+def noisy_barometer():
+    """Returns a barometer with all parameters set to non-default values,
+    i.e. with noise and temperature drift."""
+    return Barometer(
+        sampling_rate=50,
+        noise_density=19,
+        noise_variance=19,
+        random_walk_density=0.01,
+        constant_bias=1000,
+        operating_temperature=25 + 273.15,
+        temperature_bias=0.02,
+        temperature_scale_factor=0.02,
+    )
+
+
 @pytest.fixture
 def quantized_accelerometer():
     """Returns an accelerometer with all parameters set to non-default values,
@@ -69,15 +87,33 @@ def quantized_gyroscope():
     )
 
 
+@pytest.fixture
+def quantized_barometer():
+    """Returns a barometer with all parameters set to non-default values,
+    i.e. with noise and temperature drift."""
+    return Barometer(
+        sampling_rate=50,
+        measurement_range=7e4,
+        resolution=0.16,
+    )
+
+
 @pytest.fixture
 def ideal_accelerometer():
     return Accelerometer(
-        sampling_rate=100,
+        sampling_rate=10,
     )
 
 
 @pytest.fixture
 def ideal_gyroscope():
     return Gyroscope(
-        sampling_rate=100,
+        sampling_rate=10,
+    )
+
+
+@pytest.fixture
+def ideal_barometer():
+    return Barometer(
+        sampling_rate=10,
     )
diff --git a/tests/test_sensor.py b/tests/test_sensor.py
new file mode 100644
index 000000000..ba9a32b75
--- /dev/null
+++ b/tests/test_sensor.py
@@ -0,0 +1,115 @@
+import json
+import os
+
+import numpy as np
+import pytest
+
+from rocketpy.mathutils.vector_matrix import Vector
+from rocketpy.rocket.components import Components
+from rocketpy.sensors.accelerometer import Accelerometer
+from rocketpy.sensors.gyroscope import Gyroscope
+
+
+def test_sensor_on_rocket(calisto_with_sensors):
+    """Test the sensor on the rocket.
+
+    Parameters
+    ----------
+    calisto_with_sensors : Rocket
+        Pytest fixture for the calisto rocket with a set of ideal sensors.
+    """
+    sensors = calisto_with_sensors.sensors
+    assert isinstance(sensors, Components)
+    assert isinstance(sensors[0].component, Accelerometer)
+    assert isinstance(sensors[1].position, Vector)
+    assert isinstance(sensors[2].component, Gyroscope)
+    assert isinstance(sensors[2].position, Vector)
+
+
+def test_ideal_sensors(flight_calisto_with_sensors):
+    """Test the ideal sensors. All types of sensors are here to reduce
+    testing time.
+
+    Parameters
+    ----------
+    flight_calisto_with_sensors : Flight
+        Pytest fixture for the flight of the calisto rocket with an ideal accelerometer and a gyroscope.
+    """
+    accelerometer = flight_calisto_with_sensors.rocket.sensors[0].component
+    time, ax, ay, az = zip(*accelerometer.measured_data[0])
+    ax = np.array(ax)
+    ay = np.array(ay)
+    az = np.array(az)
+    a = np.sqrt(ax**2 + ay**2 + az**2)
+    sim_accel = flight_calisto_with_sensors.acceleration(time)
+
+    # tolerance is bounded to numerical errors in the transformation matrixes
+    assert np.allclose(a, sim_accel, atol=1e-12)
+    # check if both added accelerometer instances saved the same data
+    assert (
+        flight_calisto_with_sensors.sensors[0].measured_data[0]
+        == flight_calisto_with_sensors.sensors[0].measured_data[1]
+    )
+
+    gyroscope = flight_calisto_with_sensors.rocket.sensors[2].component
+    time, wx, wy, wz = zip(*gyroscope.measured_data)
+    wx = np.array(wx)
+    wy = np.array(wy)
+    wz = np.array(wz)
+    w = np.sqrt(wx**2 + wy**2 + wz**2)
+    flight_wx = np.array(flight_calisto_with_sensors.w1(time))
+    flight_wy = np.array(flight_calisto_with_sensors.w2(time))
+    flight_wz = np.array(flight_calisto_with_sensors.w3(time))
+    sim_w = np.sqrt(flight_wx**2 + flight_wy**2 + flight_wz**2)
+    assert np.allclose(w, sim_w, atol=1e-12)
+
+    barometer = flight_calisto_with_sensors.rocket.sensors[3].component
+    time, pressure = zip(*barometer.measured_data)
+    pressure = np.array(pressure)
+    sim_data = flight_calisto_with_sensors.pressure(time)
+    assert np.allclose(pressure, sim_data, atol=1e-12)
+
+
+def test_export_all_sensors_data(flight_calisto_with_sensors):
+    """Test the export of sensor data.
+
+    Parameters
+    ----------
+    flight_calisto_with_sensors : Flight
+        Pytest fixture for the flight of the calisto rocket with a set of ideal
+        sensors.
+    """
+    flight_calisto_with_sensors.export_sensor_data("test_sensor_data.json")
+    # read the json and parse as dict
+    filename = "test_sensor_data.json"
+    with open(filename, "r") as f:
+        data = f.read()
+        sensor_data = json.loads(data)
+    # convert list of tuples into list of lists to compare with the json
+    flight_calisto_with_sensors.sensors[0].measured_data[0] = [
+        list(measurement)
+        for measurement in flight_calisto_with_sensors.sensors[0].measured_data[0]
+    ]
+    flight_calisto_with_sensors.sensors[1].measured_data[1] = [
+        list(measurement)
+        for measurement in flight_calisto_with_sensors.sensors[1].measured_data[1]
+    ]
+    flight_calisto_with_sensors.sensors[2].measured_data = [
+        list(measurement)
+        for measurement in flight_calisto_with_sensors.sensors[2].measured_data
+    ]
+    flight_calisto_with_sensors.sensors[3].measured_data = [
+        list(measurement)
+        for measurement in flight_calisto_with_sensors.sensors[3].measured_data
+    ]
+    assert (
+        sensor_data["Accelerometer"]
+        == flight_calisto_with_sensors.sensors[0].measured_data
+    )
+    assert (
+        sensor_data["Gyroscope"] == flight_calisto_with_sensors.sensors[2].measured_data
+    )
+    assert (
+        sensor_data["Barometer"] == flight_calisto_with_sensors.sensors[3].measured_data
+    )
+    os.remove(filename)
diff --git a/tests/test_sensors.py b/tests/test_sensors.py
deleted file mode 100644
index 99ae7a0dd..000000000
--- a/tests/test_sensors.py
+++ /dev/null
@@ -1,63 +0,0 @@
-import json
-import os
-
-import numpy as np
-
-from rocketpy.mathutils.vector_matrix import Vector
-from rocketpy.rocket.components import Components
-from rocketpy.sensors.accelerometer import Accelerometer
-from rocketpy.sensors.gyroscope import Gyroscope
-
-
-def test_sensor_on_rocket(calisto_accel_gyro):
-    """Test the sensor on the rocket.
-
-    Parameters
-    ----------
-    calisto_accel_gyro : Rocket
-        Pytest fixture for the calisto rocket with an accelerometer and a gyroscope.
-    """
-    sensors = calisto_accel_gyro.sensors
-    assert isinstance(sensors, Components)
-    assert isinstance(sensors[0].component, Accelerometer)
-    assert isinstance(sensors[1].position, Vector)
-    assert isinstance(sensors[2].component, Gyroscope)
-    assert isinstance(sensors[2].position, Vector)
-
-
-def test_ideal_sensors(flight_calisto_accel_gyro):
-    """Test the ideal sensors. All types of sensors are here to reduce
-    testing time.
-
-    Parameters
-    ----------
-    flight_calisto_accel_gyro : Flight
-        Pytest fixture for the flight of the calisto rocket with an ideal accelerometer and a gyroscope.
-    """
-    accelerometer = flight_calisto_accel_gyro.rocket.sensors[0].component
-    time, ax, ay, az = zip(*accelerometer.measured_data[0])
-    ax = np.array(ax)
-    ay = np.array(ay)
-    az = np.array(az)
-    a = np.sqrt(ax**2 + ay**2 + az**2)
-    sim_accel = flight_calisto_accel_gyro.acceleration(time)
-
-    # tolerance is bounded to numerical errors in the transformation matrixes
-    assert np.allclose(a, sim_accel, atol=1e-12)
-    # check if both added accelerometer instances saved the same data
-    assert (
-        flight_calisto_accel_gyro.sensors[0].measured_data[0]
-        == flight_calisto_accel_gyro.sensors[0].measured_data[1]
-    )
-
-    gyroscope = flight_calisto_accel_gyro.rocket.sensors[2].component
-    time, wx, wy, wz = zip(*gyroscope.measured_data)
-    wx = np.array(wx)
-    wy = np.array(wy)
-    wz = np.array(wz)
-    w = np.sqrt(wx**2 + wy**2 + wz**2)
-    flight_wx = np.array(flight_calisto_accel_gyro.w1(time))
-    flight_wy = np.array(flight_calisto_accel_gyro.w2(time))
-    flight_wz = np.array(flight_calisto_accel_gyro.w3(time))
-    sim_w = np.sqrt(flight_wx**2 + flight_wy**2 + flight_wz**2)
-    assert np.allclose(w, sim_w, atol=1e-12)
diff --git a/tests/unit/test_flight.py b/tests/unit/test_flight.py
index 10ecbe4fe..e09657d82 100644
--- a/tests/unit/test_flight.py
+++ b/tests/unit/test_flight.py
@@ -289,42 +289,42 @@ def test_out_of_rail_stability_margin(flight_calisto_custom_wind):
     assert np.isclose(res, 2.14, atol=0.1)
 
 
-def test_export_sensor_data(flight_calisto_accel_gyro):
+def test_export_sensor_data(flight_calisto_with_sensors):
     """Test the export of sensor data.
 
     Parameters
     ----------
-    flight_calisto_accel_gyro : Flight
+    flight_calisto_with_sensors : Flight
         Pytest fixture for the flight of the calisto rocket with an ideal accelerometer and a gyroscope.
     """
-    flight_calisto_accel_gyro.export_sensor_data("test_sensor_data.json")
+    flight_calisto_with_sensors.export_sensor_data("test_sensor_data.json")
     # read the json and parse as dict
     filename = "test_sensor_data.json"
     with open(filename, "r") as f:
         data = f.read()
         sensor_data = json.loads(data)
     # convert list of tuples into list of lists to compare with the json
-    flight_calisto_accel_gyro.sensors[0].measured_data[0] = [
+    flight_calisto_with_sensors.sensors[0].measured_data[0] = [
         list(measurement)
-        for measurement in flight_calisto_accel_gyro.sensors[0].measured_data[0]
+        for measurement in flight_calisto_with_sensors.sensors[0].measured_data[0]
     ]
-    flight_calisto_accel_gyro.sensors[1].measured_data[1] = [
+    flight_calisto_with_sensors.sensors[1].measured_data[1] = [
         list(measurement)
-        for measurement in flight_calisto_accel_gyro.sensors[1].measured_data[1]
+        for measurement in flight_calisto_with_sensors.sensors[1].measured_data[1]
     ]
-    flight_calisto_accel_gyro.sensors[2].measured_data = [
+    flight_calisto_with_sensors.sensors[2].measured_data = [
         list(measurement)
-        for measurement in flight_calisto_accel_gyro.sensors[2].measured_data
+        for measurement in flight_calisto_with_sensors.sensors[2].measured_data
     ]
     assert (
         sensor_data["Accelerometer"][0]
-        == flight_calisto_accel_gyro.sensors[0].measured_data[0]
+        == flight_calisto_with_sensors.sensors[0].measured_data[0]
     )
     assert (
         sensor_data["Accelerometer"][1]
-        == flight_calisto_accel_gyro.sensors[1].measured_data[1]
+        == flight_calisto_with_sensors.sensors[1].measured_data[1]
     )
     assert (
-        sensor_data["Gyroscope"] == flight_calisto_accel_gyro.sensors[2].measured_data
+        sensor_data["Gyroscope"] == flight_calisto_with_sensors.sensors[2].measured_data
     )
     os.remove(filename)
diff --git a/tests/unit/test_sensor.py b/tests/unit/test_sensor.py
new file mode 100644
index 000000000..186466ccb
--- /dev/null
+++ b/tests/unit/test_sensor.py
@@ -0,0 +1,462 @@
+import json
+import os
+
+import numpy as np
+import pytest
+from pytest import approx
+
+from rocketpy.mathutils.vector_matrix import Matrix, Vector
+from rocketpy.tools import euler_to_quaternions
+
+# calisto standard simulation no wind solution index 200
+TIME = 3.338513236767685
+U = [
+    0.02856482783411794,
+    50.919436628139216,
+    1898.9056294848442,
+    0.021620542063162787,
+    30.468683793837055,
+    284.19140267225384,
+    -0.0076008223256743114,
+    0.0004430927976100488,
+    0.05330950836930627,
+    0.9985245671704497,
+    0.0026388673982115224,
+    0.00010697759229808481,
+    19.72526891699468,
+]
+U_DOT = [
+    0.021620542063162787,
+    30.468683793837055,
+    284.19140267225384,
+    0.0009380154986373648,
+    1.4853035773069556,
+    4.377014845613867,
+    -9.848086239924413,
+    0.5257087555505318,
+    -0.0030529818895471124,
+    -0.07503444684343626,
+    0.028008532884449017,
+    -0.052789015849051935,
+    2.276425320359305,
+]
+GRAVITY = 9.81
+
+
+@pytest.mark.parametrize(
+    "sensor",
+    [
+        "noisy_rotated_accelerometer",
+        "quantized_accelerometer",
+        "noisy_rotated_gyroscope",
+        "quantized_gyroscope",
+        "noisy_barometer",
+        "quantized_barometer",
+    ],
+)
+def test_sensors_prints(sensor, request):
+    """Test the print methods of the Sensor class. Checks if all attributes are
+    printed correctly.
+    """
+    sensor = request.getfixturevalue(sensor)
+    sensor.prints.all()
+    assert True
+
+
+def test_rotation_matrix(noisy_rotated_accelerometer):
+    """Test the rotation_matrix property of the InertialSensor class. Checks if
+    the rotation matrix is correctly calculated.
+    """
+    # values from external source
+    expected_matrix = np.array(
+        [
+            [0.2500000, -0.0580127, 0.9665064],
+            [0.4330127, 0.8995190, -0.0580127],
+            [-0.8660254, 0.4330127, 0.2500000],
+        ]
+    )
+    rotation_matrix = np.array(noisy_rotated_accelerometer.rotation_matrix.components)
+    assert np.allclose(expected_matrix, rotation_matrix, atol=1e-8)
+
+
+def test_inertial_quantization(quantized_accelerometer):
+    """Test the quantize method of the InertialSensor class. Checks if returned values
+    are as expected.
+    """
+    # expected values calculated by hand
+    assert quantized_accelerometer.quantize(Vector([3, 3, 3])) == Vector(
+        [1.9528, 1.9528, 1.9528]
+    )
+    assert quantized_accelerometer.quantize(Vector([-3, -3, -3])) == Vector(
+        [-1.9528, -1.9528, -1.9528]
+    )
+    assert quantized_accelerometer.quantize(Vector([1, 1, 1])) == Vector(
+        [0.9764, 0.9764, 0.9764]
+    )
+
+
+def test_scalar_quantization(quantized_barometer):
+    """Test the quantize method of the ScalarSensor class. Checks if returned values
+    are as expected.
+    """
+    # expected values calculated by hand
+    assert quantized_barometer.quantize(7e5) == 7e4
+    assert quantized_barometer.quantize(-7e5) == -7e4
+    assert quantized_barometer.quantize(1001) == 1000.96
+
+
+import pytest
+
+
+@pytest.mark.parametrize(
+    "sensor, input_value, expected_output",
+    [
+        (
+            "quantized_accelerometer",
+            Vector([3, 3, 3]),
+            Vector([1.9528, 1.9528, 1.9528]),
+        ),
+        (
+            "quantized_accelerometer",
+            Vector([-3, -3, -3]),
+            Vector([-1.9528, -1.9528, -1.9528]),
+        ),
+        (
+            "quantized_accelerometer",
+            Vector([1, 1, 1]),
+            Vector([0.9764, 0.9764, 0.9764]),
+        ),
+        ("quantized_barometer", 7e5, 7e4),
+        ("quantized_barometer", -7e5, -7e4),
+        ("quantized_barometer", 1001, 1000.96),
+    ],
+)
+def test_quantization(sensor, input_value, expected_output, request):
+    """Test the quantize method of various sensor classes. Checks if returned values
+    are as expected.
+
+    Parameters
+    ----------
+    sensor : str
+        Fixture name of the sensor to be tested.
+    input_value : any
+        Input value to be quantized by the sensor.
+    expected_output : any
+        Expected output value after quantization.
+    """
+    sensor = request.getfixturevalue(sensor)
+    result = sensor.quantize(input_value)
+    assert result == expected_output
+
+
+@pytest.mark.parametrize(
+    "sensor",
+    [
+        "ideal_accelerometer",
+        "ideal_gyroscope",
+    ],
+)
+def test_inertial_measured_data(sensor, request):
+    """Test the measured_data property of the Sensor class. Checks if
+    the measured data is treated properly when the sensor is added once or more
+    than once to the rocket.
+    """
+    sensor = request.getfixturevalue(sensor)
+
+    sensor.measure(
+        time=TIME,
+        u=U,
+        u_dot=U_DOT,
+        relative_position=Vector([0, 0, 0]),
+        gravity=GRAVITY,
+    )
+    assert len(sensor.measured_data) == 1
+    sensor.measure(
+        time=TIME,
+        u=U,
+        u_dot=U_DOT,
+        relative_position=Vector([0, 0, 0]),
+        gravity=GRAVITY,
+    )
+    assert len(sensor.measured_data) == 2
+    assert all(isinstance(i, tuple) for i in sensor.measured_data)
+
+    # check case when sensor is added more than once to the rocket
+    sensor.measured_data = [
+        sensor.measured_data[:],
+        sensor.measured_data[:],
+    ]
+    sensor._save_data = sensor._save_data_multiple
+    sensor.measure(
+        time=TIME,
+        u=U,
+        u_dot=U_DOT,
+        relative_position=Vector([0, 0, 0]),
+        gravity=GRAVITY,
+    )
+    assert len(sensor.measured_data) == 2
+    assert len(sensor.measured_data[0]) == 3
+    assert len(sensor.measured_data[1]) == 2
+    sensor.measure(
+        time=TIME,
+        u=U,
+        u_dot=U_DOT,
+        relative_position=Vector([0, 0, 0]),
+        gravity=GRAVITY,
+    )
+    assert len(sensor.measured_data[0]) == 3
+    assert len(sensor.measured_data[1]) == 3
+
+
+def test_scalar_measured_data(ideal_barometer, example_plain_env):
+    """Test the measure method of ScalarSensor. Checks if saved
+    measurement is (P) and if measured_data is [(t, P), ...]
+    """
+    t = TIME
+    u = U
+
+    ideal_barometer.measure(
+        t,
+        u=u,
+        relative_position=Vector([0, 0, 0]),
+        pressure=example_plain_env.pressure,
+    )
+    assert len(ideal_barometer.measured_data) == 1
+    ideal_barometer.measure(
+        t,
+        u=u,
+        relative_position=Vector([0, 0, 0]),
+        pressure=example_plain_env.pressure,
+    )
+    assert len(ideal_barometer.measured_data) == 2
+    assert all(isinstance(i, tuple) for i in ideal_barometer.measured_data)
+
+    # check case when sensor is added more than once to the rocket
+    ideal_barometer.measured_data = [
+        ideal_barometer.measured_data[:],
+        ideal_barometer.measured_data[:],
+    ]
+    ideal_barometer._save_data = ideal_barometer._save_data_multiple
+    ideal_barometer.measure(
+        t,
+        u=u,
+        relative_position=Vector([0, 0, 0]),
+        pressure=example_plain_env.pressure,
+    )
+    assert len(ideal_barometer.measured_data) == 2
+    assert len(ideal_barometer.measured_data[0]) == 3
+    assert len(ideal_barometer.measured_data[1]) == 2
+    ideal_barometer.measure(
+        t,
+        u=u,
+        relative_position=Vector([0, 0, 0]),
+        pressure=example_plain_env.pressure,
+    )
+    assert len(ideal_barometer.measured_data[0]) == 3
+    assert len(ideal_barometer.measured_data[1]) == 3
+
+
+def test_noisy_rotated_accelerometer(noisy_rotated_accelerometer):
+    """Test the measure method of the Accelerometer class. Checks if saved
+    measurement is (ax,ay,az) and if measured_data is [(t, (ax,ay,az)), ...]
+    """
+
+    # calculate acceleration at sensor position in inertial frame
+    relative_position = Vector([0.4, 0.4, 1])
+    a_I = Vector(U_DOT[3:6]) + Vector([0, 0, -GRAVITY])
+    omega = Vector(U[10:13])
+    omega_dot = Vector(U_DOT[10:13])
+    accel = (
+        a_I
+        + Vector.cross(omega_dot, relative_position)
+        + Vector.cross(omega, Vector.cross(omega, relative_position))
+    )
+
+    # calculate total rotation matrix
+    cross_axis_sensitivity = Matrix(
+        [
+            [1, 0.005, 0.005],
+            [0.005, 1, 0.005],
+            [0.005, 0.005, 1],
+        ]
+    )
+    sensor_rotation = Matrix.transformation(euler_to_quaternions(60, 60, 60))
+    total_rotation = sensor_rotation @ cross_axis_sensitivity
+    rocket_rotation = Matrix.transformation(U[6:10])
+    # expected measurement without noise
+    ax, ay, az = total_rotation @ (rocket_rotation @ accel)
+    # expected measurement with constant bias
+    ax += 0.5
+    ay += 0.5
+    az += 0.5
+
+    # check last measurement considering noise error bounds
+    noisy_rotated_accelerometer.measure(
+        time=TIME,
+        u=U,
+        u_dot=U_DOT,
+        relative_position=relative_position,
+        gravity=GRAVITY,
+    )
+    assert noisy_rotated_accelerometer.measurement == approx([ax, ay, az], rel=0.1)
+    assert len(noisy_rotated_accelerometer.measurement) == 3
+    assert noisy_rotated_accelerometer.measured_data[0][1:] == approx(
+        [ax, ay, az], rel=0.1
+    )
+    assert noisy_rotated_accelerometer.measured_data[0][0] == TIME
+
+
+def test_noisy_rotated_gyroscope(noisy_rotated_gyroscope):
+    """Test the measure method of the Gyroscope class. Checks if saved
+    measurement is (wx,wy,wz) and if measured_data is [(t, (wx,wy,wz)), ...]
+    """
+    # calculate acceleration at sensor position in inertial frame
+    relative_position = Vector([0.4, 0.4, 1])
+    omega = Vector(U[10:13])
+    # calculate total rotation matrix
+    cross_axis_sensitivity = Matrix(
+        [
+            [1, 0.005, 0.005],
+            [0.005, 1, 0.005],
+            [0.005, 0.005, 1],
+        ]
+    )
+    sensor_rotation = Matrix.transformation(euler_to_quaternions(-60, -60, -60))
+    total_rotation = sensor_rotation @ cross_axis_sensitivity
+    rocket_rotation = Matrix.transformation(U[6:10])
+    # expected measurement without noise
+    wx, wy, wz = total_rotation @ (rocket_rotation @ omega)
+    # expected measurement with constant bias
+    wx += 0.5
+    wy += 0.5
+    wz += 0.5
+
+    # check last measurement considering noise error bounds
+    noisy_rotated_gyroscope.measure(
+        time=TIME,
+        u=U,
+        u_dot=U_DOT,
+        relative_position=relative_position,
+        gravity=GRAVITY,
+    )
+    assert noisy_rotated_gyroscope.measurement == approx([wx, wy, wz], rel=0.3)
+    assert len(noisy_rotated_gyroscope.measurement) == 3
+    assert noisy_rotated_gyroscope.measured_data[0][1:] == approx([wx, wy, wz], rel=0.3)
+    assert noisy_rotated_gyroscope.measured_data[0][0] == TIME
+
+
+def test_noisy_barometer(noisy_barometer, example_plain_env):
+    """Test the measure method of the Barometer class. Checks if saved
+    measurement is (P) and if measured_data is [(t, P), ...]
+    """
+    # expected measurement without noise
+    relative_position = Vector([0.4, 0.4, 1])
+    relative_altitude = (Matrix.transformation(U[6:10]) @ relative_position).z
+    P = example_plain_env.pressure(relative_altitude + U[2])
+    # expected measurement with constant bias
+    P += 0.5
+
+    noisy_barometer.measure(
+        time=TIME,
+        u=U,
+        relative_position=relative_position,
+        pressure=example_plain_env.pressure,
+    )
+    assert noisy_barometer.measurement == approx(P, rel=0.03)
+    assert noisy_barometer.measured_data[0][1] == approx(P, rel=0.03)
+    assert noisy_barometer.measured_data[0][0] == TIME
+
+
+@pytest.mark.parametrize(
+    "sensor, file_format, expected_header, expected_keys",
+    [
+        ("ideal_accelerometer", "csv", "t,ax,ay,az\n", ("ax", "ay", "az")),
+        ("ideal_gyroscope", "csv", "t,wx,wy,wz\n", ("wx", "wy", "wz")),
+        ("ideal_accelerometer", "json", None, ("ax", "ay", "az")),
+        ("ideal_gyroscope", "json", None, ("wx", "wy", "wz")),
+        ("ideal_barometer", "csv", "t,pressure\n", ("pressure",)),
+        ("ideal_barometer", "json", None, ("pressure",)),
+    ],
+)
+def test_export_data(
+    sensor, file_format, expected_header, expected_keys, request, example_plain_env
+):
+    """Test the export_data method of the sensors. Checks if the data is
+    exported correctly in the specified file_format.
+    """
+    sensor = request.getfixturevalue(sensor)
+
+    sensor.measure(
+        time=TIME,
+        u=U,
+        u_dot=U_DOT,
+        relative_position=Vector([0, 0, 0]),
+        gravity=GRAVITY,
+        pressure=example_plain_env.pressure,
+    )
+    sensor.measure(
+        time=TIME,
+        u=U,
+        u_dot=U_DOT,
+        relative_position=Vector([0, 0, 0]),
+        gravity=GRAVITY,
+        pressure=example_plain_env.pressure,
+    )
+
+    file_name = f"sensors.{file_format}"
+
+    sensor.export_measured_data(file_name, file_format=file_format)
+
+    if file_format == "csv":
+        with open(file_name, "r") as file:
+            contents = file.read()
+
+        expected_data = expected_header
+        for data in sensor.measured_data:
+            expected_data += ",".join(map(str, data)) + "\n"
+
+        assert contents == expected_data
+
+    elif file_format == "json":
+        with open(file_name, "r") as file:
+            contents = json.load(file)
+
+        expected_data = {"t": []}
+        for key in expected_keys:
+            expected_data[key] = []
+
+        for data in sensor.measured_data:
+            expected_data["t"].append(data[0])
+            for i, key in enumerate(expected_keys):
+                expected_data[key].append(data[i + 1])
+
+        assert contents == expected_data
+
+    # check exports for sensors added more than once to the rocket
+    sensor.measured_data = [
+        sensor.measured_data[:],
+        sensor.measured_data[:],
+    ]
+    sensor.export_measured_data(file_name, file_format=file_format)
+
+    if file_format == "csv":
+        with open(f"{file_name}_1", "r") as file:
+            contents = file.read()
+        assert contents == expected_data
+
+        with open(f"{file_name}_2", "r") as file:
+            contents = file.read()
+        assert contents == expected_data
+
+    elif file_format == "json":
+        with open(f"{file_name}_1", "r") as file:
+            contents = json.load(file)
+        assert contents == expected_data
+
+        with open(f"{file_name}_2", "r") as file:
+            contents = json.load(file)
+        assert contents == expected_data
+
+    os.remove(file_name)
+    os.remove(f"{file_name}_1")
+    os.remove(f"{file_name}_2")
diff --git a/tests/unit/test_sensors.py b/tests/unit/test_sensors.py
deleted file mode 100644
index ff746e4ae..000000000
--- a/tests/unit/test_sensors.py
+++ /dev/null
@@ -1,315 +0,0 @@
-import json
-import os
-
-import numpy as np
-import pytest
-from pytest import approx
-
-from rocketpy.mathutils.vector_matrix import Matrix, Vector
-from rocketpy.tools import euler_to_quaternions
-
-# calisto standard simulation no wind solution index 200
-TIME = 3.338513236767685
-U = [
-    0.02856482783411794,
-    50.919436628139216,
-    1898.9056294848442,
-    0.021620542063162787,
-    30.468683793837055,
-    284.19140267225384,
-    -0.0076008223256743114,
-    0.0004430927976100488,
-    0.05330950836930627,
-    0.9985245671704497,
-    0.0026388673982115224,
-    0.00010697759229808481,
-    19.72526891699468,
-]
-U_DOT = [
-    0.021620542063162787,
-    30.468683793837055,
-    284.19140267225384,
-    0.0009380154986373648,
-    1.4853035773069556,
-    4.377014845613867,
-    -9.848086239924413,
-    0.5257087555505318,
-    -0.0030529818895471124,
-    -0.07503444684343626,
-    0.028008532884449017,
-    -0.052789015849051935,
-    2.276425320359305,
-]
-GRAVITY = 9.81
-
-
-@pytest.mark.parametrize(
-    "sensor",
-    [
-        "noisy_rotated_accelerometer",
-        "quantized_accelerometer",
-        "noisy_rotated_gyroscope",
-        "quantized_gyroscope",
-    ],
-)
-def test_sensors_prints(sensor, request):
-    """Test the print methods of the Sensor class. Checks if all attributes are
-    printed correctly.
-    """
-    sensor = request.getfixturevalue(sensor)
-    sensor.prints.all()
-    assert True
-
-
-def test_rotation_matrix(noisy_rotated_accelerometer):
-    """Test the rotation_matrix property of the Accelerometer class. Checks if
-    the rotation matrix is correctly calculated.
-    """
-    # values from external source
-    expected_matrix = np.array(
-        [
-            [0.2500000, -0.0580127, 0.9665064],
-            [0.4330127, 0.8995190, -0.0580127],
-            [-0.8660254, 0.4330127, 0.2500000],
-        ]
-    )
-    rotation_matrix = np.array(noisy_rotated_accelerometer.rotation_matrix.components)
-    assert np.allclose(expected_matrix, rotation_matrix, atol=1e-8)
-
-
-def test_quantization(quantized_accelerometer):
-    """Test the quantize method of the Sensor class. Checks if returned values
-    are as expected.
-    """
-    # expected values calculated by hand
-    assert quantized_accelerometer.quantize(Vector([3, 3, 3])) == Vector(
-        [1.9528, 1.9528, 1.9528]
-    )
-    assert quantized_accelerometer.quantize(Vector([-3, -3, -3])) == Vector(
-        [-1.9528, -1.9528, -1.9528]
-    )
-    assert quantized_accelerometer.quantize(Vector([1, 1, 1])) == Vector(
-        [0.9764, 0.9764, 0.9764]
-    )
-
-
-@pytest.mark.parametrize(
-    "sensor",
-    [
-        "ideal_accelerometer",
-        "ideal_gyroscope",
-    ],
-)
-def test_measured_data(sensor, request):
-    """Test the measured_data property of the Sensors class. Checks if
-    the measured data is treated properly when the sensor is added once or more
-    than once to the rocket.
-    """
-    sensor = request.getfixturevalue(sensor)
-
-    sensor.measure(TIME, U, U_DOT, Vector([0, 0, 0]), GRAVITY)
-    assert len(sensor.measured_data) == 1
-    sensor.measure(TIME, U, U_DOT, Vector([0, 0, 0]), GRAVITY)
-    assert len(sensor.measured_data) == 2
-    assert all(isinstance(i, tuple) for i in sensor.measured_data)
-
-    # check case when sensor is added more than once to the rocket
-    sensor.measured_data = [
-        sensor.measured_data[:],
-        sensor.measured_data[:],
-    ]
-    sensor._save_data = sensor._save_data_multiple
-    sensor.measure(TIME, U, U_DOT, Vector([0, 0, 0]), GRAVITY)
-    assert len(sensor.measured_data) == 2
-    assert len(sensor.measured_data[0]) == 3
-    assert len(sensor.measured_data[1]) == 2
-    sensor.measure(TIME, U, U_DOT, Vector([0, 0, 0]), GRAVITY)
-    assert len(sensor.measured_data[0]) == 3
-    assert len(sensor.measured_data[1]) == 3
-
-
-def test_noisy_rotated_accelerometer(noisy_rotated_accelerometer):
-    """Test the measure method of the Accelerometer class. Checks if saved
-    measurement is (ax,ay,az) and if measured_data is [(t, (ax,ay,az)), ...]
-    """
-
-    # calculate acceleration at sensor position in inertial frame
-    relative_position = Vector([0.4, 0.4, 1])
-    a_I = Vector(U_DOT[3:6]) + Vector([0, 0, -GRAVITY])
-    omega = Vector(U[10:13])
-    omega_dot = Vector(U_DOT[10:13])
-    accel = (
-        a_I
-        + Vector.cross(omega_dot, relative_position)
-        + Vector.cross(omega, Vector.cross(omega, relative_position))
-    )
-
-    # calculate total rotation matrix
-    cross_axis_sensitivity = Matrix(
-        [
-            [1, 0.005, 0.005],
-            [0.005, 1, 0.005],
-            [0.005, 0.005, 1],
-        ]
-    )
-    sensor_rotation = Matrix.transformation(euler_to_quaternions(60, 60, 60))
-    total_rotation = sensor_rotation @ cross_axis_sensitivity
-    rocket_rotation = Matrix.transformation(U[6:10])
-    # expected measurement without noise
-    ax, ay, az = total_rotation @ (rocket_rotation @ accel)
-    # expected measurement with constant bias
-    ax += 0.5
-    ay += 0.5
-    az += 0.5
-
-    # check last measurement considering noise error bounds
-    noisy_rotated_accelerometer.measure(TIME, U, U_DOT, relative_position, GRAVITY)
-    assert noisy_rotated_accelerometer.measurement == approx([ax, ay, az], rel=0.1)
-    assert len(noisy_rotated_accelerometer.measurement) == 3
-    assert noisy_rotated_accelerometer.measured_data[0][1:] == approx(
-        [ax, ay, az], rel=0.1
-    )
-    assert noisy_rotated_accelerometer.measured_data[0][0] == TIME
-
-
-def test_noisy_rotated_gyroscope(noisy_rotated_gyroscope):
-    """Test the measure method of the Gyroscope class. Checks if saved
-    measurement is (wx,wy,wz) and if measured_data is [(t, (wx,wy,wz)), ...]
-    """
-    # calculate acceleration at sensor position in inertial frame
-    relative_position = Vector([0.4, 0.4, 1])
-    omega = Vector(U[10:13])
-    # calculate total rotation matrix
-    cross_axis_sensitivity = Matrix(
-        [
-            [1, 0.005, 0.005],
-            [0.005, 1, 0.005],
-            [0.005, 0.005, 1],
-        ]
-    )
-    sensor_rotation = Matrix.transformation(euler_to_quaternions(-60, -60, -60))
-    total_rotation = sensor_rotation @ cross_axis_sensitivity
-    rocket_rotation = Matrix.transformation(U[6:10])
-    # expected measurement without noise
-    wx, wy, wz = total_rotation @ (rocket_rotation @ omega)
-    # expected measurement with constant bias
-    wx += 0.5
-    wy += 0.5
-    wz += 0.5
-
-    # check last measurement considering noise error bounds
-    noisy_rotated_gyroscope.measure(TIME, U, U_DOT, relative_position, GRAVITY)
-    assert noisy_rotated_gyroscope.measurement == approx([wx, wy, wz], rel=0.3)
-    assert len(noisy_rotated_gyroscope.measurement) == 3
-    assert noisy_rotated_gyroscope.measured_data[0][1:] == approx([wx, wy, wz], rel=0.3)
-    assert noisy_rotated_gyroscope.measured_data[0][0] == TIME
-
-
-@pytest.mark.parametrize(
-    "sensor, expected_string",
-    [
-        ("ideal_accelerometer", "t,ax,ay,az\n"),
-        ("ideal_gyroscope", "t,wx,wy,wz\n"),
-    ],
-)
-def test_export_data_csv(sensor, expected_string, request):
-    """Test the export_data method of accelerometer. Checks if the data is
-    exported correctly.
-
-    Parameters
-    ----------
-    flight_calisto_accel_gyro : Flight
-        Pytest fixture for the flight of the calisto rocket with an ideal accelerometer and a gyroscope.
-    """
-    sensor = request.getfixturevalue(sensor)
-    sensor.measure(TIME, U, U_DOT, Vector([0, 0, 0]), GRAVITY)
-    sensor.measure(TIME, U, U_DOT, Vector([0, 0, 0]), GRAVITY)
-
-    file_name = "sensors.csv"
-
-    sensor.export_measured_data(file_name, format="csv")
-
-    with open(file_name, "r") as file:
-        contents = file.read()
-
-    expected_data = expected_string
-    for t, x, y, z in sensor.measured_data:
-        expected_data += f"{t},{x},{y},{z}\n"
-
-    assert contents == expected_data
-
-    # check exports for accelerometers added more than once to the rocket
-    sensor.measured_data = [
-        sensor.measured_data[:],
-        sensor.measured_data[:],
-    ]
-    sensor.export_measured_data(file_name, format="csv")
-    with open(file_name + "_1", "r") as file:
-        contents = file.read()
-    assert contents == expected_data
-
-    with open(file_name + "_2", "r") as file:
-        contents = file.read()
-    assert contents == expected_data
-
-    os.remove(file_name)
-    os.remove(file_name + "_1")
-    os.remove(file_name + "_2")
-
-
-@pytest.mark.parametrize(
-    "sensor, expected_string",
-    [
-        ("ideal_accelerometer", ("ax", "ay", "az")),
-        ("ideal_gyroscope", ("wx", "wy", "wz")),
-    ],
-)
-def test_export_data_json(sensor, expected_string, request):
-    """Test the export_data method of the accelerometer. Checks if the data is
-    exported correctly.
-
-    Parameters
-    ----------
-    flight_calisto_accel_gyro : Flight
-        Pytest fixture for the flight of the calisto rocket with an ideal
-        accelerometer and a gyroscope.
-    """
-    sensor = request.getfixturevalue(sensor)
-    sensor.measure(TIME, U, U_DOT, Vector([0, 0, 0]), GRAVITY)
-    sensor.measure(TIME, U, U_DOT, Vector([0, 0, 0]), GRAVITY)
-
-    file_name = "sensors.json"
-
-    sensor.export_measured_data(file_name, format="json")
-
-    contents = json.load(open(file_name, "r"))
-
-    expected_data = {
-        "t": [],
-        expected_string[0]: [],
-        expected_string[1]: [],
-        expected_string[2]: [],
-    }
-    for t, x, y, z in sensor.measured_data:
-        expected_data["t"].append(t)
-        expected_data[expected_string[0]].append(x)
-        expected_data[expected_string[1]].append(y)
-        expected_data[expected_string[2]].append(z)
-
-    assert contents == expected_data
-
-    # check exports for accelerometers added more than once to the rocket
-    sensor.measured_data = [
-        sensor.measured_data[:],
-        sensor.measured_data[:],
-    ]
-    sensor.export_measured_data(file_name, format="json")
-    contents = json.load(open(file_name + "_1", "r"))
-    assert contents == expected_data
-
-    contents = json.load(open(file_name + "_2", "r"))
-    assert contents == expected_data
-
-    os.remove(file_name)
-    os.remove(file_name + "_1")
-    os.remove(file_name + "_2")