EPIDINO

 


*****

Es gibt verschiedene Alarmgeraete zur Erkennung eines epileptischen Anfalls waehrend des Schlafens.

Die Geraete registrieren mittels eines unter der Matratze angebrachten Sensors die  Bewegungen der Matratze und geben einen Alarm aus, wenn nach innerhalb einer festgelegten Zeit die Bewegungshaeufigkeit einem bestimmen Muster entspricht.

Das "Epi-Care" gibt es schon viele Jahre und arbeitet recht zufriedenstellend. 

Das Epi-Care ist fuer alle eine Hilfe, auch der/die Betroffene fuehlt sich sicherer und kann besser schlafen.
Bei einem Anfall piepst das Geraet. Zur Weiterleitung des Alarms wird normalerweise vom Hersteller des Epi-Cares ein <<Pager System mit Vibrator>> angeboten, das zum Anschluss an das Epi-Care-Geraet modifiziert ist. Ein Sender sendet ein Signal zu einem kleinen Pager (oder auch Pieper genannt). Allerdings ist die Reichweite begrenzt.


Die Idee, ein  Epi-Alarmgeraet mit dem Arduino zu bauen, kam, als der Sensor dieses Epi-Care nicht mehr arbeitete und eine schnelle Loesung gefunden werden musste.

Und so entstand das Epidino. Ein Epi-Alarmgeraet mit Uebertragung des Alarms ins Handy-Netz.

Verwendete Baugruppen: ARDUINO UNO, ein Shield fuer die Bauteile und ein GSM-Shield 

Bauteile: Piezo-Element, Beschleunigungssensor, Potentiometer, LEDs, Stopptaste, Widerstaende fuer die LEDs

Eine Leiterplatte fuer die zusaetzlichen Bauteile ist  hier zu sehen.

Der Beschleunigungssensor erfasst die Bewegungen besser, das Piezo-Element erfasst mehr den Druck der Matratze auf die Unterlage (Brett oder Sprungrahmen).
Bei einem Bett ohne Sprungrahmen, bei dem die Matratze auf einem festen Brett liegt, waere der Piezo-Sensor sicher vorteilhafter als der Beschleunigungssensor, der eher bei Bewegungen eines Sprungrahmens reagiert.
Bei einem Futon, der auf dem Boden liegt, arbeitet das Epidino mit Beschleunigungssensor evtl. nicht gut oder gar nicht.. Der Piezo-Sensor ist in diesem Fall vorzuziehen.

Bei dieser Version koennen beide Sensortypen nebeneinander verwendet werden.


Epidino-Plan

Die Pilotlampen sind nicht am Arduino angeschlossen, sondern direkt an der Stromversorgung nach dem Ein-/Ausschalter.



(Aktualisiert am 29.05.2014)

Plan mit Anschlussmoeglichkeit des EpiCare free

Es gibt jetzt ein neues Epi-Care-Geraet mit neuem Konzept. Man traegt ein Armband, das mittels BlueTooth Kraempfe an eine Basisstation sendet. Um das neue Geraet testen zu koennen, ist eine Anschlussmoeglichkeit dafuer wie im folgenden gezeigt vorgesehen.


Im Code ist das EpiCare free bereits mit einbezogen.





 Versuchsaufbau



Das Epidino


Rechts der Ein-/Ausschalter, links daneben die orangefarbene Stopptaste, ganz links, kaum zu erkennen, die LED.
Sobald Bewegungen festgestellt werden,  beginnt der Timer an zu zaehlen. Dies wird durch eine gruene LED signalisiert.
Bei Bewegungen wechselt die Farbe der LED von Gruen auf Rot.



Das Epi-Care free kann im Koffer integriert werden.





Arduino mit GSM shield und Epidino shield.




Das Kaestchen mit der Nummer 1 ist der Beschleunigungssensor, die anderen schwarzen Elemente sind Piezo-Sensoren. Normalerweise wird nur ein Piezo-Sensor benoetigt.
Ist das Bett allerdings gross, kann man weitere Piezo-Sensoren problemlos anstecken.

An der Rueckseite des Koffers befinden sich ausser den Anschluessen fuer die Sensoren auch:
Ganz rechts der Netzadapter-Anschluss (12V-Netzadapter).
Links sind eine Buchse fuer die Tuerlampe und zwei weitere fuer zukuenftige Verwendung.


An Eingang2 kann auch statt des Piezo-Sensors ein zweiter Beschleunigungssensor angeschlossen werden.
An den Piezo-Sensor koennen weitere Piezo-Sensoren angeschlossen werden.





Der Piezo-Sensor
Zwei Plastikplatten, die mit Kabelbinder zusammengehalten werden. Dazwischen befindet sich das Piezo-Element. In der Mitte ist ein Gummifuesschen aufgeklebt
.




