Die STONE serieller tragbarer Touchscreen-Monitor, die Hardwareabteilung entschied sich für die Verwendung des 32-Bit-Mikroprozessorchips von NXP als gesamte Maschinenüberwachung, EKG-Analyse, Kontrollzentrum, durch EKG-Bioelektrizitätserfassungsverstärkung, Antrieb des rechten Beins, Import der MIT-EKG-Datenbank, um einen Algorithmus zu erstellen, aber Überwachen Sie auch das elektrische Signal des SpO2-Sensors, den Blutdruck, die Verstärkung des elektrischen Atmungssignals und die Filterverarbeitung durch Hochgeschwindigkeits-Baudratenkommunikation, Laufwerk STONE seriell aufnehmen Bildschirm um Wellenform- und Parameteränderungen in Echtzeit anzuzeigen und mit einem Referenzwert zu vergleichen, um eine Beurteilung vorzunehmen, und um die Änderungen der Parameter des menschlichen Körpers zu überwachen und Alarm zu geben. Bei einer Reichweitenabweichung erfolgt automatisch eine Sprachmeldung.
Die neue Version des STONE serieller Touchscreen unterstützt perfekt Kurvendarstellung und -anzeige, das Kommunikationsprotokoll ist einfach und leicht zu merken, Mikrocontroller-Ingenieure können es nach dem Lesen des Handbuchs verwenden, es gibt viele Beispiele für Treiber im Befehlssatz, die direkt kopiert werden können, um den Namen und die Parameter zu ändern verwendet werden. Die serielle Verbindung ist einfach, Sie können die offizielle Adapterplatine verwenden, egal ob es sich um eine direkte serielle Verbindung oder eine USB-zu-Seriell-Verbindung handelt, sie ist sehr bequem und einfach zu bedienen. Der Monitor zeigt mehrere Gruppen von Vitalparametern gleichzeitig an, insbesondere 3 Kurven, die dynamisch gezeichnet und gleichzeitig sehr flüssig dargestellt werden, und sollte in der Lage sein, mehr Gruppen von Kurvengrafiken gleichzeitig zu zeichnen, können Sie bei Bedarf ausprobieren . Natürlich hat die Befehlssatzkurvenfunktion ein Beispiel für mehrere Daten gleichzeitig gepusht, aber die tatsächliche Verwendung der aktuellen Hardware reagiert nicht, ich hoffe, das kann so schnell wie möglich offiziell optimiert werden. Es kann auch durch Aktualisieren der Firmware behoben werden. Für diese neue Version der Zeichnungskurvenfunktion habe ich zuerst versucht, wie sie nicht eingestellt werden kann, und schließlich erfahren, dass der serielle Bildschirm eine neue Firmware hat, die neue Firmware gebürstet, um das „wahre Gesicht des Berges“ zu sehen. Wenn man die glatte EKG-Kurve sieht, die mit der gebürsteten Firmware aus dem seriellen Bildschirm kommt, ist die Stimmung glücklich, huh ……
Das Designbild dieses Projekts ist in Abbildung (1) dargestellt. Die Schnittstelle basiert auf a STWI101WT-01 serieller Bildschirm mit einer Auflösung von 1024*600, die linke Seite zeigt 2/3 der Wellenformkurve und das rechte 1/3 zeigt den Wert.
Dieser Artikel konzentriert sich auf die Erstellung und Darstellung der Kurvendiagrammansicht. Es entspricht vollständig dem Produktionsprozess der Projektdemo, ohne Klassifizierung, vielleicht fühlen Sie sich chaotisch, aber es ist der wahre Prozess der echten Entwicklung.
Zunächst entschieden wir uns, die Kurvendarstellung des EKG zu fixieren.
Diese Demo simuliert eine Herzfrequenz von 75 Schlägen pro Minute, was einem Herzschlag von 800 ms entspricht, dh ein Punkt alle 40 ms, ein Zyklus alle 20 Punkte, basierend auf der gesamten X-Achse der Diagrammansicht, die in 100 gleiche Teile unterteilt ist, 4-Sekunden-Wellenform pro Bildschirm, Bildschirmaktualisierung Rate 25Hz, sieht sehr glatt aus. Das Linienserienelement dieser Diagrammansichtssteuerung ist auf glatt = falsch eingestellt (EKG-Wellenform ist scharf), die untere Hüllkurve wird nicht angezeigt und die Punktmarkierung wird nicht angezeigt. Bereich. Hier siehe Abbildung (4), min = 0, max = 140 für die Y-Achse, der im Programm angegebene Maximalwert ist 130, und der Bereich ist relativ voll. Siehe Abbildung (2) – Abbildung (7) für andere Parameter, die für Diagrammansicht1 und seine Elemente X-Achse1, Y-Achse2, Balkenserie1 und Linienserie1 festgelegt werden. Wir wählen transparentes rgba (0,0,0,0) für die bg-Farbe des Diagrammansichtssteuerelements, das die Grundfarbe (schwarz) zeigt, und andere Steuerelemente, wie z. B. Ansicht, haben die gleichen Eigenschaften.
Der Programmiercode zum Simulieren der EKG-Wellenform (75 bpm) gemäß den obigen Einstellungen lautet wie folgt.
Definieren Sie zunächst zwei Variablen wie folgt.
Int num19_1 = 0;
Int num19_2 = 0;
Then generally in the main loop main.c, the ECG curve is depicted by the following code.
delay(10);
num19_1 += 1;
if(num19_1 >= 4){ // Draw one point every 40ms.
num19_1 = 0;
num19_2 += 1;
if(num19_2 == 3){
Serial.println("ST<{\"cmd_code\":\"set_value\",\"type\":\"line_series\",\"widget\":\"line_series1\",\"mode\":\"push\",\"value\" :10}>ET");
}else if(num19_2 == 4){
Serial.println("ST<{\"cmd_code\":\"set_value\",\"type\":\"line_series\",\"widget\":\"line_series1\",\"mode\":\"push\",\"value\" :130}>ET");
}else{
Serial.println("ST<{\"cmd_code\":\"set_value\",\"type\":\"line_series\",\"widget\":\"line_series1\",\"mode\":\"push\",\"value\" :40}>ET");
}
if(num19_2 >= 20){ //every 20 data is a cycle
num19_2 = 0;
}
}
Dann möchten Sie sich um die CO2-Kurve kümmern und sich auf die Scan-Synchronisation konzentrieren.
Die 3 Kurven dieses Projekts, Diagrammansicht 2 ist für den SpO2-Blutsauerstoffsensor und Diagrammansicht 3 ist für die CO2-Atmung.
Diagrammansicht 2, Diagrammansicht 3 X-Achse sind auf min = 0, max = 100 und EKG-Diagrammansicht 1 gleich eingestellt, Kurvendurchlauf, um synchron zu bleiben, Diagrammansicht 2 Y-Achse 2 auf max = 100, so dass die Vorbereitung des Programms Y-Achsenwert gegeben ist bis maximal 95 ist der Algorithmus im folgenden Programmcode dargestellt.
First, define 3 variables as follows.
Int num19_3 = 0;
Int num19_4 = 0;
Int num19_5 = 0;
The CO2 curve is then generally depicted in the main loop, main.c, by the following code.
num19_3 += 1;
if(num19_3 >= 4){ //one point every 40ms
num19_3 = 0;
num19_4 += 1;
if(num19_4 <= 10){
num19_5 = num19_4*9; //the first 10 points increase linearly
Serial.print("ST<{\"cmd_code\":\"set_value\",\"type\":\"line_series\",\"widget\":\"line_series3\",\"mode\":\"push\",\"value\":" );
Serial.print(num19_5);
Serial.println("}>ET");
}else if(num19_4 <= 40){ // the last 30 points decrease linearly
num19_5 = 95 - (num19_4 - 10)*3;
Serial.print("ST<{\"cmd_code\":\"set_value\",\"type\":\"line_series\",\"widget\":\"line_series3\",\"mode\":\"push\",\"value\":" );
Serial.print(num19_5);
Serial.println("}>ET");
}else{
num19_4 = 0;
Serial.println("ST<{\"cmd_code\":\"set_value\",\"type\":\"line_series\",\"widget\":\"line_series3\",\"mode\":\"push\",\"value\" :5}>ET");
} }
Die folgende CO2-Wellenform in Abbildung (8) ist die Wirkung des obigen Programms, wenn das Attributsymbol runder Radius = 4 für die Linienserie3 ist. Wir versuchen, das Symbol Rundungsradius = 30 zu ändern, in der Hoffnung, dass der Kurvenübergang abgerundeter ist, aber das Testergebnis unterscheidet sich nicht von Abbildung (8), siehe Abbildung (9), die zeigt, dass bei dichteren Punkten der Rundungseffekt auftritt ist nicht offensichtlich. Dies kann nur durch Änderung der Punktkoordinaten erreicht werden.
Schauen wir uns die Eigenschaften der X-Achse in Abbildung (3) anhand von Abbildung (10) an. Wenn in Abbildung (3) show = true für die Trennlinie gilt, wird der lange vertikale Balken (Trennbalken) angezeigt; wenn show = true for line, wird die horizontale Linie der X-Achse angezeigt (z. B. die horizontale Linie am unteren Rand der oberen Diagrammansicht); wenn show = true für tick, wird die dünne Linie der Skala unter der horizontalen Linie der X-Achse angezeigt; wenn show = true für label, wird die Zahl unter der horizontalen Linie der X-Achse (der in die Daten eingetragene Wert) angezeigt. = wahr, es wird die Zahl unter der horizontalen Linie der X-Achse angezeigt (der in die Daten eingetragene Wert). Das ist alles.
Jetzt war es an der SpO2-Kurve und es wurde entschieden, AD-Konvertierung zu verwenden.
Kurvensimulation mit ESP32 ADC, es ist 12-Bit, Vollausschlag 4096. Diagrammansicht2 Y-Achse max = 255, der ADC-Einlesewert geteilt durch 20, kann die Kurvenanzeige erfüllen. Die SPO2-Vollanzeige beträgt 100 %, sodass der ADC-Wert geteilt durch 20 und dann geteilt durch 2.55 in Label2 angezeigt werden kann, das Programm, da es sich um eine Ganzzahloperation handelt, der Algorithmus korrigiert wird, siehe eigentlicher Test ok programmcode. Verwenden Sie die Funktion analogRead(32) in Arduino, um den AD-Umwandlungswert von GPIO32 (auch ADC-CH4) von ESP32 direkt zu lesen. Der Test kann mit einem Potentiometer durchgeführt werden, aber Sie können auch einfach den ADC-CH4-Pin mit GND, +3.3 V, +5 V oder Überhang verbinden, um die Interferenzwellenform zu sehen, siehe Videoeffekt (niedrig angezeigt, wenn geerdet, verbunden mit +3.3 V, +5 V ist die gleiche hohe volle Amplitude, der Überhang ist eine falsche Kurve), die rechte label2-Steuerung zeigt rechtzeitig ADC-Spannungsänderungen an. Der Code und Algorithmuscode ist wie folgt.
//--------ADC-------
int adcPin = 32; // GPIO32, also ADC-CH4
int adcValue = 0;
int num19_6 = 0;
delay(10);
adcValue = analogRead(adcPin); // Read in the value of the AD conversion
adcValue = adcValue/20;
//-----SPO2 curve plotting ------
num19_6 += 1;
if(num19_6 >= 4){ // one point every 40ms
num19_6 = 0;
Serial.print("ST<{\"cmd_code\":\"set_value\",\"type\":\"line_series\",\"widget\":\"line_series2\",\"mode\":\"push\",\"value\":" );
Serial.print(adcValue);
Serial.println("}>ET");
adcValue = (adcValue*10)/21;
Serial.print("ST<{\"cmd_code\":\"set_value\",\"type\":\"label\",\"widget\":\"label2\",\"value\":");
Serial.print(adcValue);
Serial.println("}>ET");
}
Siehe Abbildung (11) für eine Teilaufnahme des eigentlichen Bildes und Abbildung (12) für die Designschnittstelle im Computer. Wie in Abbildung (3), wenn show = false der Teilungslinie der X-Achse2 der Diagrammansicht2, schaltet der Trennbalken des gelben SPO2-Bereichs in der Mitte von Abbildung (12) die Anzeige aus (wie der echte Bild); Die glatte Wellenform der Videoanzeige kann vollständig als Echtzeit-Oszilloskop erfolgen.
Bezugspunkte
- Die Struktur der STONE Die Diagrammansichtssteuerung der Designer-Plattform ist in Abbildung (13) dargestellt. Es gibt eine detaillierte Beschreibung im offiziellen Benutzerhandbuch 8.1, einschließlich der Erklärung jeder Eigenschaft und jedes Parameters; der Befehlssatz 4.24 gibt die Methode des Datenschiebens an, siehe Abbildung (14), und es gibt hier Beispiele für Befehle, die im Programm verwendet werden.
2. AnalogRead()-Lesefunktion von Arduino für analoge AD-Wandlung. Im Menü „Hilfe“ – „Referenz“ – „Lernen –– „Analog I/O“ der Arduino-Version 1.8.13 können Sie die Beschreibung der analogRead()-Funktion wie folgt sehen.
analogRead ()
Beschreibung
Das Arduino-Board enthält einen 6-Kanal (8 Kanäle beim Mini und Nano, 16 beim Mega), 10-Bit-Analog-Digital-Wandler. Dies bedeutet, dass er Eingangsspannungen zwischen 0 und 5 Volt in ganzzahlige Werte zwischen 0 und 1023 umwandelt. Dies ergibt eine Auflösung zwischen den Messwerten von 5 Volt / 1024 Einheiten oder 0049 Volt (4.9 mV) pro Einheit. analogReferenz ().
Das Lesen eines Analogeingangs dauert etwa 100 Mikrosekunden (0.0001 s), sodass die maximale Leserate etwa 10,000 Mal pro Sekunde beträgt.
Syntax
analogLesen (pin)
Parameter
pin: die Anzahl der analogen Eingangspins, von denen gelesen werden soll (0 bis 5 bei den meisten Boards, 0 bis 7 beim Mini und Nano, 0 bis 15 beim Mega)
Rücksendungen
Ganzzahl (0 bis 1023)
Hinweis
Wenn der analoge Eingangspin mit nichts verbunden ist, schwankt der von analogRead() zurückgegebene Wert basierend auf einer Reihe von Faktoren (z. B. den Werten der anderen analogen Eingänge, wie nahe Ihre Hand an der Platine ist usw.).
Beachten Sie jedoch, dass hier der ADC-CH4 von ESP32 12 Bit beträgt und der Rückgabewert 0 bis 4096 beträgt. Weitere Details finden Sie unter dem entsprechenden Link im Originalartikel und im ESP32-Handbuch.
