RTC 3231 und Arduino Uno

Hallo Forum,

soeben ist mir mein Browser abgeschmiert und meine ellenlange Frage wurde gelöscht. Jetzt fehlt mir die Muße alles nochmal so detailliert zu schreiben daher fasse ich mich kurz. (Btw. "Save Draft" ist wirklich nh super Funktion und werd ich ab jetzt immer nutzen :confused: )

Ich habe verschiedene Libaries zum Programmieren der RTC 3231 ausprobiert, konnte sie über den Quelltext auch schon erfolgreich parametrieren. Jetzt suche ich aber einen eleganteren Weg, Uhrzeizt und einen Alarm zu Programmieren. In den Examples (z.B. "TimeSerial") der Time.h habe ich etwas von übermitteln der Zeit über einen Linux Terminal gelesen, bin daran aber gescheitert. Könnt ihr mir sagen wie ich dafür vorgehen muss?

rodan/ds3231 Hier im example rtc_ds3231 sieht es für mich so aus als könne man über eine einfache Eingabe von Buchstaben oder Zahlen im Serial Monitor Zeit und Alarme anzeigen oder programmieren. Wenn ich einfach einen Buchstaben eingebe kommt jedoch keine Reaktion.... Wo ist mein (denk-)Fehler?

Solange die Knopfzelle genug Spannung liefert bleibt nicht nur Uhrzeit sondern auch ein eingestellter Alarm erhalten oder?

Liebe Grüße,

JimmyPesto

Hallo, ich nutze diese Anleitung mit dem Sketch, der ohne Bibliothek auskommt.

JimmyPesto: Solange die Knopfzelle genug Spannung liefert bleibt nicht nur Uhrzeit sondern auch ein eingestellter Alarm erhalten oder?

Üblicherweise ist es eher so, solange die Batterie Backup-Power liefert: Die Zeit zählt weiter, die eingestellten Alarme bleiben erhalten.

Aber willst Du wirklich die Alarme verwenden, die innerhalb der RTC programmierbar sind?

Einfacher handhabbar wäre es aus meiner Sicht, Alarmzeiten nicht in der RTC zu speichern, sondern im EEPROM des Arduino-Controllers, und sie von dort beim Programmstart wieder einzulesen. Erstens bist Du dann nicht auf zwei Alarmzeiten begrenzt, sondern Du kannst auch jeden Alarm gesondert behandeln, z.B. unterschiedliche Alarm-Pins beim Erreichen der eingestellten Alarmzeit aktivieren.

Für Uhren, die automatisch zwischen Sommerzeit/Winterzeit umschalten und auf der stets gültigen "lokalen Zeit" alarmieren sollen, würde dann auch die Programmlogik zum automatischen Sommerzeit/Winterzeit Handling viel einfacher.

Also es hängt von Deinen Anforderungen ab:

Möchtest Du eher keine automatische Sommerzeit/Winterzeit Umstellung, die Umstellung soll manuell erfolgen? Und der Arduino-Controller soll (z.B. bei einem batteriebetriebenen Gerät) in den PowerDown-Sleepmode versetzt werden und nur bei Alarmierung durch die RTC wacht der Arduino aus dem Sleepmode auf und fängt an zu arbeiten?

Oder soll der Arduino "always ON" laufen und eine automatische Sommerzeit-Winterzeit Umstellung machen?

Den seriellen Monitor (oder ein serielles Terminalprogramm) zum Einstellen zu verwenden, ist eigentlich kein großes Problem. Dafür brauchst Du Dir eigentlich nur "Befehle" ausdenken und auf dem Arduino umsetzen, so dass Zeilen wie beispielsweise setdate 23.11.2015 settime 11:08 setalarm 22:00 anhand der über Serial eintreffenden Befehlszeilen empfangen, ausgewertet, auf Plausibilität geprüft und in die entsprechenden Aktionen (Datum setzen, Zeit setzen, Alarmzeit setzen) umgesetzt werden können.

Wie gesagt: Außer eventuell bei batteriebetriebenen Geräten, die überwiegend im PowerDown-Sleepmode laufen sollen, würde ich Alarmzeiten viel eher im Arduino verwalten statt in der RTC.

Danke für die schnellen Antworten.

