Vom Wearable ins Web: Echtzeit-Pipeline mit MQTT und Node.js

Einleitung

Haben Sie sich schon einmal gefragt, wie Ihr Fitness-Tracker Ihre Herzfrequenz in Echtzeit an Ihr Telefon sendet? Oder wie Smart-Home-Sensoren ein Dashboard sofort aktualisieren? Die Magie steckt in einer robusten Echtzeit-Datenpipeline. Für Entwicklerinnen und Entwickler ist der Aufbau solcher Pipelines eine Kernkompetenz in der rasant wachsenden Welt des Internets der Dinge (IoT).

In diesem vertiefenden Tutorial bauen wir eine vollständige End-to-End-Datenpipeline. Wir simulieren ein Wearable mit einem beliebten und günstigen ESP32-Mikrocontroller, streamen dessen Sensordaten über das schlanke MQTT-Protokoll, verarbeiten sie mit einem Node.js-Backend und visualisieren sie live auf einem Web-Dashboard mithilfe von WebSockets.

Dieses Projekt ist keine rein theoretische Übung; es ist ein Bauplan für Ihre eigenen IoT-Anwendungen – von persönlichen Gesundheitsmonitoren bis zu industriellen Sensornetzwerken. Sie lernen, Echtzeitdaten effizient zu verarbeiten und dabei geringe Latenz und hohe Zuverlässigkeit sicherzustellen.

Voraussetzungen:

• Grundkenntnisse in JavaScript (Node.js) und C++ (Arduino).
• Node.js und npm auf Ihrem Rechner installiert.
• Arduino IDE für die ESP32-Entwicklung eingerichtet.
• Ein ESP32-Entwicklungsboard (jedes Modell mit WLAN ist geeignet).
• Ein Sensor für Ihren ESP32 (wir verwenden einen BME280 für Temperatur und Luftfeuchtigkeit, der Code lässt sich jedoch leicht an jeden Sensor anpassen).

Das Problem verstehen: Die IoT-Datenherausforderung

Das Streamen von Daten von Millionen von Geräten ist komplex. Ein naiver Ansatz, bei dem jedes Gerät HTTP-Anfragen an einen zentralen Server sendet, skaliert nicht. Er ist ineffizient, erzeugt enge Kopplung und kommt mit unzuverlässigen Netzen schlecht zurecht – ein häufiges Szenario bei IoT-Geräten.

Hier glänzt das Publish/Subscribe-(Pub/Sub-)Modell und insbesondere das MQTT-Protokoll.

• Entkopplung: Geräte (Publisher) senden Nachrichten an einen zentralen Knoten, den Broker, zu bestimmten „Topics“, ohne zu wissen, wer sie empfängt. Anwendungen (Subscriber) hören diese Topics ab, um die benötigten Daten zu erhalten.
• Schlank: MQTT ist für eingeschränkte Geräte und schmalbandige Netze ausgelegt und damit ideal für batteriebetriebene Wearables.
• Zuverlässigkeit: MQTT verfügt über eingebaute Quality-of-Service-(QoS-)Stufen, um die Nachrichtenzustellung auch bei instabilen Verbindungen sicherzustellen.

Unsere Architektur sieht so aus:

ESP32 (Wearable) -> MQTT-Broker -> Node.js-Backend -> WebSocket -> Webbrowser

Dieser Ansatz ist skalierbar, widerstandsfähig und der Branchenstandard für viele IoT-Anwendungen.

Voraussetzungen und Einrichtung

Bevor wir mit dem Programmieren beginnen, bereiten wir unsere Umgebung vor.

1. Der MQTT-Broker

Der Broker ist der zentrale Nachrichten-Hub. Für dieses Tutorial haben wir zwei gute Optionen:

• Am einfachsten (cloudbasiert): Wir verwenden einen kostenlosen, öffentlichen MQTT-Broker von EMQ X unter broker.emqx.io. Er erfordert keine Einrichtung und eignet sich hervorragend für die schnelle Entwicklung.
• Lokal und sicher: Für eine produktionsähnlichere Umgebung können Sie Ihren eigenen Mosquitto-Broker installieren. Mit Docker geht das einfach:

# Pull the Mosquitto image
docker pull eclipse-mosquitto

