Datum mit Hex Eingabe sortieren

Selbst wenn ich jeden Datentyp in long verändere, klappt es trotzdem nicht. Ich muss die Werte die ich erzeugt habe, doch in ein Array schreiben können.

Das ist die Fehlermeldung:

Steuerung_V18:587: error: cannot convert ‘’ to ‘long int’ in assignment

ausgabe[j] = {ausgabe_bildschirm1, ausgabe_bildschirm2, ausgabe_bildschirm3};

^

exit status 1
cannot convert ‘’ to ‘long int’ in assignment

So sollte das gehen:

const byte AnzahlZeiten = 3;
uint32_t ausgabe[AnzahlZeiten];
byte jahr, monat, tag, stunde, tminute;

void setup() {
  Serial.begin(9600);
  Serial.println("Anfang");
  jahr = 16;
  monat = 12;
  tag = 15;
  stunde = 12;
  tminute = 15;
  ausgabe[0] = ((((long)jahr * 16 + monat) * 32 + tag) * 32 + stunde) * 64 + tminute;

  jahr = 16;
  monat = 12;
  tag = 15;
  stunde = 7;
  tminute = 00;
  ausgabe[1] = ((((long)jahr * 16 + monat) * 32 + tag) * 32 + stunde) * 64 + tminute;

  jahr = 16;
  monat = 12;
  tag = 15;
  stunde = 13;
  tminute = 30;
  ausgabe[2] = ((((long)jahr * 16 + monat) * 32 + tag) * 32 + stunde) * 64 + tminute;

  uint32_t swapHolder = 0;
  Serial.println("Vor dem Sortieren: ");
  for ( byte j = 0; j < AnzahlZeiten; j++) {
    Serial.print(j);
    Serial.print("\t");
    Serial.println(ausgabe[j], DEC);
  }
  for ( byte j = 0; j < (AnzahlZeiten - 1); j++) {
    if (ausgabe[j] > ausgabe[j + 1]) {
      swapHolder = ausgabe[j + 1];
      ausgabe[j + 1] = ausgabe[j];
      ausgabe[j] = swapHolder;
    }
  }
  Serial.println("Nach dem Sortieren: ");
  for ( byte j = 0; j < AnzahlZeiten; j++) {
    Serial.print(j);
    Serial.print("\t");
    Serial.println(ausgabe[j], DEC);
  }
}

void loop() {}

Danke, das Programm funktioniert schon einmal. Ich hatte vorher auch alle Werte in long geändert und es ging trotzdem nicht. Es hat erst funktioniert, als ich mein array ausgabe[j] innerhalb der for-Schleife deklariert habe, was daraus folgte, dass es außerhalb der Funktion nicht mehr bekannt war.

Manchmal bekomme ich den Eindruck Arduino hat ein Eigenleben :smiley:

Muss die Funktion im setup stehen oder in der loop? Es geht ja beides. Mir ist dabei der Unterschied nicht ganz bewusst.

Wie schaffe ich es nun den EEPROM einzubinden? Ich glaube wenn ich das geschafft habe, ist mein endgültiges Problem gelöst. Mein Denkproblem ist immer folgendes: Ich kann zwar alle 6 Bytes eine Variable Tag oder Monat auslesen, darf jedoch beim sortieren das gesamte Datum nicht auseinanderreißen und die Ausgabe muss mir wieder ein Wert als Datum zurückliefern, so dass ich es auf dem Display lesbar erkennen kann. Wobei wenn ich richtig sehe, dieses schon implementiert wurde.