@agmue Diese Anleitung habe ich bereits erfolgreich getestet. Für den Einstieg ganz nett aber wenig elegant. Auch ist hier soweit ich das gesehen habe nichts vorgesehen um einen Alarm zu programmieren.

@jurs Einsatzzweck ist eine automatisierte Gartenbewässerungsanlage. Jeden morgen soll der Arduino einmal wach werden, seine Sensoren checken, ggf wässern und wieder schlafen. Mir ist es besonders wichtig, den Stromverbrauch so gering wie möglich zu halten, Das ganze System kommt ohnehin nur im Sommer zum Einsatz also ist eine perfekte umschaltung der Zeit nicht von nöten.

Ich hatte auch die Hoffnung es wäre einfach mit dem seriellen Monitor und es hat sich in den genannten libaries auch schon jemand gedanken über Befehle gemacht nur hats bei mir nicht hingehauen und ich weiß nicht wieso. Ich habe es wohl geschafft über die Eingabe von T98657463456 bla bla mal die Uhrzeit zu stellen (hab leider vergessen mit welcher libarie das klappte).

JimmyPesto: Ich habe es wohl geschafft über die Eingabe von T98657463456 bla bla mal die Uhrzeit zu stellen (hab leider vergessen mit welcher libarie das klappte).

Hier machst du wohl grundsätzliche Fehler.

Du solltest zur eigenen "Sicherheit" jeden Sketch richtig dokumentieren und auch Links der Libraries eintragen. Dann findest du auch später alles wieder. Zusätzlich den Sketch mit entsprechender Benennung abspeichern.

JimmyPesto: Mir ist es besonders wichtig, den Stromverbrauch so gering wie möglich zu halten,

Was bedeutet das konkret?

Ein Arduino UNO Board zieht (ohne angeschlossene Hardware) ca. 55 mA @5V, das sind P= U*I = 0,055A * 5V = 0,275 Watt Ist das zuviel für Deine Anwendung?

Also der Stromverbrauch soll im Standby deutlich unter 0,275 Watt liegen und dafür bist Du bereit, erheblichen Aufwand bei Hard- und Software zu betreiben?

Wie hoch darf der Standby-Verbrauch denn sein?

Eine Library, die das Setzen von Alarmzeiten innerhalb einer DS3232 oder DS3231 erlaubt, ist wohl diese von Jack Christensen: https://github.com/JChristensen/DS3232RTC

@HotSystems Da hast du wohl recht! Ich hab ja auch alle noch auf dem Rechner und weiß auch noch wo sie her kommen. Nur funktionieren die alle fast gleich bzw haben auch noch mehrere Examples die ähnlich funktionieren... Ist auch eher unwichtig. Wollte damit nur sagen das mein Aufbau und System wohl zur Kommunikation fähig ist und der Fehler dort schon mal nicht liegen kann.

@jurs Ich wollte da jetzt nicht drauf rum rechnen. Die RTC liegt nun hier und möchte benutzt werden. Bisher hat mein garten kein µA verbaucht und jetzt soll er so wenig wie möglich und so viel wie nötig bekommen. Habe leider auch noch kein DIP Board gibt viele ecken die ich noch verbessern kann aber jetzt will ich erstmal diese RTC besiegen!

Zur Not programmier ich die RTC halt über den Quellcode wie im Beispiel von #1. Jemand schon mal über einen Liunux Terminal die Systemzeit übertragen?

Okay nehmen wir uns die Jack Christensen vor, auch diese hab ich auf dem Rechner. Ich kram Sie schnell raus, spiele sie auf und sag euch was klappt und was nicht =)

Noch kurz zur Anwendung der unterschiedlichen Libraries ein wichtiger Tipp:

Wenn du Libraries mit gleichem Namen einsetzen möchtest, bzw. diese gegeneinander austauschst, ist es wichtig, die "alte" Library aus dem Ordner zu löschen, bzw. in einen anderen Ordner (nicht Arduino-Ordner) zu verschieben.

Andernfalls greift die IDE noch darauf zu und du bekommst Fehler, die sich nicht so leicht erklären lassen.

JimmyPesto: Jemand schon mal über einen Liunux Terminal die Systemzeit übertragen?

Was spricht dagegen, auch unter Linux den "Seriellen Monitor" der Arduino-IDE zum Stellen der Zeit zu verwenden?

