hallo allerseits,
mit welcher art von sensor könnte ich (ausgewertet durch einen arduino) mit einer genauigkeit von +/- 10° feststellen ob eine testperson in rückenlage liegt?
Druckbare Version
hallo allerseits,
mit welcher art von sensor könnte ich (ausgewertet durch einen arduino) mit einer genauigkeit von +/- 10° feststellen ob eine testperson in rückenlage liegt?
also ich selbst könnte mir vorstellen das mit dem gyro MPU6050 zu messen, das kästchen mit der MPU und einem wemos D1 (mit BT) müsste die testperson quasi mit einem breiten klettband um den bauch gebunden haben. Die wemos node MCU müsste die rückenlage einem gerät in form eine smartwatch per BT melden, das gerät würde dann anfangen zu vibrieren um die testperson dazu zu bewegen aus der rückenlage rauszugehen....
Möglich?
Vielleicht auch mit anderen methoden?
Soll der Messaufbau an der Person oder an der Liege sein?
Deine Idee müsste eigentlich funktionieren, wenn er an der Person befestigt ist.
An der Liege könnte man druckempfindliche Sensoren in der Gegend der Schulterblätter anbringen, denke ich- Wägesensoren, oder sowas.
es geht um schlafapnoe, die tritt meistens beim schlafen auf dem rücken auf. Ich denke dass es sinnvoller ist die sensoren für die rückenlage "am man" zu haben, die kann man dann einfacher mitnehmen...
ich teste es mal mit dem gyro ob das überhaupt denkbar wäre...
ein zusätzliches problem ist der vibrator am handgelenk. Ich dachte da an sowas ähnliches wie ein fitnessstracker. Ein leeres gehäuse bekommt man günstig beim chinesen, durchmesser 44mm, höhe ca. 10mm. Und da muss der BT-empfänger, microcontroler, akku, ladebuchse und der vibrator rein. Das grösste problem wird wohl der controler sein, sowas kleines gibts glaube ich garnicht...
Eine Banglejs könnte das..
ich hab mir die möglichkeiten die auf der webseite beschrieben sind nur ganz flüchtig angeschaut: Hast Du erfahrung mit der uhr?
Ich hab eine und habe auch ein wenig damit rumgespielt. Lässt sich halt mit Javascript programmieren und man hat u.a. Zugriff auf die IMU, den Buzzer und Bluetooth Funktionen. Die Dokumentation ist gut und die Toolchain läuft zwar im Browser aber man kann trotzdem damit arbeiten. Die Uhr ist allerdings recht groß weswegen sie vielleicht nicht jeder am Arm tragen möchte.
Ich würde allerdings die Rückenlage eher am Bein messen als am Arm.
Der Kleinste, fertige, den ich kenne ist der Arduino Pro Mini.
Mit den Dingern wurden auch schon Smartuhren gebaut (google mal, da gibts einiges zu)- wirklich klein ist das nicht, aber es geht schon.
wie stark ist der buzzer - kannst Du Dir vorstellen dass man davon wach wird?Zitat:
Zitat von Defiant
am handgelenk war nur der auswertender buzzer geplant, der eigentliche sensor sollte um die brust gebunden werden, aber das fussgelenk ist super idee!Zitat:
Zitat von Defiant
das stimmt allerdings, muss mir das anschauen. Einiges auf der basis von ESP32 liesst sich sehr gut. Der tipp von dir war -wie immer - super!Zitat:
Zitat von Rabenauge
Kommt darauf an wie tief die Zielperson schläft. Bei mir hat es nachts bisher gut geklappt, aber beim fahrradfahren hab ich es schon mehrmals nicht mitbekommen.Zitat:
Zitat von inka
ich hatte mir bei philips was bestellt ( https://www.philips.de/c-e/smartslee...ontent_advisor )
habe es nach einer woche wieder zurückgeschickt. Schön verarbeitet, noch schöner verpackt, manual auf hochglanzpapier, allerdings war die bedienung miserabel und eine auswertungsmöglichkeit auch - nämlich keine. Der preis jenseits von gut und böse...
hab jetzt was selbst gebastelt, es funktioniert, statt der LED kann man natürlich auch ein buzzer schalten. Oder leichte stromschläge :-)
ein breadboard model ist fertig:
https://youtu.be/5zvhXQoEOpg
jetzt muss ich es nur noch in ein gehäuse packen...
der prototyp ist fertig
Anhang 35437 Anhang 35438
wurde auch schon paar nächte getestet, funktioniert so weit. Das kästchen wird mit den zwei magneten an einem flexiblen band un der um die brust befestigt. Zwei dinge sollten noch verbessert / korrigiert werden:
- auf dem esp8266 läuft eine STA, erreichbar im home-wifi. Schien mir einfacher als das ewige auslogen und in einen eigenständigen AP anmelden. Über das wifi sollen einstellungen wie die stärke und frequenz des "wecksignals" eingestellt werden können, wie auch die anzeige und später eine auswertung von gespeicherten daten stattfinden. Nach längerem suchen, testen und anpassen habe ich nun folgenden code auf dem esp laufen:
wie gesagt, so weit fast alles ok, die darstellung auf der webseite ist nicht gut, vermute einen HTML problemCode:#include <Wire.h>
#include <Arduino.h>
#include <ESP8266WiFi.h>
#include <ESPAsyncTCP.h>
#include <ESPAsyncWebServer.h>
//Spannung auslesen vorbereiten
ADC_MODE(ADC_VCC);
String Ubatt = "";
//verbinden mit wlan
const char* ssid = "a-b-c";
const char* password = "x-y-z";
// Hier wird der aktuelle Status der schalter festgehalten
String summer_zustand = "off";
String LED_zustand = "off";
//slider power
String sliderValue_power = "400";//0
const char* PARAM_INPUT_POWER = "value";
//slider frequency
String sliderValue_frequency = "2";//0
const char* PARAM_INPUT_FREQUENCY = "value";
//frequency
uint8_t frequency = 0;
// Create AsyncWebServer object on port 80
AsyncWebServer server(80);
//website - slider
const char index_html[] PROGMEM = R"rawliteral(
<!DOCTYPE HTML>
<html>
<head>
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>anti apnoe web</title>
<style>
html {font-family: Arial; display: inline-block; text-align: center;}
h2 {font-size: 2.3rem;}
p {font-size: 1.9rem;}
body {max-width: 400px; margin:0px auto; padding-bottom: 25px;}
.slider { -webkit-appearance: none; margin: 14px; width: 300px; height: 25px; background: #FFD65C;//360px
outline: none; -webkit-transition: .2s; transition: opacity .2s;}
.slider::-webkit-slider-thumb {-webkit-appearance: none; appearance: none; width: 35px; height: 35px; background: #003249; cursor: pointer;}
.slider::-moz-range-thumb { width: 35px; height: 35px; background: #003249; cursor: pointer; }
</style>
</head>
<body>
<h2>vibration power</h2>
<p><span id="textSliderValue_power">%SLIDERVALUE_POWER%</span></p>
<p><input type="range" onchange="updateSliderPWM_power(this)" id="pwmSlider_power" min="300" max="1023" value="%SLIDERVALUE_POWER%" step="1" class="slider"></p>
<script>
function updateSliderPWM_power(element)
{
var sliderValue_power = document.getElementById("pwmSlider_power").value;
document.getElementById("textSliderValue_power").innerHTML = sliderValue_power;
console.log(sliderValue_power);
var xhr = new XMLHttpRequest();
xhr.open("GET", "/slider?value="+sliderValue_power, true);
xhr.send();
}
</script>
<h2>vibration frequency</h2>
<p><span id="textSliderValue_frequency">%SLIDERVALUE_FREQUENCY%</span></p>
<p><input type="range" onchange="updateSliderPWM_frequency(this)" id="pwmSlider_frequency" min="0" max="10" value="%SLIDERVALUE_FREQUENCY%" step="1" class="slider"></p>
<script>
function updateSliderPWM_frequency(element)
{
var sliderValue_frequency = document.getElementById("pwmSlider_frequency").value;
document.getElementById("textSliderValue_frequency").innerHTML = sliderValue_frequency;
console.log(sliderValue_frequency);
var xhr = new XMLHttpRequest();
xhr.open("GET", "/slider?value="+sliderValue_frequency, true);
xhr.send();
}
</script>
</body>
</html>
)rawliteral";
// Replaces placeholder with button section in your web page
String processor(const String& var)
{
//Serial.println(var);
if (var == "SLIDERVALUE_POWER")
{
return sliderValue_power;
}
return String();
if (var == "SLIDERVALUE_FREQUENCY")
{
return sliderValue_frequency;
}
return String();
}
//lagezaehler
uint8_t rueckenlage = 0;
//LED
#define LED_pin_gruen D1
int LED_state_gruen = LOW;
long previousMillis_gruen = 0;
//summer
#define summer D2
//timer
unsigned long aktuelle_timer_millis, vergangene_timer_millis;
unsigned long halbe_tick, sekunden_tick;
unsigned long interval_timer = 1000;
// MPU6050 Slave Device Address
const uint8_t MPU6050SlaveAddress = 0x68;
double Ax, Ay, Az, T, Gx, Gy, Gz;
// Select SDA and SCL pins for I2C communication
const uint8_t scl = D7;
const uint8_t sda = D6;
// sensitivity scale factor respective to full scale setting provided in datasheet
const uint16_t AccelScaleFactor = 16384;
const uint16_t GyroScaleFactor = 131;
// MPU6050 few configuration register addresses
const uint8_t MPU6050_REGISTER_SMPLRT_DIV = 0x19;
const uint8_t MPU6050_REGISTER_USER_CTRL = 0x6A;
const uint8_t MPU6050_REGISTER_PWR_MGMT_1 = 0x6B;
const uint8_t MPU6050_REGISTER_PWR_MGMT_2 = 0x6C;
const uint8_t MPU6050_REGISTER_CONFIG = 0x1A;
const uint8_t MPU6050_REGISTER_GYRO_CONFIG = 0x1B;
const uint8_t MPU6050_REGISTER_ACCEL_CONFIG = 0x1C;
const uint8_t MPU6050_REGISTER_FIFO_EN = 0x23;
const uint8_t MPU6050_REGISTER_INT_ENABLE = 0x38;
const uint8_t MPU6050_REGISTER_ACCEL_XOUT_H = 0x3B;
const uint8_t MPU6050_REGISTER_SIGNAL_PATH_RESET = 0x68;
int16_t AccelX, AccelY, AccelZ, Temperature, GyroX, GyroY, GyroZ;
void setup()
{
Serial.begin(115200);
Serial.print("code----/home/georg/Arduino/schlaf_apnoe/anti_apnoe_STA_browser_zwei_slider_zugriff_2");
//MPU
Wire.begin(sda, scl);
MPU6050_Init();
//summer
pinMode(D2, OUTPUT);
//LED
pinMode(D1, OUTPUT);
//start-meldung summer und LED
analogWrite(summer, 500);
delay(500);
analogWrite(summer, 0);
digitalWrite(LED_pin_gruen, HIGH);
delay(500);
digitalWrite(LED_pin_gruen, LOW);
// mit wlan verbinden
Serial.println();
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");
// server starten
server.begin();
Serial.println("Server started");
// locale Ip adresse
Serial.print("Use this URL to connect: ");
Serial.print("http://");
Serial.print(WiFi.localIP());
Serial.println("/");
// Route for root / web page
server.on("/", HTTP_GET, [](AsyncWebServerRequest *request)
{
request->send_P(200, "text/html", index_html, processor);
});
// Send a GET request to <ESP_IP>/slider?value=<inputMessage_power>
server.on("/slider", HTTP_GET, [] (AsyncWebServerRequest *request)
{
String inputMessage_power;
// GET input1 value on <ESP_IP>/slider?value=<inputMessage_power>
if (request->hasParam(PARAM_INPUT_POWER))
{
inputMessage_power = request->getParam(PARAM_INPUT_POWER)->value();
sliderValue_power = inputMessage_power;
analogWrite(summer, sliderValue_power.toInt());
}
else
{
inputMessage_power = "No message sent";
}
Serial.println(inputMessage_power);
request->send(200, "text/plain", "OK");
});
// Send a GET request to <ESP_IP>/slider?value=<inputMessage_frequency>
server.on("/slider", HTTP_GET, [] (AsyncWebServerRequest *request)
{
String inputMessage_frequency;
// GET input1 value on <ESP_IP>/slider?value=<inputMessage_frequency>
if (request->hasParam(PARAM_INPUT_FREQUENCY))
{
inputMessage_frequency = request->getParam(PARAM_INPUT_FREQUENCY)->value();
sliderValue_frequency = inputMessage_frequency;
analogWrite(frequency, sliderValue_frequency.toInt());
}
else
{
inputMessage_frequency = "No message sent";
}
Serial.println(inputMessage_frequency);
request->send(200, "text/plain", "OK");
});
}
void loop()
{
//timer();
//read_gyro();
// blinken_10_sec ();
//abfrage_lage();
//abfrage_lage_10_sec ();
//lage_zaehler();
//sekunden_aufgaben();
}
https://youtu.be/3nwYLq_bsjU
wie man in dem video sehen kann, "entfaltet" sich der untere schieberegler erst beim draufklicken. Könnte bitte jemand einen blick auf den code werfen, ich find den fehler nicht :-(
- zweite verbesserung wäre eine anzeige eines zu neige gehenden akkus. Die spannung wird ja schon gemessen, die tests zeigen, dass der akku für 2 nächte reicht. Meine idealvorstellung wäre, dass wenn die spannung der lipoakku unter den wert sinkt bei dem noch der esp betrieben werden kann eine rote LED aufleuchtet. Wie könnte man das realisieren?
Du kannst doch einfach ne LED aufleuchten lassen-Ausgänge hat der ESP dafür doch genug....allerdings würde ich die angehen lassen, ehe der ESP die Flügel streckt...
Schau doch mal hier nach. Im "Link zur Simulation" gibts ein Schaubild. Dort kann man die Bauteile (Schieberegler, Widerstände) etc anklicken und z.B. den Schieberegler auf (? 8k8 ?) stellen dabei fängt die LED an zu glimmen, ab 8.6k etwa leuchtet die richtig (DezimalPUNKT, nicht Komma!). So ist eine Spannungsänderung möglich. Früher konnte man die Spannung (irgendwie anders) verändern. Hübsch ist bei der gezeigten Schaltung, dass verschiedene Werte mit dem Mauszeiger eingeblendet werden können.Zitat:
.. Meine idealvorstellung wäre .. lipoakku unter den wert sinkt .. eine rote LED aufleuchtet. Wie könnte man das realisieren?
Der LiPo-Akku muss geladen werden, wenn der eine bestimmte untere Spannung erreicht. Gut geeignet ist der Spannungswert, der auf dem LiPo steht - wenn der unterschritten wird, dann sollte der LiPo geladen werden; meine Empfehlung dazu, für eine lange Lebensdauer.Zitat:
Zitat von inka
Eine Rote LED oder so: kann man machen, wird dann aber irgendwann nicht mehr so oft hingeschaut. Dadurch könnte der LiPo zu tief entladen werden.
Du kannst eine Spannungsanzeige bauen, mit so einem kleinen 3V-Display beispielsweise, könnte nett aussehen. Dazu einen Testknopf. Wenn der gedrückt wird, kannst Du die Spannung anzeigen lassen (in Prozent, als Balkengrafik oder wie auch immer). Kann man auch mit 1 LED machen: durch Blinkzeichen anzeigen lassen, wie die Spannung ist (Akku voll 6mal Blinken bspw.).
MfG
Die idee mit dem display ist ganz net, aber nachts ist es ja dunkel...
ich dachte an eine DUO-led, rot/grün, die ist direkt neben dem schiebeschalter eingebaut, leuchtet grün ca 3 sec. nach dem einschalten als "OK" auf, dann erlischt sie. Das gerät soll ja täglich benutzt werden, wenn es sinn machen soll, man muss auch beobachten können, ob sich was ändert, also ob man zum seitenschläfer "umprogrammiert" wird :-)
beim abschalten morgens kann man noch einmal einschalten, grün bedeutet - eine nacht reichts noch, rot würde bedeuten - vor der nächsten nacht laden. man könnte auch mit PWM verschiedene farbtöne zaubern, aber das ist dann wirklich schon spielerei...
Was mich jetzt mehr beschäftigt ist das abspeichern von einstellungen der beiden slider z.b. im SPIFFS, die einstellung soll man zwar immer wieder über die webseite neu machen können, aber nicht machen müssen, wenn also eine kombination aus power und frequenz stimmt, soll sie automatisch beim start geladen werden...
Ich hab jetzt ein paar infos über speichern von dateien im SPIFFS gefunden, das auslesen geht auch (beispielhaft), aber wie ich z.b. die daten richtig in der datei speichern und die richtigen daten wieder auslesen soll - da bin ich noch nicht dahintergestiegen...
Funktioniert es z.b. mit der schlichten anweisung - String sliderValue_power = "532"; - die im setup aus der datei im SPIFFS ausgelesen wird??? Und wie lese ich den einzelnen wert aus der gespeicherten datei aus??? Hat das schon mal jemand gemacht?
Vielleicht mal das hier, unter diesem Link versuchen! Praktikabel, für so einfache Dinge. Und ausreichend. SPIFFs wird nicht mehr unterstützt und soll nicht mehr verwendet werden.
MfG
es sieht so aus, als wäre "preferences.h" nur für ESP32 und nicht für ESP8266...
Nimmst Du keinen ESP32?
nein. der 8266 schien mir für diese anwendung gut genug, es ist der D1 mini... Also doch SPIFFS. Egal ob "man" es nehmen soll oder nicht...
Schnell was zusammen gesucht, zum Lesen und Schreiben
Bei SPIFFS dann statt "LittleFS" eben "SPIFFS" schreiben.Code:#include <LittleFS.h>
#define FileSys LittleFS
//Datei
const char* file = "/meineDatei";
//Wert als Byte
byte b;
//----------------------------------------------
//Datei öffnen und lesen
File f = FileSys.open(file, "r");
//Byte lesen
b = f.read();
//Datei schließen
f.close();
//----------------------------------------------
//Datei öffnen und schreiben
//----------------------------------------------
File f = FileSys.open(file, "w");
//Byte schreiben
f.write(b);
//Datei schließen
f.close();
//----------------------------------------------
Also:
#include <SPIFFS.h>
#define FileSys SPIFFS
danke Moppi,
es geht weiter...
ich hab mir von AZ-delivery (die deutschen erklärungen tun richtig gut :-) ) zwei sketches angepasst:
das schreiben der geänderten slider-variablem (und nur einmal schreiben)
und das zeilenweise auslesen (weiss noch nicht wie ich eine bestimmte zeile auslese :-( )Code:#include <SPI.h>
#include <FS.h> // Nutze die SPIFFS library
int FileSize;
String sliderValue_power = "200";
String sliderValue_power_alt;
File myfile; // erstelle eine SPIFFS Handling Variable
void setup()
{
Serial.begin(115200);
SPI.begin();
bool Result = InitalizeFileSystem();
if (!(SPIFFS.exists ("/power_config.csv") )) //Prüfe ob Datei power_config.csv schon exisiert.
{
myfile = SPIFFS.open("/power_config.csv", "w"); //Öffne die Datei power_config.csv im Root Verzeichnis zum schreiben (w – write)
if (!myfile)
{
Serial.println("Fehler beim schreiben der Datei");
}
Result = myfile.println("sliderValue_power");
Result = myfile.println(sliderValue_power);
myfile.close();
}
else
{
SPIFFS.remove("/power_config.csv"); //Lösche Datei
Serial.println("Datei power_config.csv war schon vorhanden, sie wurde gelöscht.");
}
}
void loop()
{
myfile = SPIFFS.open("/power_config.csv", "r"); //Öffne die Datei usage_log.csv im Root Verzeichnis zum lesen (r - read)
while (myfile.position() < myfile.size()) // lese Dateiinhalt Zeile für Zeile bis um Ende der Datei
{
String content = myfile.readStringUntil('\n');
Serial.println(content);
}
FileSize = myfile.size();
myfile.close();
Serial.print("Dateigroesse in Bytes:"); // gebe die aktuelle Dateigröße in Bytes aus
Serial.println(FileSize); // gebe die aktuelle Dateigröße in Bytes aus
delay (5000);
yield(); // interne ESP8266 Funktionen aufrufen
if (sliderValue_power != sliderValue_power_alt) //die config_power soll nur einmal bei sich änderndem "sliderValue_power" geändert werden
{
myfile = SPIFFS.open("/power_config.csv", "a"); // Öffne Datei um Daten anzuhängen ! (a - append)
myfile.println("sliderValue_power");
myfile.println(sliderValue_power);
myfile.close();
sliderValue_power_alt = sliderValue_power;
}
}
Code:#include "FS.h" // Hier binden wir die benötigte Bibliothek ein
void readLines(File f)
{
String data;
unsigned int zeilenZaehler = 0;
Serial.println("Inhalt der geöffneten Datei:");
while (f.available()) {
data = f.readStringUntil('\n'); // lesen bis Zeilenumbruch...
Serial.print("Zeile ");
Serial.print(zeilenZaehler);
Serial.print(": ");
Serial.println(data); // ... und wieder ausgegeben
zeilenZaehler++;
}
}
void setup()
{
Serial.begin(115200);
SPIFFS.begin(); // Filesystem mounten
File f = SPIFFS.open( "/power_config.csv", "r"); // Datei zum Lesen öffnen
if (!f)
{
Serial.println("file open failed!");
}
else
{
readLines(f); // Funktion fuer das Zeilenweise Auslesen
f.close(); // Datei schliessen
}
SPIFFS.end(); // Filesystem unmounten
}
void loop()
{
}
so sieht die bedienseite am smartphone nun aus:
Anhang 35446
die auswahl der stärke und frequenz der vibration funktioniert schon, die buttons zum lesen und speichern der einstellungen noch nicht ganz...
so sieht es nun aus:
Anhang 35567 Anhang 35568
ich und meine tochter (25) verwenden es regelmässig, die mehrmonatige erfahrung zeigt, dass die rückenlage und damit die gefahren der schlaf-apnoe recht zuverlässig verhindert werden. Es tritt sogar ein gewisser unbewusster lerneffekt ein - man dreht sich auch im halbschlaf eher auf die seite, um das lästige vibrieren an der brust zu vermeiden :-)
das problem mit dem akku habe ich ganz einfach gelöst, das gerät wird abwechselnd mit dem smartphone geladen - das eine nachts, das andere tagsüber...
Meine hausärztin zeigte auch interesse an einem prototyp, wollte es im familienkreis testen...
Mich beschäftigt jetzt ein ganz anderes problem: Wie kann ich die geschichte publik machen? Nicht falsch zu verstehen, keine patentierung, eher das gegenteil. Dieses ding ist nicht patentwürdig. Es sollte aber jeder der nach irgendwas gegen schlafapnoe sucht die möglichkeit haben es nachzubauen - wie mache ich das?
Wie wäre es mit einem Artikel in der Make (Make-Magazin)?Zitat:
Mich beschäftigt jetzt ein ganz anderes problem: Wie kann ich die geschichte publik machen? Nicht falsch zu verstehen, keine patentierung, eher das gegenteil. Dieses ding ist nicht patentwürdig. Es sollte aber jeder der nach irgendwas gegen schlafapnoe sucht die möglichkeit haben es nachzubauen - wie mache ich das?
Die Redaktionen freuen sich immer über gute Projekte, die einigermaßen ordentlich dokumentiert sind. Bei den Artikeln sind immer viele Fotos von der Entstehung oder vom aufgeschraubten Gerät, bzw. den Baustufen, wichtig. Wenn Du Tipps zum Artikel schreiben brauchst, lass' es mich wissen. Man hat schnell 20000 Zeichen zusammen.
VG, Jürgen
Ich würde mich über Open Source Lizenzen informieren. Es gibt verschiedene, ich habe mich gerade wegen einem Filamentextruder (damit ich Filament aus Granulat herstellen kann).
Dort bin ich auf eine DIY-Lösung gestoßen (mit richtiger Extruderschnecke). https://www.artme-3d.de
Dieser bietet sein Projekt auch unter einer Open Source Lizenz an. Was in welcher Lizenz steht bzw. was die Beste für dich ist musst du für dich entscheiden/finden.
Vielleicht ist es hilfreich für dich.
MfG Hannes
habs jetzt versucht: findest du mein projekt? es ist noch privat, wenn ich den link verschicke, kann es wohl jeder veröffentlichen?Zitat:
Zitat von jmoors
auch sehe ich dort keine möglichkeit mehrere bilder oder dateien dem artikel zuzuordnen. Das eine bild, was ich da hinzugefügt habe macht eher den eindruck als wäre es als "antwort" hinzugefügt worden - übersehe ich da was?
EDIT: ich habs jetzt einfach freigegeben...
Ich meine in der Zeitung. Ruf mal bei der Redaktion an.
Das Projekt findet man sofort: https://makeprojects.com/de/project/...ei-schlafapnoe