So sieht momentan meine Ausgabe des Datums aus. Mit “0” und “8” scrolle ich sozusagen durch das Menü.

    case 3:

      while (1) {
        lcd.setCursor(0, 1);
        for ( j = n; j < 6 + n; j++) {
          a[j] = I2CEEPROM_Read(j);
          if (a[j] == 255) {
            a[j] = 0;
          }
          if (a[j] < 10) {
            lcd.print("0");
          }
          lcd.print(a[j]);
          if (j == n + 0 || j == n + 1) { //Nach den einzelnen Bytes die Punkte drucken
            lcd.print(".");
          }
          if (j == n + 3) { //Nach den einzelnen Bytes die Punkte drucken
            lcd.print(":");
          }
          if (j == n + 2 || j == n + 4) { //Nach den einzelnen Bytes die Punkte drucken
            lcd.print(" ");
          }
        }

        lcd.setCursor(0, 2);
        for ( j = n + 6; j < 12 + n; j++) {
          a[j] = I2CEEPROM_Read(j);
          if (a[j] == 255) {
            a[j] = 0;
          }
          if (a[j] < 10) {
            lcd.print("0");
          }
          lcd.print(a[j]);
          if (j == n + 6 || j == n + 7) {
            lcd.print(".");
          }
          if (j == n + 9) { 
            lcd.print(":");
          }
          if (j == n + 8 || j == n + 10) { 
            lcd.print(" ");
          }
        }
        
        lcd.setCursor(0, 3);
        for ( j = n + 12; j < 18 + n; j++) {
          a[j] = I2CEEPROM_Read(j);
          if (a[j] == 255) {
            a[j] = 0;
          }
          if (a[j] < 10) {
            lcd.print("0");
          }
          lcd.print(a[j]);
          if (j == n + 12 || j == n + 13) {
            lcd.print(".");
          }
          if (j == n + 15) { 
            lcd.print(":");
          }
          if (j == n + 14 || j == n + 16) 
            lcd.print(" ");
          }

        }
        key = keypad.getKey();
        if (key == 'D') {
          lcd.clear();
          break;// Abbruchbedingung: Wenn 'D' gedrückt wird, anzeige = 0 => Startbildschirm
          // anzeige = 0;    // goto Startbildschirm
        }
        //----------------------Menu scrollen------------------------------------------
        if (key == '0') {
          n = n + 6;
        }
        if (key == '8' && n > 0) {
          n = n - 6;
        }
        //--------------------Termin loeschen----------------------------------------
        if (key == 'C') {
          lcd.setCursor(0, 1);
          for (j = n; j < 6 + n; j++) {
            I2CEEPROM_Write(j, 0xFF);
          }
          n = 0;
        }
      }

      if (key == 'D') {
        lcd.clear();      // Abbruchbedingung: Wenn 'D' gedrückt wird, anzeige = 0 => Startbildschirm
        anzeige = 0;    // goto Startbildschirm
      }
      break;
byte I2CEEPROM_Read(unsigned int address )
{
  Wire.beginTransmission(EEPROM_ID);
  Wire.write((int)highByte(address) );
  Wire.write((int)lowByte(address) );
  Wire.endTransmission();
  Wire.requestFrom(EEPROM_ID, (byte)1);
  while (Wire.available() == 0); // wait for data
  data = Wire.read();
  return data;
}

Hier ist noch einmal die Ansicht, wie die Termin im EEPROM liegen.

Das EEPROM im atmega328 brauchst du nicht einzubinden oder über I2C zu adressieren.

Muss die Funktion im setup stehen oder in der loop?

Schonmal in die Referenz geguckt? Und da setup und loop gefunden?

Wenn du einen Test machst, den du nur per Knopfdruck (Reset) wiederholen willst, und du dir bis dahin in Ruhe das Ergebnis im SerialMonitor angucken willst, ...

Du darfst den Grund nicht aus den Augen verlieren. Dazu kannst Du ein zweidimensionales Feld verwenden oder zwei eindimensionale. Ich habe meinen Testsketch um die “Mitsortierung” des Grundes erweitert:

const byte AnzahlZeiten = 3;
uint32_t zeiten[AnzahlZeiten];
byte gruende[AnzahlZeiten];
byte jahr, monat, tag, stunde, tminute;