Der Beschleunigungs-Sensor
Beschleunigungssensor mit  analogem Ausgang. Betriebsspannung: 3.3V bis 5V. Dieser kann also mit 5V vom Arduino betrieben werden.
Verwendet man einen Beschleunigungssensor mit einer Betriebsspannung von 3,3 V, so muss man Vcc des Sensors mit dem 3V3-Pin  des Arduino verbinden.


 


Der Beschleunigungssensor ist in einem kleinen Plastikkaestchen untergebracht, das mit Styropor aufgefuellt ist.
 (Nr. 1 ist zum Anschluss an die Buchse 1 bestimmt, d.h. sowohl X als auch Y werden ausgewertet.



Tuerlampe (Hier nur ein Muster zur Veranschaulichung gezeigt.)
Die LED ist ueber der Tuer angebracht und ueber ein Kabel und Stecker am Epidino angeschlossen.
Bei eingeschaltetem Epidino leuchtet sie und signalisiert der Nachtwache, dass das Geraet in Betrieb ist.
 



[2014-01-07]
Damit die Stopptaste im Dunkeln besser  zu erkennen ist, ist diese mit einer unten angeklebten LED beleuchtet.
 
 Epidino  ausgeschaltet
  Epidino  eingeschaltet
[nach oben]
Und hier der 
Code

// <<<<<<<<<<<<<   Handy-Nummer, die vom GSM Shield (wenn vorhanden) angerufen wird  >>>>>>>>>>>>>>
char remoteNumber[20]= "0160123456789";   // Handy-Nummer, an die die SMS geschickt werden soll
char txtMsgEpidino[200]="Epidino Zimmer 1";     // SMS-Text (z.B. wenn mehrerer Epidino verwendet werden, hier den Namen)
char txtMsgEpiCareFree[200]="EpiCareFree Zimmer 1";     // SMS-Text fuer EpiCareFree

/* Epidino Source Version: 140107_0911
 Code fuer Beschleunigungssensor (accelerometer) und/oder PiezoSensor
 <<< Mit <J> sind die Stellen markiert, die geaendert werden koennen >>>
 
Anschlussmoeglichkeit von ein oder zwei Sensoren:
 
 o Ein Beschleunigungssensor oder
 o zwei Beschleunigungssensoren oder
 o ein Beschleunigungssensor und ein PiezoSensor oder
 o nur ein PiezoSensor
 
 Je nach angeschlossen Sensoren wird BSensorFlag und PSensorFlag auf 0, 1 oder 2 gesetzt (siehe unten)
 
 Dauer: Legt fest, wie lange Sensoraktivitaet registriert wird.
 Pause: Wenn waehrend der Sensoraktivierungs-Dauer eine laengere Pause registriert wird, wird die Ueberwachungsphase abgebrochen.
 
 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
 Beschleunigungssensor: (Anzahl der Bewegungen, Zaehler)
 Es koennen zwei Beschleunigungssensoren verwendet werden.
 AlarmSchwelle: Bei welchem BZaehler der Alarm ausgeloest werden soll
 
 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
 Piezo:
 Wenn die Matratze auf einer harten Unterlage liegt (kein Lattenrost) wie beispielsweise bei einem Futon,
 macht ein Bewegungssensor unter der Matratze keinen Sinn, da er sich ja nicht bewegt. Mit einem Piezosensor
 allerdings koennen Druckunterschiede registriert werden.
 
 Je nach Sensor und Bett/Matratze muessen die mit <J> gekennzeichneten Parameter evtl.
 veraendert werden.
 
 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
 GSM Shield oder Relais-Ausgang >>>>>>>>>>>>>>>>>>>
 <<< GSM Shields >>>
 Vorteil: Kompakt, einfach aufstecken und schon fertig. Es kann selbst so programmiert werden, wie
 man es wuenscht. Zum Beispiel nach einer gewissen Zeit noch einmal waehlen lassen, falls nieman gekommen
 ist (Stopp-Taste wurde nicht gedrueckt)
 Es kann auch ein Festnetz-Telefon angerufen werden.
 
 Nachteil: Soll ein anderes Telefon/Handy angerufen werden, so muss die Nummer hier im Code geaendert und
 der Arduino neu geflashed werden.
 
 <<< Relais-Ausgang >>>
 Vorteil: Es kann ein beliebiges GSM-Wahlgeraet verwendet oder auch nur eine einfache Klingel angeschlossen
 werden.
 Bei Verwendung des GSM-Wahlgeraet GW-02/NO kann die Nummer des anzurufenden Handys auf einfache Weise geaendert
 werden: Es braucht lediglich von dem anzurufenden Handy aus eine SMS an das Wahlgeraet gesendet zu werden.
 
 
 */

#include <GSM.h>
#define PINNUMBER ""
// Initialsieren der Library
GSM gsmAccess;
GSM_SMS sms;

//==========================================================
// <<<<<<<<<<< Einstellungen im Programm >>>>>>>>>>>>>   <<< Mit <J> markiert >>>

// ---- GSM oder AlarmRelais ---------------------------------------
// Wahl zwischen GSM Shield oder AlarmRelais
// Wenn statt des GSM Shield ein Relais vorgesehen ist, kann mit dem Relais z.B. eine Klingel betaetigt werden, oder
// natuerlich auch ein GSM-Wahlgeraet (z.B. das GSM-Wahlgeraet GW-02/NO der Firma AMG Alarmtechnik)
int gsmRelais = 0;  // <J> 0: GSM Shield vorhanden  1: AlarmRelais schalten





// ---- AlarmRelais---Alarm--------------------------------------
int AlarmRelaisDelay = 500;  // <J> Wartezeit bis Alarm gestartet wird (AlarmRelais) schaltet
int AlarmGSMDelay = 700;     // <J> Wartezeit bis Alarm gestartet wird (GSM) schaltet
int AlarmRelaisEin = 1000;   // <J> Wie lange das AlarmRelais anbleiben soll
//
int AlarmRelaisAktiv = 0;    // Ob AlarmRelais aktiv ist oder nicht (0=Nicht aktiv  1=Aktiv)

// ---- Relais---Reset--------------------------------------
int ResetRelaisDelay = 5000;  // <J> Wartezeit bis Relais wieder oeffnet


// Monitor-Ausgabe waehlen (nur fuer Programmierungszwecke). Serielle Ausgabe. 0=aus 1=an
int monA = 1;  // Dauer, Pause Zahler
int monT = 0;  // Timer
int monB = 0;  // Bewegungssensor
int monP = 0;  // Piezo
//==========================================================   

// Mit [DIP] gekennzeichnete Parameter: Mit einem DIP-Schalter waehlbar
// Festlegung der Sensoren --------------------------------
//int BFlag = 1;  // [DIP]  0: ohne Beschl.Sensor  1: mit einem Beschl.Sensor  2: mit zwei Beschl.Sensoren
//int PFlag = 1;  // [DIP]  0: ohne Piezo-Sensor   1: mit Piezo-Sensor

int SensorFlag = 1;
int BFlag = 0;
int PFlag = 0;


// Ein- und Ausgaenge festlegen ------------------------------------------------
// <<<<< Digitale Ein-/Ausgaenge >>>>>

//const int GsmRxPin = 2;       // Pin2 ist fuer GSM festgelegt (hier nur Kommentar)
//const int GsmTxPin = 3;       // Pin3 ist fuer GSM festgelegt (hier nur Kommentar)

const int PauseOnOffPin = 4;    // [DIP]   0=aus  1=ein
const int Sensor1Pin = 5;       // [DIP]   0: kein Sensor   1: Beschleunigungssensor
const int Sensor2Pin = 6;       // [DIP]   0: Zweiter Beschleunigungssensor   1: Piezosensor

//const int ModemResetPin = 7;  // GSM Shield Reset
const int AlarmRelaisPin = 7;   // AlarmRelais
const int ResetRelaisPin = 8;   // Relais zum Zuruecksetzen des EpiCareFree
const int EpiCareFreePin= 9;    // Alarm von EpiCareFree

const int SpeakerPin = 10;      // Lautsprecher (Buzzer)
const int StoppTastePin = 11;   // Stopp-Taste
const int DauerLedPin = 12;     // Leuchtet bei der ersten Sensoraktivitaet auf
const int AktivitaetsLedPin = 13; // zeigt Sensoraktivitaet an, leuchtet stetig bei Alarm



// <<<<< Analoge Eingaenge >>>>>

// Anschluss des Potis zur Einstellung der Dauer der Bewegungsregistrierung
const int DauerPotiPin = A0;      // [Poti]

// Anschluss des Potis zur Einstellung der Alarmschwelle, Empfindlichkeit von Beschl.Sensor & Piezo-Sensor
const int AlarmSchwellenPotiPin = A1; // [Poti]

// Beschleunigungssensor-Anschluss
const int B1zPin = A2;        // Z
const int B1yPin = A3;        // Y

// Zweiter Beschl.Sensor (Optional)
const int B2zPin = A4;        // Z
//const int B2yPin = A5;      // Y  // Der zweite Beschl.Sensor nur fuer Z-Achse

// PiezoSensor-Anschluss
const int P2Pin = A4;          // Eingang2: PiezoSensor-Anschluss (AnalogEingang) // = B2yPin

// Generelle Parameter --------------------------------------------------------------------
int T = 0;     // Zaehler fuer Aktivitaets-LED
int Dauer;     //  [Poti] Mit Poti eingestellte Zeitspanne, in der die eingelesenen Werte aufsummiert werden
int Pause;     // Pause nach Aktivierung des Sensors
int TimerPause;        // Timer fuer Nicht-Aktivitaet waehrend der Aktivitaets-Registrierdauer
int PauseOnOff = 1;    // [DIP] Es wird festgelegt, ob waehrend der Ueberwachungsphase eine laenger Pause zum Abbruch der
// der Phase fuehren soll. 0=aus  1=ein
int SensorAktiv = 0;       // Sensoraktivitaet: 0 = keine Aktivitaet,  1 = wenn Sensor aktiviert wurde
unsigned long TimerStart;  // Startzeit des Timers fuer Uberwachungsphasendauer
unsigned long TimerEnde;   // Endzeit des Timers fuer Uberwachungsphasendauer

// Zum Anzeigen, ob bereits eine SMS gesendet wurde oder nicht
// Wenn =1 dann wurde eine SMS geschickt, und es wird verhindert, dass weitere SMS gesendet werden.
int gsmAktiv = 0;   // 0: GSM shield nicht aktiv, 1: GSM shield aktiv

// Beschleunigungs-Sensor (accelerometer) --------------------------------------------------
// Chip Pin8=Z   Pin7=Y   Pin6=X
// Bei Plazierung des Sensors unter der Matratze wird Z (vertikale Bewegung),
// bei Anbringung seitlich an der Matratze wird Y (seitliche Bewegung des Sensors)
// ausgewertet.

// Eingelesene Beschleunigungssensorwerte (Beschl.Sensor 1 + 2)
int BVal1 = 0;  // erster Wert
int BVal2 = 0;  // zweiter Wert (nach einer bestimmen Zeit nach Einlesen des ersten Wertes)
int BVal2_1 = 50;   // <J> Bei welchem Unterschied der BZaehler erhoeht werden soll

int AlarmSchwelle;  // [Poti] Mit Poti eingestellte Schwelle, die vorgibt, bei welchem Zaehlerstand der Alarm ausgeloest werden soll


// Piezo-Sensor ---------------------------------------------------------------------------
// Parameter
int PThreshold = 100; // <J> Unterster PiezoSensorwert (Rauschunterdrueckung)
unsigned long PVal;   // aufsummierte PiezoSensorwerte
int PValEin;          // PiezoSensor-Eingangswert
unsigned long PVSchwelle;    // Piezo-AlarmSchwelle, Empfindlichkeit, mit Poti eingestellt
float PFaktor = 0.4;  // <J> Zum Justieren der PiezoSensor-Empfindlichkeit entsprechend der Bettunterlage.

// Beschl.Sensor & PiezoSensor----------------------------------------------------------------
int SensZaehler = 0;

// Allgemeine Variablen ---------------------------------------------------------------------
int wert1 = 0;  // allgemeine Variable
int wert2 = 0;  // allgemeine Variable

int Epidino_EpiCareFree = 0;  // 0: Epidino hat Alarm ausgeloest  1: EpiCareFree hat Alarm ausgeloest

//////////////////////////////////////////////////////////////////////////////////////
void setup() {
  pinMode(AktivitaetsLedPin, OUTPUT);
  pinMode(SpeakerPin, OUTPUT);
  pinMode(DauerLedPin, OUTPUT);

  // pinMode(ModemResetPin, OUTPUT);  // GSM-Reset
  if( gsmRelais == 1) {  // Nur wenn ein Relais geschaltet wird (nicht bei GSM shield)
    pinMode(AlarmRelaisPin, OUTPUT);  // AlarmRelais
  }
  pinMode(EpiCareFreePin, INPUT);  // Alarm von EpiCareFree
  digitalWrite(EpiCareFreePin, HIGH);   // Pullup-Widerstand aktivieren
  pinMode(ResetRelaisPin, OUTPUT);  // ResetRelais zum Aus- und Wiedereinschalten des EpiCare
  digitalWrite(ResetRelaisPin, HIGH);  // Pullup-Widerstand aktivieren. Das verwendete Relais schaltet bei LOW
  pinMode(StoppTastePin, INPUT);
  //Externen Pullup-Widerstand eingesetzt
  //digitalWrite(StoppTastePin, HIGH);   // Pullup-Widerstand aktivieren

  pinMode(Sensor1Pin, INPUT);
  digitalWrite(Sensor1Pin,HIGH);  // Pullup-Widerstand aktivieren
  pinMode(Sensor2Pin, INPUT);
  digitalWrite(Sensor2Pin,HIGH);  // Pullup-Widerstand aktivieren
  pinMode(PauseOnOffPin, INPUT);
  digitalWrite(PauseOnOffPin,HIGH);  // Pullup-Widerstand aktivieren
  // pinMode(PSensPin, INPUT);

  /*
  ������������������������
   //const int Sensor1Pin = 5;        // [DIP]
   //const int Sensor2Pin = 6;        // [DIP]
  
   // 2 Schalter
   0
   0    BeschlSensor an Sens1      kein Sensor an Sens2           SensorFlag = 1     BFlag = 1  PFlag = 0
  
   0
   1    Beschl.Sensor an Sens1       2. Beschl.Sensor an Sens2      SensorFlag = 2     BFlag = 2  PFlag = 0
  
   1
   1   Beschl.Sensor an Sens1        PiezoSensor an Sens2           SensorFlag = 3     BFlag = 1  PFlag = 1
  
   1
   0    kein Beschl.Sensor an Sens1  PiezoSens an Sens2             SensorFlag = 4     BFlag = 0  PFlag = 1
   ������������������������
   */

  BFlag = 0;
  PFlag = 0;
  wert1 = digitalRead(Sensor1Pin); //
  wert2 = digitalRead(Sensor2Pin); //

  if( wert1 == LOW && wert2 == LOW ) {
    SensorFlag = 1;
    BFlag = 1;
  }
  if( wert1 == LOW && wert2 == HIGH ) {
    SensorFlag = 2;
    BFlag = 2;
  }
  if( wert1 == HIGH && wert2 == HIGH ) {
    SensorFlag = 3;
    BFlag = 1;
    PFlag = 1;
  }
  if( wert1 == HIGH && wert2 == LOW ) {
    SensorFlag = 4;
    PFlag = 1;
  }

  wert1 = digitalRead(PauseOnOffPin);  // 0=aus  1=ein
  PauseOnOff = 0;
  if( wert1 == LOW ) {
    PauseOnOff = 1;
  }


  Serial.begin(9600);

  if( BFlag == 2 ) {  // Falls nicht richtig festgelegt wurde
    PFlag = 0;
  }

  //////////////// GSM shield starten ////////////////////
  if( gsmRelais == 0) {  // Nur wenn ein GSM shield vorhanden ist
    // digitalWrite(ModemResetPin,LOW);
    Serial.println("SMS Sender");

    boolean notConnected = true;  // Verbindungsstatus

    while(notConnected)
    {
      if(gsmAccess.begin(PINNUMBER)==GSM_READY){
        notConnected = false;
      }
      else
      {
        Serial.println("Nicht verbunden");
        tone(SpeakerPin,3000,1000);
        delay(1000);
      }
    }
    Serial.println("GSM initialisiert");
    tone(SpeakerPin,100,1000);
    digitalWrite(DauerLedPin,HIGH);  // Aktivitaets-LED einschalten
    delay(2000);
    digitalWrite(DauerLedPin,LOW);  // Aktivitaets-LED ausschalten
    //sendSMS();
}
}
//////////////////////////////////////////////////////////////////////////////////////
void loop() {
  Check_StoppTaste();  // Stopptaste abfragen
  Epidino_EpiCareFree=0;  // Epidino. Wenn Signal von EpiCareFree registriert wird, wird =1 gesetzt
  EpiCareFree();   // EpiCareFree abfragen

  Dauer = analogRead(DauerPotiPin);   // eingestellte Dauer einlesen
  Dauer = 20 + Dauer * 100/1000; //  20 Sek Minimum
  Pause = Dauer * 0.25;

  if( monA == 1 ){   
    //  MonitorA();
    // delay(3000);
  }

  if ( SensorAktiv == 1 ) {
    T = T++;        // Zaehler zum Abschalten der aktivierten Aktivitaets-LED
  }
  if ( T == 2 ) { 
    digitalWrite(AktivitaetsLedPin,LOW); // Aktivitaets-LED wird ausgeschaltet, wenn T=2 ist
    T = 0;
  }
  // aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
  if( T < 5 ){ // ... und wenn noch kein Alarm ausgeloest ist
    BPSensor();
  }
  // aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
  if( T == 5 ) { // Wenn Alarm ausgeloest ist
    melodieAlm();
    if( gsmRelais == 0 ) {  // Wenn ein GSM Shield verwendet wird
      if( gsmAktiv == 0 ) {  // Wenn noch keine SMS geschickt wurde
        sendSMS();
      }
    }
    if( gsmRelais == 1 && AlarmRelaisAktiv == 0 ) { // wenn bei AlarmRelais-Ausgang das AlarmRelais noch nicht aktiviert wurde
      Serial.println("Relais schalten");
      AlarmRelaisOn();
    }
  }
  // aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa

  if( gsmRelais == 1 && AlarmRelaisAktiv == 1 ) { // wenn bei AlarmRelais-Ausgang das AlarmRelais aktiviert wurde
    AlarmRelaisOff();
  }
}
//////////////////////////////////////////////////////////////////////////////////////
void BPSensor(){
  AlarmSchwelle = analogRead(AlarmSchwellenPotiPin) / 8;   // eingestellte BAlarmSchwelle
  AlarmSchwelle = 10 + AlarmSchwelle;  // Minimum 10

  //bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb
  BVal1 = 0;
  BVal2 = 0;
  if( BFlag == 1 ) { // Wenn an SensEingang1 ein  Beschl.Sensor angeschlossen ist
    BVal1 = analogRead(B1zPin) + analogRead(B1yPin);
  }
  if( BFlag ==2 ) { // Wenn an SensEingang2 ein zweiter Beschl.Sensor angeschlossen ist
    BVal1 = BVal1 + analogRead(B2zPin); // + analogRead(B2yPin);  // Der zweite Beschl.Sensor nur fuer Z-Achse
  }
  delay(50);
  if( BFlag == 1 ) { // Wenn an SensEingang1 ein  Beschl.Sensor angeschlossen ist
    BVal2 = analogRead(B1zPin) + analogRead(B1yPin);
  }
  if( BFlag ==2 ) { // Wenn ein zweiter Beschl.Sensor angeschlossen ist  
    BVal2 = BVal2 + analogRead(B2zPin); // + analogRead(B2yPin);  // Der zweite Beschl.Sensor nur fuer Z-Achse
  }  //bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb

  // pppppppppppp Piezo ppppppppppppppppppp
  if( PFlag == 1 ) { // Wenn an SensEingang2 ein PiezoSensor angeschlossen ist
    PValEin = analogRead(P2Pin); //(evtl * PSensorFaktor);   // PiezoSensorwert einlesen
  } // ppppppppppppppppppppppppppppppppppppp



  // bpbpbpbpbpb Beschl.Sensor & Piezo bpb
  if (abs((abs(BVal2) - abs(BVal1)) > BVal2_1)  || ( PValEin > PThreshold ) ) {
    SensorStart();
    digitalWrite(AktivitaetsLedPin,HIGH);  // Aktivitaets-LED einschalten
    PVal = PVal + PValEin;    // PiezoSensorwert aufsummieren
    SensZaehler = SensZaehler++;    // (Beschl.Sensor & Piezo) Zaehler erhoehen
    TimerPause = millis()/1000 + Pause;
  } // bpbpbpbpbpbpbpbpbpbpbpbpbpbpbpbpbpbpb

  SensorAktiviert();
}
//////////////////////////////////////////////////////////////////////////////////////
void SensorStart(){
  if( SensorAktiv == 0 ){     // bei der ersten Aktivierung des Sensors   
    TimerStart = millis()/1000; // aktuelle Zeit abspeichern
    TimerEnde = TimerStart + Dauer;
    SensorAktiv = 1;  // Sensor ist aktiviert, der Timer laeuft

    digitalWrite(DauerLedPin,HIGH);  // Dauer-LED einschalten
  }
}
//////////////////////////////////////////////////////////////////////////////////////
void SensorAktiviert(){
  if( SensorAktiv == 1 ){
    if( millis()/1000 > TimerEnde ){
      SensorAktiv = 0;                  // SensorFlag auf Null setzen
      PVal = 0; // Piezowert zuruecksetzen
      SensZaehler = 0;  // Gemeinsamer Zaehler fuer Beschl.Sensor & PiezoSensor
      digitalWrite(DauerLedPin,LOW);  // Dauer-LED ausschalten
    }

    //ggggggggggggggggggggggggggggggggggggggg   
    //------------------- Beschl.Sensor & Piezo
    if( SensZaehler > AlarmSchwelle){  // Wenn der BP-Zaehler groesser als der vorgegebene Wert ist
      digitalWrite(AktivitaetsLedPin, HIGH);  // Aktivitaets-LED einschalten
      Reset1();
      T = 5;                   // Aktivitaets-LED leuchtet stetig
    }
    //ggggggggggggggggggggggggggggggggggggg

    Check_StoppTaste();
    if( PauseOnOff == 1 && millis()/1000 == TimerPause ){
      Reset1(); 
    }
  }
}
//////////////////////////////////////////////////////////////////////////////////////
void EpiCareFree() {
  if( digitalRead(EpiCareFreePin) == LOW ){
    SensorAktiv = 0;
    digitalWrite(AktivitaetsLedPin, HIGH);  // Aktivitaets-LED einschalten
    Reset1();
    T = 5;                   // Aktivitaets-LED leuchtet stetig
    Epidino_EpiCareFree=1;
  }
}
//////////////////////////////////////////////////////////////////////////////////////
void Check_StoppTaste() {
  if ( digitalRead(StoppTastePin) == LOW ){  // Die Stopptaste wurde gedrueckt
    Reset1();
    Reset2();
    melodieStoppTaste();
    digitalWrite(ResetRelaisPin, LOW);
    delay(12000);  // Warten, bis EpiCare free ausschaltet
    digitalWrite(ResetRelaisPin, HIGH);
    delay(ResetRelaisDelay);  // Warten, um Alarmausloesung durch das Ausgangssignal vom EpiCare free zu verhindern.
    tone(SpeakerPin,100,1000);
  }
}
//////////////////////////////////////////////////////////////////////////////////////
void Reset1()
{
  digitalWrite(DauerLedPin,LOW);  // Dauer-LED ausschalten
  TimerPause = 0;
  SensorAktiv = 0;                  // SensorFlag auf Null setzen
  T = 0;
  PVal = 0;  // Piezo-Wert auf Null setzen
  SensZaehler = 0;  // Gemeinsamer Zaehler fuer Beschl.Sensor & PiezoSensor
  if( gsmRelais == 1 ) {  // Wenn ein Relais verwendet wird
    digitalWrite(AlarmRelaisPin,HIGH); // Das AusgangsAlarmRelais sofort abschalten
  }
  gsmAktiv = 0;   // fuer GSM shield
  AlarmRelaisAktiv = 0;  // AlarmRelais ist nicht aktiv
}
//////////////////////////////////////////////////////////////////////////////////////
void Reset2(){
  digitalWrite(AktivitaetsLedPin, LOW); // die Aktivitaets-LED ausschalten
  SensorAktiv = 0;                  // SensorFlag auf Null setzen
  T = 0;
  PVal = 0;  // Piezo-Wert auf Null setzen
  SensZaehler = 0;  // Gemeinsamer Zaehler fuer Beschl.Sensor & PiezoSensor
  if( gsmRelais == 1 ) {  // Wenn ein Relais verwendet wird
    digitalWrite(AlarmRelaisPin,HIGH); // Das AusgangsAlarmRelais sofort abschalten
  }
  gsmAktiv = 0;   // fuer GSM shield
  AlarmRelaisAktiv = 0;  // AlarmRelais ist nicht aktiv
}
//////////////////////////////////////////////////////////////////////////////////////
void sendSMS()
{
  wert1=0;
  while (wert1 < AlarmGSMDelay){
    Check_StoppTaste();
    if( T == 0 ){
      wert1 = AlarmGSMDelay;
    }
    melodieAlarmRelaisOn();
    delay(10);
    wert1=wert1++;
  }

  if( T != 0 ){  // Nicht wenn die StoppTaste gedrueckt wurde
    Serial.println("SMS senden"); 
    melodieSMS1();
    gsmAktiv = 1;
    Serial.print("SMS an Handy Nummer: ");
    Serial.println(remoteNumber);
    Serial.println("SENDING");
    Serial.println();
    Serial.print("Message:");
    if( Epidino_EpiCareFree == 0 ){  // Alarm wurde vom Epidino selbst ausgeloest
      Serial.println(txtMsgEpidino);
    }
    if( Epidino_EpiCareFree == 0 ){  // Alarm wurde vom Epi-Care free ausgeloest
      Serial.println(txtMsgEpiCareFree);
    }

    // SMS senden
    sms.beginSMS(remoteNumber);
    if( Epidino_EpiCareFree == 0 ){  // Alarm wurde vom Epidino selbst ausgeloest
      sms.print(txtMsgEpidino);
    }
    if( Epidino_EpiCareFree == 1 ){  // Alarm wurde vom Epi-Care free ausgeloest
      sms.print(txtMsgEpiCareFree);
    }
    sms.endSMS();
 //   delay(1);
    Serial.println("\nCOMPLETE!\n");
    melodieSMS2();
  }
}
//////////////////////////////////////////////////////////////////////////////////////
void AlarmRelaisOn() {  // Aktivieren des Relais mit Verzoegerung
  wert1=0;
  while (wert1 < AlarmRelaisDelay){
    Check_StoppTaste();
    if( T == 0 ){
      wert1 = AlarmRelaisDelay;
    }
    melodieAlarmRelaisOn();
    delay(10);
    wert1=wert1++;
  }
  if( T == 5 ){ // nicht, wenn Reset-Taste gedrueckt wurde (T = 0)
    if( gsmRelais == 1 ) {  // Wenn ein Relais verwendet wird
      digitalWrite(AlarmRelaisPin,LOW);  // AlarmRelais einschalten (AlarmRelais schaltet, wenn Minus)
    }
    AlarmRelaisAktiv = 1;  // AlarmRelais ist aktiviert
  }
}
//////////////////////////////////////////////////////////////////////////////////////
void AlarmRelaisOff() {  // Deaktivieren des AlarmRelais nach einer vorgegebenen Zeit
  wert1=0;
  while (wert1 < AlarmRelaisEin){
    Check_StoppTaste();
    if( T == 0 ){
      wert1 = AlarmRelaisEin;
    }  // Wenn die Stopptaste gedrueckt wurde, Schleife sofort verlassen
    melodieAlarmRelaisOff();
    delay(10);
    wert1=wert1++;
  }
  if( gsmRelais == 1 ) {  // Wenn ein Relais verwendet wird
    digitalWrite(AlarmRelaisPin,HIGH);  // AlarmRelais abschalten (AlarmRelais schaltet, wenn Minus)
  }
  AlarmRelaisAktiv = 5;  // AlarmRelais ist nach der vorgegebenen Zeit deaktiviert worden
  noTone(SpeakerPin);
}
//////////////////////////////////////////////////////////////////////////////////////
void melodieAlm() {
  tone(SpeakerPin,500,2000);
}
//////////////////////////////////////////////////////////////////////////////////////
void melodieSMS1() {
  tone(SpeakerPin,1800,1000);
}
//////////////////////////////////////////////////////////////////////////////////////
void melodieSMS2() {
  tone(SpeakerPin,400,1000);
}
//////////////////////////////////////////////////////////////////////////////////////
void melodieAlarmRelaisOn() {
  tone(SpeakerPin,800,1000);
}
//////////////////////////////////////////////////////////////////////////////////////
void melodieAlarmRelaisOff() {
  tone(SpeakerPin,1200);
}
//////////////////////////////////////////////////////////////////////////////////////
void melodieStoppTaste() {
  tone(SpeakerPin,300);
  delay(800);  // warten
  tone(SpeakerPin,1000);
  delay(800);  // warten
  noTone(SpeakerPin);
}
//////////////////////////////////////////////////////////////////////////////////////
void MonitorA(){
  //  SensorFlag = 1;
  //   BFlag = 1;
  Serial.print("abs(BVal1)=");
  Serial.print(abs(BVal1));
  Serial.print(" - ");
  Serial.print("abs(BVal2)=");
  Serial.print(abs(BVal2));
  Serial.print(" - ");
  Serial.print("abs(BVal2) - abs(BVal1)=");
  Serial.println(abs(abs(BVal2) - abs(BVal1)));
  //  Serial.print("SensZaehler: ");
  //  Serial.println(SensZaehler);
}
//////////////////////////////////////////////////////////////////////////////////////
void MonitorA1(){
  //  SensorFlag = 1;
  //   BFlag = 1;
  Serial.print("SensorFlag=");
  Serial.print(SensorFlag);
  Serial.print(" - ");
  Serial.print("BFlag= ");
  Serial.print(BFlag);
  Serial.print(" - ");
  //  Serial.print(" - ");
  //  Serial.print(" - ");
  //  Serial.print("SensZaehler: ");
  //  Serial.println(SensZaehler);
}
//////////////////////////////////////////////////////////////////////////////////////
void MonitorA2(){
  Serial.print("Dauer=");
  Serial.print(Dauer);
  Serial.print(" - ");
  Serial.print("BZ-Schwelle: ");
  Serial.print(AlarmSchwelle);
  Serial.print(" - ");
  Serial.print(" - ");
  Serial.print(" - ");
  Serial.print("SensZaehler: ");
  Serial.println(SensZaehler);
}
//////////////////////////////////////////////////////////////////////////////////////
void MonitorB(){
  Serial.print(" Dauer ");
  Serial.print(Dauer);
  Serial.print("B-Schwelle: ");
  Serial.print(AlarmSchwelle);
  Serial.print("  SensZaehler: ");
  Serial.println(SensZaehler);
}
//////////////////////////////////////////////////////////////////////////////////////
void MonitorP(){
  Serial.print(" Dauer ");
  Serial.print(Dauer);
  Serial.print(" P-Schwelle ");
  Serial.print(PVSchwelle);
  Serial.print(" PValEin ");
  Serial.print(PValEin);
  Serial.print(" PVal: ");
  Serial.print(PVal);
}



--------------------- ENDE des Codes --------------------------------------------------------------------


[nach oben]

Inhaltsverzeichnis

Disclaimer


Aktualisiert am 19.01.2015