Für eine DS1307 (auch mit DS3231 verwendbar) habe ich in diesem Forum schon ein paarmal ein Beispielprogramm gepostet, mit dem man auch die Zeit über den seriellen Monitor setzen kann. Zum Beispiel hier: http://forum.arduino.cc/index.php?topic=191362.msg1414512#msg1414512

Der Vorteil des seriellen Monitors liegt dabei darin, dass dieser einen Zeileneditor hat, in dem man eine Zeile editieren kann, bevor man sie absendet.

Wenn Du eine Zeile "blind", also ohne Buchstabenecho, eingeben kannst, kannst Du das unveränderte Beispiel verwenden, ein serielles Terminalprogramm starten, das Kommando eingeben und [Enter] drücken und die Zeit wird gesetzt.

Ansonsten müßtest Du entweder das Terminalprogramm auf "lokales Echo" einstellen, damit es bei der Eingabe jedes Zeichen ausgibt, oder bei der typischen Einstellung "no Echo" müßte das Arduinoprogramm das Echoing von Zeichen übernehmen und entsprechend abgeändert werden, damit das Kommando zum Setzen der Zeit nicht blind in das serielle Terminal eingetippt werden muss. Möglich ist vieles.

@HotSystems Danke für den Tipp ich werde drauf achten :wink:

Also JChristensen/DS3232RTC aus #5 runter geladen die nötigen Libaries eingebunden.
Das Example SetSerial liefert in der Ausgabe nur Müll:
““ù|þù\ùXùIûÑúMþ“ýXø¶ùÑþ\þ“ù›ùù|þ]þ\iP|êMù<êXùIûIûÑúXù“üIí”
Hingegen das Example TimeRTC problemlos funktioniert.
Ausgabe:
“RTC has set the system time
13:51:20 31 12 2095” (Zurück in die Zukunft =P Zeit ist noch vom herumspielen verstellt)
Ich könnte mir vorstellen die fehlerhafte Ausgabe liegt daran, dass SetSerial Streaming.h benutzt und TimeRTC nicht.
Hab eine Streaming.h eingebunden aber wer weiß was ich da vllt falsch gemacht habe.
Ich würde mir die Zeit dieses Problem zu lösen aber gerne spaaren weil beide Example keine möglichkeit bieten einen Alarm zu programmieren.
Daher möchte ich gerne auf die rodan/ds3231 aus meinem ersten Beitrag zurück kommen
Example “rtc_ds3231” läuft und gibt mir die Ausgabe:
“GET time
1995.12.31 13:59:54”
Das 19XX liegt an der ds3231.h soweit ich mich entsinne, dort kann man zwei Zeilen umschreiben und bekommt ein 20XX. Die RTC liefert nur die zwei XX.
jetzt lese ich in den Kommentaren des Examples : // “1” get alarm 1 oder // “C” - get temperature register
Tipp ich 1 oder C in den seriellen Monitor passiert nix.