void setup() {
  Serial.begin(9600);
  Serial.println("Anfang");
  jahr = 16;
  monat = 12;
  tag = 15;
  stunde = 12;
  tminute = 15;
  zeiten[0] = ((((long)jahr * 16 + monat) * 32 + tag) * 32 + stunde) * 64 + tminute;
  gruende[0] = 1;

  jahr = 16;
  monat = 12;
  tag = 15;
  stunde = 7;
  tminute = 00;
  zeiten[1] = ((((long)jahr * 16 + monat) * 32 + tag) * 32 + stunde) * 64 + tminute;
  gruende[1] = 5;

  jahr = 16;
  monat = 12;
  tag = 15;
  stunde = 13;
  tminute = 30;
  zeiten[2] = ((((long)jahr * 16 + monat) * 32 + tag) * 32 + stunde) * 64 + tminute;
  gruende[2] = 7;

  uint32_t tmpZeit = 0;
  byte tmpGrund = 0;
  Serial.println("Vor dem Sortieren: ");
  for ( byte j = 0; j < AnzahlZeiten; j++) {
    Serial.print(j);
    Serial.print("\t");
    Serial.print(zeiten[j], DEC);
    Serial.print("\tGrund ");
    Serial.println(gruende[j], DEC);
  }
  for ( byte j = 0; j < (AnzahlZeiten - 1); j++) {
    if (zeiten[j] > zeiten[j + 1]) {
      tmpZeit = zeiten[j + 1];
      tmpGrund = gruende[j + 1];
      zeiten[j + 1] = zeiten[j];
      gruende[j + 1] = gruende[j];
      zeiten[j] = tmpZeit;
      gruende[j] = tmpGrund;
    }
  }
  Serial.println("Nach dem Sortieren: ");
  for ( byte j = 0; j < AnzahlZeiten; j++) {
    Serial.print(j);
    Serial.print("\t");
    Serial.print(zeiten[j], DEC);
    Serial.print("\tGrund ");
    Serial.println(gruende[j], DEC);
  }
}

void loop() {}

Danke schon mal für eure kompetene Hilfe hier. Ich habe nun auch in die Referenz geschaut ;)

Ich muss es mal in mein Programm implementieren und melde mich dann wieder.

Ich hatte schon ein paar Sketche geschrieben, bevor ich die Referenz und die Beispiele in der IDE gefunden habe. Mit dem Playground stehe ich immer noch auf Kriegsfuß :frowning:

Viel Erfolg, wird schon werden :slight_smile:

Ich mach es leider immer noch falsch :o Ich möchte ja nun keine festen Werte haben, sondern die Werte aus dem EEPROM. So wie ich es aber nun habe, steht im Monitor nur “Anfang” und sonst nichts weiter. Es soll ja nun dynamisch werden

#include <Wire.h>
byte data;
const byte EEPROM_ID = 0x50;
byte i = 0;

//----------------------int -> hex-Konvertierung mit der Angabe der Stellen------------------------------------------
String int2hex(int wert, int stellen) {
  String temp = String(wert, HEX);
  String prae = "";
  int len = temp.length(); // Die Länge der Zeichenkette ermitteln
  int diff = stellen - len;
  for (int i = 0; i < diff; i++)
    prae = prae + "0"; // Führende Nullen erzeugen
  return prae + temp; // Führende Nullen + Ergebnis zurückliefern
}
//----------------------This function is similar to EEPROM.read()------------------------------------------
byte I2CEEPROM_Read(unsigned int address )
{
  Wire.beginTransmission(EEPROM_ID);
  Wire.write((int)highByte(address) );
  Wire.write((int)lowByte(address) );
  Wire.endTransmission();
  Wire.requestFrom(EEPROM_ID, (byte)1);
  while (Wire.available() == 0); // wait for data
  data = Wire.read();
  return data;
}
//-------------------------------------------------------------------------------------------------------------------------------------
const byte AnzahlZeiten = 4096;
uint32_t zeiten[AnzahlZeiten];
byte gruende[AnzahlZeiten];
byte jahr, monat, tag, stunde, tminute;
void setup() {
  Serial.begin(9600);
  Serial.println("Anfang");
  byte z=z+6;
for (byte j=z;j<j+z;j++){
  tag = I2CEEPROM_Read(0x00+j);
  monat = I2CEEPROM_Read(0x01+j);
  jahr = I2CEEPROM_Read(0x02+j);
  stunde = I2CEEPROM_Read(0x03+j);
  tminute = I2CEEPROM_Read(0x04+j);
  zeiten[0+j] = ((((long)jahr * 16 + monat) * 32 + tag) * 32 + stunde) * 64 + tminute;
  gruende[0+j] = I2CEEPROM_Read(0x05+j);
}
  uint32_t tmpZeit = 0;
  byte tmpGrund = 0;
  Serial.println("Vor dem Sortieren: ");
  for ( byte j = 0; j < AnzahlZeiten; j++) {
    Serial.print(j);
    Serial.print("\t");
    Serial.print(zeiten[j], DEC);
    Serial.print("\tGrund ");
    Serial.println(gruende[j], DEC);
  }
  for ( byte j = 0; j < (AnzahlZeiten - 1); j++) {
    if (zeiten[j] > zeiten[j + 1]) {
      tmpZeit = zeiten[j + 1];
      tmpGrund = gruende[j + 1];
      zeiten[j + 1] = zeiten[j];
      gruende[j + 1] = gruende[j];
      zeiten[j] = tmpZeit;
      gruende[j] = tmpGrund;
    }
  }
  Serial.println("Nach dem Sortieren: ");
  for ( byte j = 0; j < AnzahlZeiten; j++) {
    Serial.print(j);
    Serial.print("\t");
    Serial.print(zeiten[j], DEC);
    Serial.print("\tGrund ");
    Serial.println(gruende[j], DEC);
  }
}

