===== EKG-to-go =====

Unser EKG-to-go ist ein kleines EKG-Gerät für Zuhause, welches einem ermöglicht zu jeder Zeit eine Ableitung der {{ :ekg-box.png?nolink&200|}}
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_display|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 [[ad-wandler|Analog - Digital - Wandler]] versehen, der dieses Signal wiederum digitalisieren kann. Die Messwerte werden daraufhin
auf den [[lcd_display|LCD - Touch - Display]] geleitet, wo diese dann als Kurve graphisch dargestellt werden. 

{{ :schaltung.jpg?nolink&400 |}} 
**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.png?nolink&400|}} Fitzing-Schaltung

**Code-Ausschnitte:**
Besteht aus drei Teilen:
  *  AD-Wandlung
  *  Graphische Oberfläche
  *  Wertezeichnung (Kurve) = Dauerschleife

Import von ,,tkinter“ Bibliothek erforderlich
Python als Programmiersprache 
<file python 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
</file>
<file python 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)
</file>
<file python 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()
</file>