# Run the broker
docker run -it -p 1883:1883 -p 9001:9001 -v $(pwd)/mosquitto.conf:/mosquitto/config/mosquitto.conf eclipse-mosquitto

(In diesem Tutorial verwenden alle Beispiele der Einfachheit halber den öffentlichen broker.emqx.io.)

2. Node.js-Projekteinrichtung

Legen Sie auf Ihrem Computer ein neues Projektverzeichnis an und initialisieren Sie ein Node.js-Projekt.

mkdir wearable-pipeline-backend
cd wearable-pipeline-backend
npm init -y

Installieren Sie nun die benötigten Bibliotheken: mqtt für die Verbindung zu unserem Broker und ws für den WebSocket-Server.

npm install mqtt ws

Ihre package.json sollte ungefähr so aussehen:

{
  "name": "wearable-pipeline-backend",
  "version": "1.0.0",
  "description": "",
  "main": "server.js",
  "scripts": {
    "start": "node server.js"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "dependencies": {
    "mqtt": "^5.3.5",
    "ws": "^8.16.0"
  }
}

3. Arduino-IDE-Einrichtung für ESP32

Stellen Sie sicher, dass Ihre Arduino IDE für Ihr ESP32-Board konfiguriert ist. Außerdem benötigen Sie die Bibliothek PubSubClient für MQTT sowie die Bibliotheken für Ihren Sensor (z. B. die Adafruit-BME280-Bibliothek).

Sie können diese über den Library Manager der Arduino IDE installieren:

1. Gehen Sie zu Sketch -> Include Library -> Manage Libraries...
2. Suchen Sie nach PubSubClient und installieren Sie die Bibliothek.
3. Suchen Sie nach Adafruit BME280 Library und ihrer Abhängigkeit Adafruit Unified Sensor und installieren Sie beide.

Schritt 1: Das Wearable (ESP32)

Was wir tun

Wir programmieren den ESP32 so, dass er regelmäßig Sensordaten liest und sie als JSON-Payload zu einem bestimmten Topic an unseren MQTT-Broker veröffentlicht.

Umsetzung

Öffnen Sie die Arduino IDE und fügen Sie den folgenden Code ein. Denken Sie daran, die WLAN-Zugangsdaten durch Ihre eigenen zu ersetzen!

// src/esp32_mqtt_publisher/esp32_mqtt_publisher.ino

#include <WiFi.h>
#include <PubSubClient.h>
#include <Adafruit_BME280.h>
#include <ArduinoJson.h>

// --- Wi-Fi and MQTT Configuration ---
const char* ssid = "YOUR_WIFI_SSID";
const char* password = "YOUR_WIFI_PASSWORD";
const char* mqtt_server = "broker.emqx.io";
const int mqtt_port = 1883;

// --- MQTT Topics ---
const char* temp_topic = "wearable/device1/temperature";
const char* humidity_topic = "wearable/device1/humidity";

// --- Globals ---
WiFiClient espClient;
PubSubClient client(espClient);
Adafruit_BME280 bme; // I2C
unsigned long lastMsg = 0;
#define MSG_BUFFER_SIZE (50)
char msg[MSG_BUFFER_SIZE];

void setup_wifi() {
  delay(10);
  Serial.println();
  Serial.print("Connecting to ");
  Serial.println(ssid);
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.println("WiFi connected");
  Serial.println("IP address: ");
  Serial.println(WiFi.localIP());
}

void reconnect() {
  // Loop until we're reconnected
  while (!client.connected()) {
    Serial.print("Attempting MQTT connection...");
    // Create a random client ID
    String clientId = "ESP32Client-";
    clientId += String(random(0xffff), HEX);
    // Attempt to connect
    if (client.connect(clientId.c_str())) {
      Serial.println("connected");
    } else {
      Serial.print("failed, rc=");
      Serial.print(client.state());
      Serial.println(" try again in 5 seconds");
      // Wait 5 seconds before retrying
      delay(5000);
    }
  }
}

void setup() {
  Serial.begin(115200);
  setup_wifi();
  client.setServer(mqtt_server, mqtt_port);
  
  if (!bme.begin(0x76)) {
    Serial.println("Could not find a valid BME280 sensor, check wiring!");
    while (1);
  }
}

void loop() {
  if (!client.connected()) {
    reconnect();
  }
  client.loop();

  unsigned long now = millis();
  if (now - lastMsg > 5000) { // Publish every 5 seconds
    lastMsg = now;

    float temperature = bme.readTemperature(); // Celsius
    float humidity = bme.readHumidity();

    if (isnan(temperature) || isnan(humidity)) {
        Serial.println("Failed to read from BME sensor!");
        return;
    }

    // Prepare JSON payload for temperature
    StaticJsonDocument<128> tempDoc;
    tempDoc["deviceId"] = "device1";
    tempDoc["value"] = temperature;
    tempDoc["unit"] = "C";
    tempDoc["timestamp"] = millis();
    char tempOutput[128];
    serializeJson(tempDoc, tempOutput);

    // Publish temperature
    client.publish(temp_topic, tempOutput);
    Serial.print("Published to ");
    Serial.print(temp_topic);
    Serial.println(tempOutput);
    
    // Prepare JSON payload for humidity
    StaticJsonDocument<128> humidityDoc;
    humidityDoc["deviceId"] = "device1";
    humidityDoc["value"] = humidity;
    humidityDoc["unit"] = "%";
    humidityDoc["timestamp"] = millis();
    char humidityOutput[128];
    serializeJson(humidityDoc, humidityOutput);

    // Publish humidity
    client.publish(humidity_topic, humidityOutput);
    Serial.print("Published to ");
    Serial.print(humidity_topic);
    Serial.println(humidityOutput);
  }
}

So funktioniert es

1. setup_wifi(): Verbindet den ESP32 mit Ihrem lokalen WLAN.
2. reconnect(): Diese Funktion stellt die Verbindung zum MQTT-Broker her. Bricht die Verbindung ab, versucht sie es weiter. Das ist entscheidend für die Widerstandsfähigkeit des Geräts.
3. setup(): Initialisiert den seriellen Monitor, WLAN, die MQTT-Serververbindung und den BME280-Sensor.
4. loop(): Die Hauptlogik. Sie stellt sicher, dass der MQTT-Client verbunden ist, und liest dann alle 5 Sekunden Temperatur und Luftfeuchtigkeit. Sie formatiert diese Daten mit ArduinoJson zu einem einfachen JSON-Objekt und veröffentlicht jeden Messwert über client.publish() im jeweiligen Topic (wearable/device1/temperature und wearable/device1/humidity).

Häufige Fallstricke

• Falsche WLAN-Zugangsdaten: Prüfen Sie SSID und Passwort sorgfältig. Der serielle Monitor bleibt bei „Connecting to...“ stehen, wenn sie falsch sind.
• Firewall-Probleme: Stellen Sie sicher, dass Ihr Netz den Port 1883, den Standard-MQTT-Port, nicht blockiert.
• Sensorverkabelung: Wenn Sie „Could not find a valid BME280 sensor“ sehen, prüfen Sie Ihre I2C-Verdrahtung (SDA-/SCL-Pins).

Laden Sie den Code hoch und öffnen Sie den seriellen Monitor. Sie sollten sehen, dass er sich mit dem WLAN verbindet und beginnt, Daten zu veröffentlichen! ✨

Schritt 2: Das Node.js-Backend (MQTT-zu-WebSocket-Brücke)

Was wir tun

Das ist der Kern unserer Pipeline. Wir erstellen einen Node.js-Server, der:

1. sich mit dem MQTT-Broker verbindet und die Topics abonniert, zu denen unser ESP32 veröffentlicht.
2. einen WebSocket-Server erstellt, der Verbindungen von Webbrowsern annimmt.
3. eine MQTT-Nachricht sofort an alle verbundenen WebSocket-Clients weiterleitet, sobald sie eintrifft.

Umsetzung

Erstellen Sie im Verzeichnis wearable-pipeline-backend eine Datei namens server.js.

// server.js

const mqtt = require('mqtt');
const { WebSocketServer } = require('ws');

// --- MQTT Configuration ---
const MQTT_BROKER = 'mqtt://broker.emqx.io';
const TOPICS = ['wearable/device1/temperature', 'wearable/device1/humidity'];

// --- WebSocket Server Configuration ---
const WSS_PORT = 8080;

// 1. Create a WebSocket server
const wss = new WebSocketServer({ port: WSS_PORT });
console.log(`WebSocket server started on port ${WSS_PORT}`);

wss.on('connection', (ws) => {
  console.log('Client connected to WebSocket');
  ws.on('close', () => console.log('Client disconnected'));
});

// Function to broadcast to all clients
function broadcast(topic, message) {
  console.log(`Broadcasting to ${wss.clients.size} clients:`, topic, message.toString());
  wss.clients.forEach(client => {
    if (client.readyState === 1) { // WebSocket.OPEN = 1
      client.send(JSON.stringify({ topic, data: JSON.parse(message.toString()) }));
    }
  });
}

// 2. Connect to MQTT Broker
const client = mqtt.connect(MQTT_BROKER);

client.on('connect', () => {
  console.log('Connected to MQTT broker');
  
  // 3. Subscribe to all topics
  TOPICS.forEach(topic => {
    client.subscribe(topic, (err) => {
      if (!err) {
        console.log(`Subscribed to topic: ${topic}`);
      }
    });
  });
});

// 4. Handle incoming messages
client.on('message', (topic, message) => {
  console.log(`Received message from topic ${topic}: ${message.toString()}`);
  
  // Broadcast the message to all WebSocket clients
  broadcast(topic, message);
});

client.on('error', (err) => {
    console.error('MQTT Error:', err);
    client.end();
});

So funktioniert es

1. Einrichtung des WebSocket-Servers: Wir erstellen eine neue Instanz von WebSocketServer auf Port 8080. Eine einfache Protokollausgabe zeigt, wann sich Clients verbinden und trennen.
2. Einrichtung des MQTT-Clients: Mit mqtt.connect() verbinden wir uns mit dem öffentlichen Broker.
3. Abonnement: Im Callback client.on('connect', ...) durchlaufen wir unser Array TOPICS und abonnieren jedes Topic. Damit teilen wir dem Broker mit, dass wir Nachrichten zu diesen Topics empfangen möchten.
4. Nachrichtenverarbeitung: Das Ereignis client.on('message', ...) ist das Bindeglied. Trifft eine Nachricht vom Broker ein, wird diese Funktion ausgelöst. Anschließend rufen wir unsere Funktion broadcast auf.
5. Weiterleitung: Die Funktion broadcast durchläuft alle verbundenen WebSocket-Clients (wss.clients) und sendet ihnen die Daten. Wir packen das Topic und die geparsten Nachrichtendaten in ein neues JSON-Objekt, damit das Frontend sie leicht verarbeiten kann.

Starten Sie den Server im Terminal:

node server.js

Sie sollten sehen, dass er sich mit dem MQTT-Broker verbindet und die Topics abonniert. Läuft Ihr ESP32 noch, werden die eingehenden Nachrichten in Ihrem Terminal protokolliert!

Schritt 3: Die Web-App (Frontend-Visualisierung)

Was wir tun

Zum Schluss bauen wir den nutzerseitigen Teil: eine einfache HTML-Seite mit JavaScript, die sich mit unserem Node.js-WebSocket-Server verbindet und die eingehenden Daten in Echtzeit mit Chart.js visualisiert.

Umsetzung

Erstellen Sie im Backend-Projektordner eine neue Datei namens index.html.

<!-- index.html -->
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Real-Time Wearable Data</title>
    <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
    <style>
        body { font-family: sans-serif; display: flex; justify-content: center; align-items: center; height: 100vh; background-color: #f0f2f5; }
        .dashboard { display: flex; gap: 20px; }
        .chart-container { width: 500px; padding: 20px; background: white; border-radius: 8px; box-shadow: 0 2px 4px rgba(0,0,0,0.1); }
        h1 { text-align: center; }
    </style>
</head>
<body>
    <div class="dashboard">
        <div class="chart-container">
            <h1>Temperature (°C)</h1>
            <canvas id="tempChart"></canvas>
        </div>
        <div class="chart-container">
            <h1>Humidity (%)</h1>
            <canvas id="humidityChart"></canvas>
        </div>
    </div>

<script>
    const MAX_DATA_POINTS = 20;

    // --- Chart.js Setup for Temperature ---
    const tempCtx = document.getElementById('tempChart').getContext('2d');
    const tempChart = new Chart(tempCtx, {
        type: 'line',
        data: {
            labels: [],
            datasets: [{
                label: 'Temperature',
                data: [],
                borderColor: 'rgba(255, 99, 132, 1)',
                backgroundColor: 'rgba(255, 99, 132, 0.2)',
                borderWidth: 2,
                fill: true
            }]
        },
        options: {
            scales: {
                x: { title: { display: true, text: 'Time' } },
                y: { title: { display: true, text: 'Value' } }
            },
            animation: { duration: 200 }
        }
    });

    // --- Chart.js Setup for Humidity ---
    const humidityCtx = document.getElementById('humidityChart').getContext('2d');
    const humidityChart = new Chart(humidityCtx, {
        type: 'line',
        data: {
            labels: [],
            datasets: [{
                label: 'Humidity',
                data: [],
                borderColor: 'rgba(54, 162, 235, 1)',
                backgroundColor: 'rgba(54, 162, 235, 0.2)',
                borderWidth: 2,
                fill: true
            }]
        },
        options: {
            scales: {
                x: { title: { display: true, text: 'Time' } },
                y: { title: { display: true, text: 'Value' } }
            },
            animation: { duration: 200 }
        }
    });

    function addData(chart, label, data) {
        chart.data.labels.push(label);
        chart.data.datasets.forEach((dataset) => {
            dataset.data.push(data);
        });

        // Limit the number of data points
        if (chart.data.labels.length > MAX_DATA_POINTS) {
            chart.data.labels.shift();
            chart.data.datasets.forEach((dataset) => {
                dataset.data.shift();
            });
        }
        chart.update();
    }

    // --- WebSocket Connection ---
    const socket = new WebSocket('ws://localhost:8080');

    socket.onopen = () => {
        console.log('WebSocket connection established');
    };

    socket.onmessage = (event) => {
        const message = JSON.parse(event.data);
        const topic = message.topic;
        const data = message.data;
        const now = new Date();
        const timeLabel = `${now.getHours()}:${now.getMinutes()}:${now.getSeconds()}`;

        console.log(`Received from ${topic}:`, data);

        if (topic.includes('temperature')) {
            addData(tempChart, timeLabel, data.value);
        } else if (topic.includes('humidity')) {
            addData(humidityChart, timeLabel, data.value);
        }
    };

    socket.onclose = () => {
        console.log('WebSocket connection closed');
    };

    socket.onerror = (error) => {
        console.error('WebSocket error:', error);
    };

</script>
</body>
</html>

So funktioniert es

1. Diagrammeinrichtung: Mit der Bibliothek Chart.js erstellen wir zwei Liniendiagramme, eines für die Temperatur und eines für die Luftfeuchtigkeit. Wir konfigurieren sie mit grundlegender Gestaltung und Beschriftungen.
2. WebSocket-Client: Wir erstellen eine neue Instanz von WebSocket, die sich mit unserem Backend-Server unter ws://localhost:8080 verbindet.
3. socket.onmessage: Hier empfangen wir die vom Node.js-Server gesendeten Daten. Wir parsen den eingehenden JSON-String.
4. Datenweiterleitung: Wir prüfen das topic der Nachricht, um zu entscheiden, welches Diagramm aktualisiert wird.
5. Funktion addData(): Diese Hilfsfunktion fügt den neuen Datenpunkt und eine Zeitstempelbeschriftung dem richtigen Diagramm hinzu. Damit das Diagramm lesbar bleibt, entfernt sie außerdem den ältesten Datenpunkt, sobald MAX_DATA_POINTS überschritten wird, und erzeugt so einen „gleitenden Fenster“-Effekt.

Um es in Aktion zu sehen, öffnen Sie einfach die Datei index.html in Ihrem Webbrowser. Die Diagramme beginnen sich in Echtzeit zu aktualisieren, sobald Daten von Ihrem ESP32 eintreffen!

Bewährte Sicherheitspraktiken

Unsere aktuelle Einrichtung eignet sich gut für die Entwicklung, in einer Produktivumgebung ist Sicherheit jedoch unverzichtbar. Hier sind die entscheidenden nächsten Schritte.

• Anonymen Zugriff auf Ihrem Broker deaktivieren: In einer produktiven Mosquitto-Einrichtung müssen Sie anonyme Verbindungen deaktivieren und Benutzerkonten mit Passwörtern anlegen.
  • Verwenden Sie mosquitto_passwd, um eine Passwortdatei zu erstellen.
  • Setzen Sie in Ihrer mosquitto.conf die Werte allow_anonymous false und password_file /path/to/passwordfile.
• TLS/SSL-Verschlüsselung verwenden: MQTT- und WebSocket-Verkehr sollte verschlüsselt sein.
  • Konfigurieren Sie Ihren MQTT-Broker so, dass er TLS auf Port 8883 verwendet. Ihre ESP32- und Node.js-Clients müssen für eine sichere Verbindung konfiguriert werden (mqtts:// und wss://).
  • Das verhindert Man-in-the-Middle-Angriffe, bei denen ein Angreifer Ihre Sensordaten oder Zugangsdaten abfangen könnte.
• Autorisierung (ACLs) umsetzen: Verwenden Sie Access Control Lists (ACLs), um das Prinzip der geringsten Rechte durchzusetzen.
  • Ein bestimmtes Gerät (device1) darf nur in seinen eigenen Topics (wearable/device1/+) veröffentlichen.
  • Ihr Backend-Server darf nur die Topics abonnieren, die er benötigt (wearable/+/+).
  • So kann ein kompromittiertes Gerät keine schädlichen Daten in anderen Topics veröffentlichen und auch keine Daten mithören, auf die es keinen Zugriff haben sollte.

Fazit

Herzlichen Glückwunsch! Sie haben erfolgreich eine vollständige IoT-Datenpipeline in Echtzeit aufgebaut. Wir sind von einem physischen Sensor auf einem ESP32 über einen skalierbaren MQTT-Broker und ein reaktives Node.js-Backend bis zu einem live aktualisierten Dashboard im Webbrowser gegangen.

Sie haben nun eine solide Grundlage, auf der Sie aufbauen können. Sie können dieses Projekt erweitern, indem Sie:

• weitere Sensoren und Geräte hinzufügen.
• die Daten in einer Zeitreihendatenbank wie InfluxDB oder TimescaleDB für historische Analysen speichern.
• im Backend Alarmregeln hinzufügen, die Benachrichtigungen senden, wenn Sensorwerte einen bestimmten Schwellenwert überschreiten.
• ein anspruchsvolleres Frontend-Dashboard mit React, Vue oder Svelte bauen.

Die Pub/Sub-Architektur mit MQTT und WebSockets ist äußerst leistungsfähig und bildet das Rückgrat unzähliger professioneller IoT-Systeme. Legen Sie los und beginnen Sie zu bauen!

Ressourcen

• ESP32 MQTT: Random Nerd Tutorials - ESP32 MQTT Publish Subscribe
• Node.js-MQTT-Client: mqtt.js on GitHub
• Node.js-WebSocket-Bibliothek: ws on npm
• Chart.js: Official Documentation
• MQTT-Sicherheit: HiveMQ MQTT Security Fundamentals

Kurzreferenz

Häufig gestellte Fragen

F: Wie weiß ich, ob das auf mich zutrifft? A: Besprechen Sie Ihre persönliche und familiäre Krankengeschichte mit Ihrer Ärztin oder Ihrem Arzt, um Ihre individuellen Risikofaktoren zu beurteilen und geeignete nächste Schritte festzulegen.

F: Was sollte ich meine Ärztin oder meinen Arzt fragen? A: Gute Fragen sind: „Was bedeuten meine Ergebnisse?“, „Welche Möglichkeiten habe ich?“, „Welche Lebensstiländerungen würden helfen?“ und „Wann sollte ich zur Nachkontrolle kommen?“

F: Gibt es Lebensstiländerungen, die helfen können? A: Die meisten Erkrankungen profitieren von grundlegenden Maßnahmen: ausgewogene Ernährung, regelmäßige körperliche Aktivität (150+ Minuten/Woche), erholsamer Schlaf (7–9 Stunden), Stressbewältigung und Verzicht auf Tabak.

Medizinischer Haftungsausschluss

Dieser Artikel dient ausschließlich der Aufklärung und stellt keine medizinische Beratung dar. Konsultieren Sie stets eine qualifizierte medizinische Fachperson, bevor Sie Entscheidungen über Ihre Gesundheit, Behandlung oder Versorgung treffen. Individuelle Umstände unterscheiden sich, und was für eine Person angemessen ist, muss für eine andere nicht angemessen sein.

Wenn Sie einen medizinischen Notfall erleben, rufen Sie sofort 911 (oder Ihre örtliche Notrufnummer) an.