void loop() {}

Vielleicht mal den Status von

  Wire.endTransmission()

abfragen, oder nicht ewig warten, wenn nachrequestFromauchavailablefehlschlägt...

Es scheint von der Funktion EEPROM_read abzuhängen. Wenn die Variablen nur Zahlen enthalten, kann ich das Programm ausführen, so wie hier im Code aber nicht.

  tag = I2CEEPROM_Read(0x00);
  monat = I2CEEPROM_Read(0x01);
  jahr = I2CEEPROM_Read(0x02);
  stunde = I2CEEPROM_Read(0x03);
  tminute = I2CEEPROM_Read(0x04);
  zeiten[0] = ((((long)jahr * 16 + monat) * 32 + tag) * 32 + stunde) * 64 + tminute;
  gruende[0] = I2CEEPROM_Read(0x05);

Warnungen:

Test_Forum.ino:30:27: warning: large integer implicitly truncated to unsigned type [-Woverflow]
Test_Forum.ino: In function 'void setup()':
Test_Forum.ino:50:25: warning: comparison is always false due to limited range of data type [-Wtype-limits]
Test_Forum.ino:57:42: warning: comparison is always false due to limited range of data type [-Wtype-limits]
Test_Forum.ino:68:25: warning: comparison is always false due to limited range of data type [-Wtype-limits]
Test_Forum.ino:37:12: warning: 'z' is used uninitialized in this function [-Wuninitialized]
Test_Forum.ino:44:13: warning: array subscript is above array bounds [-Warray-bounds]
Test_Forum.ino:45:14: warning: array subscript is above array bounds [-Warray-bounds]
...
Globale Variablen verwenden 20.938 Bytes (1.022%) des dynamischen Speichers, -18.890 Bytes für lokale Variablen verbleiben. Das Maximum sind 2.048 Bytes.

Die Warnungen hatte ich nicht, aber selbst wenn ich nun erstmal ohne die Funktionen arbeite, so wie in #29 klappt es nicht.

Hast du Warnungen überhaupt aktiviert? Das sind alles Warnungen die praktisch schon Fehler sind.

Besonders die Speicherbelegung halte ich für überkritisch.

Gruß Tommy

Es war deaktiviert, danke für den Hinweis. Es geht jedoch trotzdem weiterhin nicht.

Dieser Code ist der letzte Stand, um erst einmal zu sehen, ob ich den EEPROM auslesen kann.

const byte AnzahlZeiten = 3;
uint32_t zeiten[AnzahlZeiten];
byte gruende[AnzahlZeiten];
byte jahr, monat, tag, stunde, tminute;
#include <Wire.h>
byte data;
const byte EEPROM_ID = 0x50;
byte i = 0;
//----------------------int -> hex-Konvertierung mit der Angabe der Stellen------------------------------------------
String int2hex(int wert, int stellen) {
  String temp = String(wert, HEX);
  String prae = "";
  int len = temp.length(); // Die Länge der Zeichenkette ermitteln
  int diff = stellen - len;
  for (int i = 0; i < diff; i++)
    prae = prae + "0"; // Führende Nullen erzeugen
  return prae + temp; // Führende Nullen + Ergebnis zurückliefern
}
//----------------------This function is similar to EEPROM.read()------------------------------------------
byte I2CEEPROM_Read(unsigned int address )
{
  Wire.beginTransmission(EEPROM_ID);
  Wire.write((int)highByte(address) );
  Wire.write((int)lowByte(address) );
  Wire.endTransmission();
  Wire.requestFrom(EEPROM_ID, (byte)1);
  while (Wire.available() == 0); // wait for data
  data = Wire.read();
  return data;
}
//-------------------------------------------------------------------------------------------------------------------------------------