void parse_cmd(char *cmd, int cmdsize)
{
    uint8_t i;
    uint8_t reg_val;
    char buff[BUFF_MAX];
    struct ts t;

    //snprintf(buff, BUFF_MAX, "cmd was '%s' %d\n", cmd, cmdsize);
    //Serial.print(buff);

    // TssmmhhWDDMMYYYY aka set time
    if (cmd[0] == 84 && cmdsize == 16) {
        //T355720619112011
        t.sec = inp2toi(cmd, 1);
        t.min = inp2toi(cmd, 3);
        t.hour = inp2toi(cmd, 5);
        t.wday = cmd[7] - 48;
        t.mday = inp2toi(cmd, 8);
        t.mon = inp2toi(cmd, 10);
        t.year = inp2toi(cmd, 12) * 100 + inp2toi(cmd, 14);
        DS3231_set(t);
        Serial.println("OK");

warum sind die Zeilen:

//snprintf(buff, BUFF_MAX, “cmd was ‘%s’ %d\n”, cmd, cmdsize);
//Serial.print(buff);

Standardmäßig auskommentiert?
auf ein mit zahlen gefülltes TssmmhhWDDMMYYYY kam leider auch keine Reaktion

@jurs Vllt habe ich mich unklar ausgedrückt :confused:
in der Time.h libarie war ein Example TimeSerial enthalten und hier steht oben drin:

 * A Processing example sketch to automatically send the messages is inclided in the download
 * On Linux, you can use "date +T%s\n > /dev/ttyACM0" (UTC time zone)
 */

Und für mich sah es so aus als könne man die PC zeit direkt übermitteln Via LinuxTerminal
Was wenn es funktionieren würde wirklich total elegant und unkompliziert wäre weil ich ja nicht mal die Zeit abtippen müsste.

Edit Time.h hier gezogen:
http://www.pjrc.com/teensy/arduino_libraries/Time.zip

JimmyPesto: in der Time.h libarie war ein Example TimeSerial enthalten und hier steht oben drin:

 * A Processing example sketch to automatically send the messages is inclided in the download
 * On Linux, you can use "date +T%s\n > /dev/ttyACM0" (UTC time zone)
 */

Und für mich sah es so aus als könne man die PC zeit direkt übermitteln Via LinuxTerminal Was wenn es funktionieren würde wirklich total elegant und unkompliziert wäre weil ich ja nicht mal die Zeit abtippen müsste.

Wenn das funktioniert, dann tippst Du das Kommando in eine lokale Linux-Konsole ein und sendet die Ausgabe an eine serielle Schnittstelle. Das Kommando wird mitnichten in einem Terminalprogramm eingetippt.

Außerdem mußt Du dafür den "Auto-Reset" auf dem Arduino-Board abgeschaltet haben, mit allen Nebenwirkungen wie z.B. dass ein Sketch-Upload dann nur noch mit manuellem Reset möglich ist, während der Auto-Reset abgeschaltet ist. Siehe: http://playground.arduino.cc/Main/DisablingAutoResetOnSerialConnection

Wenn der Auto-Reset nicht abgeschaltet sondern aktiv ist, passiert beim Senden Deines Kommandos von der Linux-Konsole das: - Konsole öffnet die serielle Schnittstelle - Arduino-Board führt einen Reset aus - Bootloader startet - während der Bootloader läuft kommt Deine Zeitangabe über Serial rein - Bootloader merkt: Das ist ja gar kein neuer Sketch, der da auf Serial ankommt - Bootloader beendet sich - Dein Sketch auf dem Board startet ==> und Dein Sketch sieht von der eintreffenden Zeitangabe überhaupt nichts mehr

Wenn das funktioniert, dann tippst Du das Kommando in eine lokale Linux-Konsole ein und sendet die Ausgabe an eine serielle Schnittstelle. Das Kommando wird mitnichten in einem Terminalprogramm eingetippt.

Danke für deine Mühe aber nagel mich hier nicht auf irgendwelche Begriffe fest. Du scheinst dich gut aus zu kennen, da könntest du auch versuchen zu verstehen was hinter meinen einfachen Worten steckt ? Btw. heißt meine "Linux-Konsole"(-n) Anwendung "Xfce Terminal".... Wüsste jetzt auch keinen unterschied zwischen den Begriffen Terminal, Konsole, Cmd aber zurück zum Topic.

Deine Erklärung ist einleuchtend! Einen Widerstand zwischen 5V und Reset zu stecken finde ich einfacher als sekundengenau die Uhrzeit ab zu tippen. Und lässt sich danach leicht wieder ab nehmen um weiter programmieren zu können. (Auch wenn die Genauigkeit für meine Zwecke unwichtig ist, finde ich das sehr interessant)

Am liebsten wäre mir die volle Funktionsfähigkeit von rodan/ds3231 nutzen zu können. Mir fehlt noch ein Weg den Alarm 1 über den serial Monitor zu programmieren. Ein Tipp was ich hier falsch mache?

So zum TimeSerial.ino: -Sketch ganz normal in den Uno geladen. -Seriellen Monitor geöffnet. -"Waiting for sync message" erhalten -"7" eingegeben. -110R Widerstand (220R||220R hatte gerade nichts besseres) zwischen 5V und RES(et) geteckt. -Linux Konsole geöffnet -"date +T%s\n > /dev/ttyUSB0" eingegeben und einmal Enter gedrückt(USB0 eventuell anpassen) -Zeile wurde ohne Antwort einfach ausgeführt, danach wird im Sekundentakt die Uhrzeit über den seriellen Monitor ausgegeben. Wie in der Beschreibung handelt es sich aber um die UTC bzw GMT Zeit also für Zeitzone Berlin eine Stunde zu früh. Jemand eine Idee wie ich das korregieren kann? -110R wieder raus ziehen und fertig

Ich habe mir die JChristensen/DS3232RTC Lib jetzt noch mal angesehen.
In den Examples ist kein Alarm vorgesehen aber die Lib selber unterstützt welche.
Mal sehen ob ich da was gebastelt bekomme.

Noch mal für mein Verständnis, kann ich mir einen Sketch schreiben, mit dem ich einmal Uhrzeit und Alarmzeit einstelle, danach meinen Arduino mit einem anderen Sketch bespielen und bekomme trotzdem z.B. täglich meinen Alarm ohne das ich ihn zurück setzen muss oder ähnliches?
Edit:
Wenn ich rodan/ds3231 Example “rtc_ds3231” einstelle immer bei einer passenden Sekundenzahl zu triggern, geht der Widerstand zwischen SQW und GND der RTC kurz von “unendlich” auf 18 Ohm, spiele ich dann ein anderes Programm auf bleibt der interrupt Pin (SQW) nach dem ersten Interrupt dauerfaft auf etwa 16 Ohm.
Ich muss ihn also irgendwie zurück setzen. Leider noch keinen Schimmer wie… :S

JimmyPesto: Noch mal für mein Verständnis, kann ich mir einen Sketch schreiben, mit dem ich einmal Uhrzeit und Alarmzeit einstelle, danach meinen Arduino mit einem anderen Sketch bespielen und bekomme trotzdem z.B. täglich meinen Alarm ohne das ich ihn zurück setzen muss oder ähnliches?

Wenn du diese Einstellungen in der RTC speicherst, dann JA. Diese muss natürlich auch eine Batterie bzw. Akku haben.

Und ACHTUNG, es werden RTCs auch mit Batterien geliefert. Diese werden onBoard geladen und können explodieren.

http://arduino-hannover.de/tag/ds3231/

Meine RTC 3231 wurde ohne Baterie geliefert, ich habe aber eine rein gepackt, die ist bis jetzt noch nicht explodiert ^^ Uff !!! Danke für die Info hab da einfach mal eine Lithium Zelle (CR2032) rein gepackt. :O Jetzt muss ich mal schauen ob ich die Diode raus haue oder nochmal Geld in die Hand nehm für eine LIR2032 ...

Wie speicher ich das Rücksetzen des Int Pins in der RTC??? :o

Ich hab mir einen Code zusammengebastelt der auf JChristensen/DS3232RTC basiert.
Die Lib ist wirklich leicht zu verwenden und super dokumentiert.
Schwierigkeiten hatte ich mit dem power-down-modus und Interrupt vom Arduino.
Habt ihr Tipps was ich noch verbessern kann?

Die Variable ERROR wird immer gesetzt, es kommt aber keine Textausgabe das ein Fehler erkannt wurde.

Lässt man den ERROR Merker weg läuft das Programm soweit…

LG
Jimmy Pesto

/*ERROR ist true, alarm2 wird erfolgreich gesetzt und abgefragt*/



#include <Time.h>
#include <Wire.h>
#include <DS3232RTC.h>

#include <avr/sleep.h>

int count = 0; /*nur für dummy loop*/
int countOfInterrupts = 0;

volatile int ERROR = 0;

void setTime()
  {
  //this example first sets the system time (maintained by the Time library) to
  //a hard-coded date and time, and then sets the RTC from the system time.
  //the setTime() function is part of the Time library.
  setTime(02, 05, 00, 25, 11, 2015);   //set the system time to 23h31m30s on 13Feb2009
  if (!RTC.set(now()))  //set the RTC from the system time
    Serial.println("Time is set successful!");
  else 
    Serial.println("Time is NOT set. ERROR!");
    ERROR = 1;
  }

void printTime()
  {
  tmElements_t tm;
  RTC.read(tm);
  if ( RTC.read(tm) ) {  //Reads the current date and time from the RTC and returns it as a tmElements_t structure
    Serial.println("Can´t read Time. ERROR!");
    //ERROR = 1;
  }
  Serial.print(tm.Hour, DEC);
  Serial.print(':');
  Serial.print(tm.Minute,DEC);
  Serial.print(':');
  Serial.println(tm.Second,DEC);
  }

void setInterruptAlarm()
  {
  //Set Alarm1 for 12:34:56 on Sunday -> ALM1_MATCH_DAY, 56, 34, 12, dowSunday
  RTC.setAlarm(ALM1_MATCH_SECONDS, 56, 34, 59, dowSunday);
  RTC.alarmInterrupt(ALARM_1, true);      //assert the INT pin when Alarm1 occurs
  Serial.println("RTC-Alarm1 is set!");
  }

void interruptSR()
  {
    Serial.println("interruptSR is called!!!");
    detachInterrupt(0);                        // Ist das hier richtig?
  }

void enterSleep()
  {
   attachInterrupt(0, interruptSR, LOW);   //Call ISR-Routine when Pin2 drops LOW
   Serial.println("Going to sleep!");
   delay(200);
   set_sleep_mode(SLEEP_MODE_PWR_DOWN);   // sleep mode is set here
   sleep_enable();                        // enables the sleep bit
   sleep_mode();             // here the device is actually put to sleep!!
                             // THE PROGRAM CONTINUES FROM HERE AFTER WAKING UP and interruptSR is finished
   sleep_disable();
   //detachInterrupt(0);       // disables interrupt 0 on pin 2 so the
   delay(200);               // interruptSR code will not be executed
                             // during normal running time.   
   //RTC.alarm(ALARM_1);//reset Interrupt Pin of RTC
   countOfInterrupts++;   
   Serial.print("Just woke up for the "); 
   Serial.print(countOfInterrupts);
   Serial.println(" time."); 
     if ( RTC.alarm(ALARM_1) ) {     //has Alarm1 triggered? resets the alarm flag in the RTC
        //yes, act on the alarm
        if ( RTC.oscStopped(true) ) { //check the oscillator and reset the OSF bit which indicates that the oscillator is or was stopped
            //may be trouble
            Serial.println("Time could be invalid. ERROR!");
            printTime();
            ERROR = 1;
          }
          else {
            //all is well
            Serial.println("Time is valid and the RTC-Alarm has triggert!");
            printTime();
          }
        }
        else {
            //no alarm
            Serial.println("RTC has not triggert the Alarm.!\nInterrupt button was pressed or an Error has occurred!");
            printTime();
        }   
  }
  
void setup()
  {
  Serial.begin(9600);
  setTime();  //just use it once to set the right time then comment it out
  printTime();//Show current RTC-Time
  RTC.alarm(ALARM_1);//reset Interrupt Pin of RTC
  pinMode(2, INPUT);              // Pin 2 is input to which an switch OR an RTC is connected = INT0
  digitalWrite(2,HIGH);           //activate internal Pull-Up resistor
  //attachInterrupt(0, interruptSR, LOW);   //Call ISR-Routine when Pin2 drops LOW **Im sleep einmal aufrufen reicht??**
  setInterruptAlarm();
  }

void loop()
{
  if(ERROR == 0)
    {
    /*Hier solls mal irgendwann zur Sache gehen aber bis dahin dieses Bsp.*/
    Serial.println("LOOP ERROR = false");
    // display information about the counter
      Serial.print("Awake for ");
      Serial.print(count);
      Serial.println("sec");
      count++;
      delay(1000);                           // waits for a second
     
      // compute the serial input
      if (Serial.available()) {
        int val = Serial.read();
        if (val == 'S') {
          Serial.println("Serial: Entering Sleep mode");
          delay(100);     // this delay is needed, the sleep
                          //function will provoke a Serial error otherwise!!
          count = 0;
          enterSleep();     // sleep function called here
        }
        if (val == 'A') {
          Serial.println("Hola Caracola"); // classic dummy message
        }
      }
     
      // check if it should go to sleep because of time
      if (count >= 10) {
          Serial.println("Timer: Entering Sleep mode");
          delay(100);     // this delay is needed, the sleep
                          //function will provoke a Serial error otherwise!!
          count = 0;
          enterSleep();     // sleep function called here
      }
    }
 else if ( ERROR == 1)
    { 
    //Set Alarm2 for every minute
    RTC.setAlarm(ALM2_EVERY_MINUTE, 1, 1, 1);
    if ( RTC.alarm(ALARM_2) ) {     //has Alarm2 triggered?  resets the alarm flag in the RTC
        Serial.println("LOOP ERROR = true"); 
        Serial.println("Alarm2 has triggert!!!");
        //yes, act on the alarm
        /*BEEEP or blink*/
      }
    }
 else Serial.println(ERROR);  
}

Serial hat in ISRs nichts verloren