Unser EKG-to-go ist ein kleines EKG-Gerät für Zuhause, welches einem ermöglicht zu jeder Zeit eine Ableitung der Herzfrequenz zu kontrollieren. Da das EKG mit einem Akku versehen ist, ist es zusätzlich auch unterwegs einsatzbereit. Die Elektroden werden je nach gewünschter Ableitung unterschiedlich am Körper des Patienten angelegt.

Aufbau: Das EKG-Gerät zieht seinen Strom aus dem Akku. Dieser versorgt das Raspberry und den LCD - Touch - Display jeweils mit Strom. Um die Ableitung darstellen zu können, wird ein EKG-Chip benötigt, welcher zusätzlich mit den Elektroden verbunden ist. Dieser EKG-Chip besitzt ein analoges Signal. Dieses Signal kann der Raspberry jedoch nicht einlesen, aufgrund dessen wurde das Raspberry mit einem Analog - Digital - Wandler versehen, der dieses Signal wiederum digitalisieren kann. Die Messwerte werden daraufhin auf den LCD - Touch - Display geleitet, wo diese dann als Kurve graphisch dargestellt werden.

Bauteile: unten links: Akku, oben: LCD-Bildschirm, mitte: Raspberry Pi, rechts daneben: Breadboard mit Ad-Wandler, ganz rechts: Breakout-Board mit EKG-Chip + Elektrodenkabel

Fitzing-Schaltung

Code-Ausschnitte: Besteht aus drei Teilen:

• AD-Wandlung
• Graphische Oberfläche
• Wertezeichnung (Kurve) = Dauerschleife

Import von ,,tkinter“ Bibliothek erforderlich Python als Programmiersprache

Bibliotheken.py

#----> Import
from tkinter import *
import random
import time
import RPi.GPIO as GPIO
import numpy as np
import sys
if sys.hexversion > 0x02ffffff:
    import tkinter as tk
else:
    import Tkinter as tk

Analogwerte am ADChannel auslesen.py

def getAnalogData(adCh, CLKPin, DINPin, DOUTPin, CSPin):
    GPIO.output(CSPin,   HIGH)     
    GPIO.output(CSPin,   LOW)
    GPIO.output(CLKPin, LOW)
 
    cmd = adCh
    cmd |= 0b00011000 # Kommando zum Abruf der Analogwerte des Datenkanals adCh
    # Bitfolge senden
    for i in range(5):
        if (cmd & 0x10):
            GPIO.output(DINPin, HIGH)
        else:
            GPIO.output(DINPin, LOW)
        # Clocksignal negative Flanke erzeugen
        GPIO.output(CLKPin, HIGH)
        GPIO.output(CLKPin, LOW)
        cmd <<= 1 # Bitfolge eine Position nach links verschieben
    # Datenabruf
    adchvalue = 0 # Wert auf 0 zurücksetzen
    for i in range(13): #12 Bit Auflösung vom Wandler + 0 Bit
        GPIO.output(CLKPin, HIGH)
        GPIO.output(CLKPin, LOW)
        adchvalue <<= 1 # 1 Postition nach links schieben
        if(GPIO.input(DOUTPin)):
            adchvalue |= 0x01    
    adchvalue = adchvalue * 0.0008
 
 
#---->  Konfiguration Eingangskanal und GPIOs
CLK = 18 # Clock 
DIN = 24 # Digital in 
DOUT = 23  # Digital out
CS = 25  # Chip-Select
 
#---->  Pin-Programmierung
GPIO.setup(CLK, GPIO.OUT) # CLK-Signal = Output vom Raspberry
GPIO.setup(DIN, GPIO.OUT) # Digital Input ADC = Output vom Raspberry
GPIO.setup(DOUT, GPIO.IN) # Digital Output ADC = Input vom Raspberry
GPIO.setup(CS,   GPIO.OUT) # Chip-Select = Output vom Raspberry
 
#----> Funktion: Beendet Programm
def callback1():
    sys.exit(0)

Wertedarstellung.py

    def append_values(self, x):        
        self.Line1.append(float(x))
        self.Line1 = self.Line1[-1 * self.npoints:]
        return
    def replot(self):   
 
        aufloesung = 1600  # Höhe Y-Achse - ((Auflösung-ADC /2)*Faktor) = 0
        h = self.winfo_height()
        max_X = max(self.Line1) + 1e-5                 
        coordsX  =[]
        for n in range(0, self.npoints):
            x = (800 * n) / self.npoints # 800 ist die breite            
            coordsX.append(x)
            coordsX.append(200-(self.Line1[n]*aufloesung))    # 250 pixel (y-achse) - (messwert in v) * auflösunsfaktor        
        self.canvas.coords('X', *coordsX)        
 
    def read(self):
        self.after(1, self.ReadADC)         
        self.after_idle(self.replot)                      
        self.after(20, self.read) # zeitabstand zwischen ad wandlung 20
    def ReadADC(self):
        x = getAnalogData(1,CLK,DIN,DOUT,CS)               
        self.append_values(x)
 
root = tk.Tk()
w, h = root.winfo_screenwidth(), root.winfo_screenheight()   
root.overrideredirect(1)
root.geometry("%dx%d+0+0" % (w, h-20))
app = App(root)
app.mainloop()