void setup() {
  Serial.begin(9600);
  Serial.println("Anfang");

  tag = I2CEEPROM_Read(0x00);
  monat = I2CEEPROM_Read(0x01);
  jahr = I2CEEPROM_Read(0x02);
  stunde = I2CEEPROM_Read(0x03);
  tminute = I2CEEPROM_Read(0x04);
  zeiten[0] = ((((long)jahr * 16 + monat) * 32 + tag) * 32 + stunde) * 64 + tminute;
  gruende[0] = I2CEEPROM_Read(0x05);
  /*jahr = 10;
  monat = 11;
  tag = 15;
  stunde = 7;
  tminute = 00;
  zeiten[0] = ((((long)jahr * 16 + monat) * 32 + tag) * 32 + stunde) * 64 + tminute;
  gruende[0] = 5;*/

  jahr = 16;
  monat = 12;
  tag = 15;
  stunde = 7;
  tminute = 00;
  zeiten[1] = ((((long)jahr * 16 + monat) * 32 + tag) * 32 + stunde) * 64 + tminute;
  gruende[1] = 5;

  jahr = 16;
  monat = 12;
  tag = 15;
  stunde = 13;
  tminute = 30;
  zeiten[2] = ((((long)jahr * 16 + monat) * 32 + tag) * 32 + stunde) * 64 + tminute;
  gruende[2] = 7;

  uint32_t tmpZeit = 0;
  byte tmpGrund = 0;
  Serial.println("Vor dem Sortieren: ");
  for ( byte j = 0; j < AnzahlZeiten; j++) {
    Serial.print(j);
    Serial.print("\t");
    Serial.print(zeiten[j], DEC);
    Serial.print("\tGrund ");
    Serial.println(gruende[j], DEC);
  }
  for ( byte j = 0; j < (AnzahlZeiten - 1); j++) {
    if (zeiten[j] > zeiten[j + 1]) {
      tmpZeit = zeiten[j + 1];
      tmpGrund = gruende[j + 1];
      zeiten[j + 1] = zeiten[j];
      gruende[j + 1] = gruende[j];
      zeiten[j] = tmpZeit;
      gruende[j] = tmpGrund;
    }
  }
  Serial.println("Nach dem Sortieren: ");
  for ( byte j = 0; j < AnzahlZeiten; j++) {
    Serial.print(j);
    Serial.print("\t");
    Serial.print(zeiten[j], DEC);
    Serial.print("\tGrund ");
    Serial.println(gruende[j], DEC);
  }
}

void loop() {}

Der Sketch verwendet 3.772 Bytes (12%) des Programmspeicherplatzes. Das Maximum sind 30.720 Bytes.
Globale Variablen verwenden 473 Bytes (23%) des dynamischen Speichers, 1.575 Bytes für lokale Variablen verbleiben. Das Maximum sind 2.048 Bytes.

Wenn die Variablen nur Zahlen enthalten

Was meinst du denn mit diesem unsinnigen Satz?

um erst einmal zu sehen, ob ich den EEPROM auslesen kann

… solltest schon etwas tiefer einsteigen…

Es kann nämlich gut sein, dass dein Code NIE aus I2CEEPROM_Read zurückkommt.
Dann kommt -wie du beschrieben hast- nach
Serial.println(“Anfang”);
einfach nix mehr.

Ich habe es hin bekommen. Der Code kam durch die while-Schleife im EEPROM_Read nicht zurück.

Die Speicherbelegung ist tatsächlich ein Problem. Bei 100 Terminen habe ich bei dem Arduino Nano eine Auslastung von 50%. Da wurde mir schon der Arduino Due empfohlen.

Ich bin gerade noch am testen. Ich sage aber schon einmal Danke für eure Hilfe. Das hätte ich alleine nicht gelöst bekommen.

const byte AnzahlZeiten = 100;
uint32_t zeiten[AnzahlZeiten]; // 400 byte
byte gruende[AnzahlZeiten];   // 100 byte

Das macht 25% vom RAM eines Uno/Nano (atmega328) Wofür brauchst du doppelt so viel? Oder auf was bezieht sich deine "Auslastung von 50%" Und warum brauchst du die überhaupt alle, wenn sie sowieso schon im EEPROM stehen? Und wo ist dein Problem? Brauchst du eigentlich 250 (statt 100) Einträge ? Oder hast du noch String Objekte zusätzlich?

( Ausserdem bin ich neugierig, wofür du das überhaupt brauchst )

Ich arbeite gerade mit dem folgenden Programm. Die Werte stehen zwar im EEPROM, jedoch möchte ich die Sortierung nicht im EEPROM vornehmen, damit dieser nicht ständig überschrieben wird. Ich habe die Auswertung dynamisch gemacht und hatte dabei eine relativ hohe Auslastung.

#include <Wire.h>
const byte AnzahlZeiten = 100;
uint32_t zeiten[AnzahlZeiten];
byte gruende[AnzahlZeiten];
byte jahr, monat, tag, stunde, tminute;
byte data;
const byte EEPROM_ID = 0x50;
byte i = 0;
uint32_t tmpZeit = 0;
byte tmpGrund = 0;
//----------------------hex2dec------------------------------------------
long hex2dec(char * a) {
  char c;
  long n = 0;

  while (*a) {
    c = *a++;
    if (c >= '0' && c <= '9') {
      c -= '0';
    } else if (c >= 'a' && c <= 'f') {
      c = (c - 'a') + 10;
    } else if (c >= 'A' && c <= 'F') {
      c = (c - 'A') + 10;
    } else {
      goto INVALID;
    }
    n = (n << 4) + c;
  }
  return n;
INVALID:
  return -1;
}

//----------------------int -> hex-Konvertierung mit der Angabe der Stellen------------------------------------------
String int2hex(int wert, int stellen) {
  String temp = String(wert, HEX);
  String prae = "";
  int len = temp.length(); // Die Länge der Zeichenkette ermitteln
  int diff = stellen - len;
  for (int i = 0; i < diff; i++)
    prae = prae + "0"; // Führende Nullen erzeugen

  return prae; // Führende Nullen + Ergebnis zurückliefern
}
//----------------------This function is similar to EEPROM.read()------------------------------------------
byte I2CEEPROM_Read(unsigned int address )
{
  Wire.beginTransmission(EEPROM_ID);
  Wire.write((int)highByte(address) );
  Wire.write((int)lowByte(address) );
  Wire.endTransmission();
  Wire.requestFrom(EEPROM_ID, (byte)1);
  //while (Wire.available() == 0); // wait for data
  data = Wire.read();
  //hex umwandeln in int
  return data;
}
//-------------------------------------------------------------------------------------------------------------------------------------
void setup() {
  Serial.begin(9600);
  Serial.println("Anfang");
  delay(200);
}
int k = 0;
void loop() {
  Serial.println("Vor dem Sortieren: ");
  for ( byte j = 0; j < AnzahlZeiten; j++) {
    Serial.print(j);
    Serial.print("\t");
    Serial.print(zeiten[j], DEC);
    Serial.print("\tGrund ");
    Serial.println(gruende[j], DEC);
  }
  //int sortieren() {
  //int i = 0;
  for ( byte j = 0; j < (AnzahlZeiten - 1); j++) {
    tag = hex2dec(I2CEEPROM_Read(k));
    k = k + 1;
    monat = hex2dec(I2CEEPROM_Read(k));
    k = k + 1;
    jahr = hex2dec(I2CEEPROM_Read(k));
    k = k + 1;
    stunde = hex2dec(I2CEEPROM_Read(k));
    k = k + 1;
    tminute = hex2dec(I2CEEPROM_Read(k));
    k = k + 1;
    byte z = z+1;
    zeiten[z] = ((((long)jahr * 16 + monat) * 32 + tag) * 32 + stunde) * 64 + tminute;
    gruende[z] = hex2dec(I2CEEPROM_Read(k));
    k = k + 6;
    if (zeiten[j] > zeiten[j + 1]) {
      tmpZeit = zeiten[j + 1];
      tmpGrund = gruende[j + 1];
      zeiten[j + 1] = zeiten[j];
      gruende[j + 1] = gruende[j];
      zeiten[j] = tmpZeit;
      gruende[j] = tmpGrund;
    }
  }
  Serial.println("Nach dem Sortieren: ");
  for ( byte j = 0; j < AnzahlZeiten; j++) {
    Serial.print(j);
    Serial.print("\t");
    Serial.print(zeiten[j], DEC);
    Serial.print("\tGrund ");
    Serial.println(gruende[j], DEC);
  }
}

Der Sketch verwendet 4.042 Bytes (13%) des Programmspeicherplatzes. Das Maximum sind 30.720 Bytes.
Globale Variablen verwenden 965 Bytes (47%) des dynamischen Speichers, 1.083 Bytes für lokale Variablen verbleiben. Das Maximum sind 2.048 Bytes.

michael_x:
( Ausserdem bin ich neugierig, wofür du das überhaupt brauchst )

Siehe #5!

Joe194:
Ich arbeite gerade mit dem folgenden Programm.

Mein Compiler (IDE 1.6.5) mag Deinen Sketch nicht:

Arduino: 1.6.5 (Windows 7), TD: 1.25, Platine: "Arduino/Genuino Uno"

Test_Forum.ino: In function 'void loop()':
Test_Forum:80: error: invalid conversion from 'byte {aka unsigned char}' to 'char*' [-fpermissive]
Test_Forum:15: error: initializing argument 1 of 'long int hex2dec(char*)' [-fpermissive]
Test_Forum:82: error: invalid conversion from 'byte {aka unsigned char}' to 'char*' [-fpermissive]
Test_Forum:15: error: initializing argument 1 of 'long int hex2dec(char*)' [-fpermissive]
Test_Forum:84: error: invalid conversion from 'byte {aka unsigned char}' to 'char*' [-fpermissive]
Test_Forum:15: error: initializing argument 1 of 'long int hex2dec(char*)' [-fpermissive]
Test_Forum:86: error: invalid conversion from 'byte {aka unsigned char}' to 'char*' [-fpermissive]
Test_Forum:15: error: initializing argument 1 of 'long int hex2dec(char*)' [-fpermissive]
Test_Forum:88: error: invalid conversion from 'byte {aka unsigned char}' to 'char*' [-fpermissive]
Test_Forum:15: error: initializing argument 1 of 'long int hex2dec(char*)' [-fpermissive]
Test_Forum:92: error: invalid conversion from 'byte {aka unsigned char}' to 'char*' [-fpermissive]
Test_Forum:15: error: initializing argument 1 of 'long int hex2dec(char*)' [-fpermissive]
invalid conversion from 'byte {aka unsigned char}' to 'char*' [-fpermissive]
byte z = z + 1;
warning: 'z' is used uninitialized in this function [-Wuninitialized]

Die Wertzuweisung k=0 scheint mir an der falschen Stelle.

Bist Du bereit, über das Konzept zu sprechen? Anmerkungen von mir:

  • Anstelle der hier im Forum als ungenau beschriebenen Tiny RTC, wurde DS3231 empfohlen. Gibt es auch mit EEPROM auf der Platine. Meine läuft schön genau.
  • Eigentlich sollte ein Nano bei vernünftiger Programmierung ausreichen. Wenn Du dennoch nach mehr Speicher suchst, könntest Du auch einen Blick auf die Teensys werfen. Die können auch über die Arduino IDE programmiert werden, nur verwendet der µC 32 Bits anstelle 8 Bits. Außerdem benötigst Du für I2C einen Levelshifter. Ich nutze einen Teensy 3.2 für LED-Animation.
  • Die mir bekannten christlichen Kirchen haben wöchentlich wiederkehrende Läutzeiten. Also beispielsweise immer Sonntag 11 Uhr. Das könnte man zusätzlich berücksichtigen.
  • Ich sehe einen SD-Karten Steckplatz. Da würde ich Daten mittels Excel erfassen und in einer csv-Datei speichern. Dann auf Knopfdruck Daten einlesen, sortieren und im EEPROM speichern. Erspart die Tipperei vor LC-Display.

Datenerfassung in OpenOffice:
Läutzeiten.png

Inhalt der csv-Datei:

16.12.2016;12:00;5
17.12.2016;11:15;1
18.12.2016;07:30;3