einfacher logger ...

International Deutsch
1

Tach, Ich bin grade am überlegen wie ich nen einfachen logger zustande bekomme.

Ich möchte gerne eine Array o.ä. haben mit sagen wir mal 30 positionen mit datum zeit und text zu "speichern"

ich dachte an sowas:

void addlog(char text)
{
  int loggerpos = 0;
  char buff[80];
  char logger[29];

  
  if (loggerpos <= 29) {
  //sprintf(buff, "%02d:%02d um %02d:02d:02d - %", day(), month, hour(), minute(), second(), text );
  sprintf(buff, "%02d:%02d um %02d:02d:02d - %", "23", "12", "20", "50", "22", text);
  logger[loggerpos] = buff;
  loggerpos++1;
  } 


  if (loggerpos == 29)
  {  
  logger[0] = logger[1];
  logger[1] = logger[2];
  logger[2] = logger[3];
  logger[3] = logger[4];
  logger[4] = logger[5];
  logger[5] = logger[6];
  logger[6] = logger[7];
  logger[7] = logger[8];
  logger[8] = logger[9];
  logger[9] = logger[10];
  logger[10] = logger[11];
  logger[11] = logger[12];
  logger[12] = logger[13];
  logger[13] = logger[14];
  logger[14] = logger[15];
  logger[15] = logger[16];
  logger[16] = logger[17];
  logger[17] = logger[18];
  logger[18] = logger[19];
  logger[19] = logger[20];
  logger[20] = logger[21];
  logger[21] = logger[22];
  logger[22] = logger[23];
  logger[23] = logger[24];
  logger[24] = logger[25];
  logger[25] = logger[26];
  logger[26] = logger[27];
  logger[27] = logger[28];
  logger[28] = logger[29];

  //sprintf(buff "%02d:%02d um %02d:02d:02d - %", day(), month(), hour(), minute(), second(), text);
  sprintf(buff, "%02d:%02d um %02d:02d:02d - %", "23", "12", "20", "50", "22", text);
  logger[29] = buff;
  }

  
}



void loop(){
for (int i = 0; i < 29; i++){
   Serial.println(logger[i]);
   delay(500);
   }


if (blabla == 1) {
  //machwas
  addlog("blabla wurde aktiviert");

  
}
}

könnt ihr mir sagen wie ich z.b. nen "leeres" array definiere und ob das so funzen wird oder das einfach ne totale Katastrophe ist? hab grad keine arduino ide bei mir...

ziel ist es bis zu 30 Ereignisse irgendwo zu hinterlegen und auf dem tft später als "log" darstellen... also sprich immer nur die aktuellsten und die größer 29 sollen überschrieben werden.

ich hoffe man kann aus meinem salat erkennen was ich will..

2

Je nach Log-Frequenz würde ich das eher im Eeprom ablegen, damit es bei Stromausfall nicht verloren geht.

3

ist nen arduino due hat keinen eeprom. benötige auch keine längere speicherung. ich schätze ca 100-150 einträge am tag.

4

Dann schreib es ins Flash.

Aber wenn du es eh nur im RAM haben willst, dann bau dir die Datenstructur und schreib die Daten da rein.
Wenn der index > 29 ist, stellst du ihn auf 0 und weiter gehts.

5

hab das ganze mal zum laufen bekommen jetzt:

char* logger[30];
int loggerpos = 0;
int testpos = 0;
char buff2[80];
int ispost = 0;

unsigned long previousMillis = 0;
const long interval = 1000;


void addlog(char* text)
{
  char buff[80] = "";

  if (loggerpos < 29) {
    //sprintf(buff, "%02d:%02d um %02d:02d:02d - %", day(), month, hour(), minute(), second(), text );
    sprintf(buff, "%02d - %s", millis(), text);
    Serial.println(buff);
    Serial.println(loggerpos);
    logger[loggerpos] = buff;
    loggerpos++ ;
  }


  if (loggerpos == 29)
  {
    logger[0] = logger[1];
    logger[1] = logger[2];
    logger[2] = logger[3];
    logger[3] = logger[4];
    logger[4] = logger[5];
    logger[5] = logger[6];
    logger[6] = logger[7];
    logger[7] = logger[8];
    logger[8] = logger[9];
    logger[9] = logger[10];
    logger[10] = logger[11];
    logger[11] = logger[12];
    logger[12] = logger[13];
    logger[13] = logger[14];
    logger[14] = logger[15];
    logger[15] = logger[16];
    logger[16] = logger[17];
    logger[17] = logger[18];
    logger[18] = logger[19];
    logger[19] = logger[20];
    logger[20] = logger[21];
    logger[21] = logger[22];
    logger[22] = logger[23];
    logger[23] = logger[24];
    logger[24] = logger[25];
    logger[25] = logger[26];
    logger[26] = logger[27];
    logger[27] = logger[28];
    logger[28] = logger[29];

    //sprintf(buff "%02d:%02d um %02d:02d:02d - %", day(), month(), hour(), minute(), second(), text);
    sprintf(buff, "%02d - %s", millis(), text);
    Serial.println(buff);
    Serial.println(loggerpos);
    logger[29] = buff;
  }


}


void setup() {
  // put your setup code here, to run once:
  Serial.begin(9600);


}


void loop() {
  unsigned long currentMillis = millis();


  if (currentMillis - previousMillis >= interval) {
    previousMillis = currentMillis;

    if (currentMillis < 35000) {
      sprintf(buff2, "%02d %s", testpos, "blablawurde aktiviert");
      addlog(buff2);
      testpos++;
    }
  }


  if (currentMillis > 36000) {
    if (ispost == 0)
    {
      Serial.println("datenausgabe:");

      Serial.println(logger[0]);
      Serial.println(logger[1]);
      Serial.println(logger[2]);
      Serial.println(logger[3]);
      Serial.println(logger[4]);
      Serial.println(logger[5]);
      Serial.println(logger[6]);
      Serial.println(logger[7]);
      Serial.println(logger[8]);
      Serial.println(logger[9]);
      Serial.println(logger[10]);
      Serial.println(logger[11]);
      Serial.println(logger[12]);
      Serial.println(logger[13]);
      Serial.println(logger[14]);
      Serial.println(logger[15]);
      Serial.println(logger[16]);
      Serial.println(logger[17]);
      Serial.println(logger[18]);
      Serial.println(logger[19]);
      Serial.println(logger[20]);
      Serial.println(logger[21]);
      Serial.println(logger[22]);
      Serial.println(logger[23]);
      Serial.println(logger[24]);
      Serial.println(logger[25]);
      Serial.println(logger[26]);
      Serial.println(logger[27]);
      Serial.println(logger[28]);
      Serial.println(logger[29]);
      ispost = 1;
    }




  }
}

allerdings gibt mir die arraywerte ausgabe mist raus..

1000 - 00 blablawurde aktiviert
0
2000 - 01 blablawurde aktiviert
1
3000 - 02 blablawurde aktiviert
2
4000 - 03 blablawurde aktiviert
3
5000 - 04 blablawurde aktiviert
4
6000 - 05 blablawurde aktiviert
5
7000 - 06 blablawurde aktiviert
6
8000 - 07 blablawurde aktiviert
7
9000 - 08 blablawurde aktiviert
8
10000 - 09 blablawurde aktiviert
9
11000 - 10 blablawurde aktiviert
10
12000 - 11 blablawurde aktiviert
11
13000 - 12 blablawurde aktiviert
12
14000 - 13 blablawurde aktiviert
13
15000 - 14 blablawurde aktiviert
14
16000 - 15 blablawurde aktiviert
15
17000 - 16 blablawurde aktiviert
16
18000 - 17 blablawurde aktiviert
17
19000 - 18 blablawurde aktiviert
18
20000 - 19 blablawurde aktiviert
19
21000 - 20 blablawurde aktiviert
20
22000 - 21 blablawurde aktiviert
21
23000 - 22 blablawurde aktiviert
22
24000 - 23 blablawurde aktiviert
23
25000 - 24 blablawurde aktiviert
24
26000 - 25 blablawurde aktiviert
25
27000 - 26 blablawurde aktiviert
26
28000 - 27 blablawurde aktiviert
27
29000 - 28 blablawurde aktiviert
28
29000 - 28 blablawurde aktiviert
29
30000 - 29 blablawurde aktiviert
29
31000 - 30 blablawurde aktiviert
29
32000 - 31 blablawurde aktiviert
29
33000 - 32 blablawurde aktiviert
29
34000 - 33 blablawurde aktiviert
29
datenausgabe:
34000 - 33 blabl
34000 - 33 blabl
34000 - 33 blabl
34000 - 33 blabl
34000 - 33 blabl
34000ÿÿÿ

ard.png
ard.png1920×1080 40.5 KB

6

Du machst da auch ganz, ganz großen Unsinn mit dem Speicher. Du hast ein lokales Array buff. Dann hast du ein globales Array aus Zeigern. Und diese Zeiger zeigen immer auf das gleiche lokale Array. Das kann so einfach nicht funktionieren

ziel ist es bis zu 30 Ereignisse irgendwo zu hinterlegen und auf dem tft später als "log" darstellen... also sprich immer nur die aktuellsten und die größer 29 sollen überschrieben werden.

Deine gewünschte Datenstruktur nennt sich Ringpuffer

Außerdem solltest du dir vielleicht mal structs ansehen. Gerade wenn du nicht mit C Strings umgehen kannst vielleicht die bessere Wahl.

7

gibts da was von ratiopharm?

hmm. ja ich wollte es mir möglichst einfach machen :confused: mein strukturiertes denken in sachen arduino ist noch am anfang und am lernen =)

mein Due hat noch genug ram von daher stört es mich nicht wenn der Logger ins ram brüllt. hauptsache ich komme einfach an die logs wieder.

8

mpl1337:
mein Due hat noch genug ram von daher stört es mich nicht wenn der Logger ins ram brüllt. hauptsache ich komme einfach an die logs wieder.

Das wird so eben nichts wenn du ein Array hast dass auf lokalen Speicher zeigt. Lokale Variablen hören am Ende ihres Scopes auf zu existieren! Und du kannst in C/C++ nicht Arrays mit = zuweisen/kopieren. Das sind keine Objekte. Eine Array Variable ist ein Zeiger auf das erste Element. Das ist nichts Arduino-spezifisches, sondern liegt an der Programmiersprache.

Du kannst sowas machen:

struct Element
{
   byte hour;
   byte minute;
   byte second;
   byte day;
   byte month;
   byte year;   //oder short für 4-stellige Jahreszahlen

   char text[20];
};

Und dann ein Array daraus. Das struct hat dann Platz für 19 Zeichen Text (+ Terminator). Und bei dem Text musst du aufpassen dass du nicht über das Ende des Arrays hinaus schreibst. Also Funktionen wie strncpy() oder snprintf() für das Kopieren verwenden! Dann werden nur n Zeichen kopiert.

Bei dem Index hast du zwei Optionen:
1.) Du machst einfach if (index >= 30) index = 0
2.) Du machst bei jedem Inkrementieren eine Modulo-Division:
index = (index + 1) % 30;

Der Modulo ist der Rest einer ganzzahligen Division:
29 % 30 = 29
30 % 30 = 0

9

mpl1337:
mein strukturiertes denken in sachen arduino ist noch am anfang und am lernen =)

Ein wichtiger Punkt. Und vorher solltest du dich noch mit den Basics beschäftigen. Spart dir später viel Zeit und Nachfragen ein. Danach kommt das mit der Struktur.

10

Mm OK. Ist zu viel unbekanntes Gebiet auf einmal. ... Kennst du oder jemand anderes Vllt eine fertige Lib die sowas kann wie ich mir wünsche?

11

Das ist so einfach, da gibt es nicht mal eine Lib für.

Aber man sollte eben die Beispiele durchgearbeitet und verstanden haben. Ein gutes Buch dazu wäre auch nicht verkehrt.

Im playground findet man auch viel, aber dazu sollte man etwas Englisch können.

12

ElEspanol:
Ein wichtiger Punkt. Und vorher solltest du dich noch mit den Basics beschäftigen. Spart dir später viel Zeit und Nachfragen ein. Danach kommt das mit der Struktur.

Ja das ist das Problem... Die Basics sind langweilig.... Ich wurde seit meiner Geburt ins kalte wasser geworfen.. Eltern konnten kein Wort Deutsch... Schule... Keiner lernte mit mir. Ausbildung... Nach wenigen Tagen ohne Gesellen auf Baustelle geschickt. Meister... Kurz erklärt...du musst überleben und dich nicht mit lapalien kaputt schlagen sagte mir man immer, Jetzt kapier das wichtigste oder Schmier ab :frowning: Ich würde gerne bei 0 anfangen... Andere fangen mir hello World oder LED blink an. Bei mir war es der avr net io mit ETH644. Und gleich mal das Aquarium ans Netzwerk gehängt :slight_smile: und hat nach etlichen fragen in Foren und Freundeskreisen geklappt :slight_smile:

13

Das ist zu spezifisch als dass man das alles so ohne weiteres in eine allgemeine Lib gießen könnte. Jedenfalls nicht ohne tief in die C++ Trickkiste zu greifen.

Aber es ist kein Problem dass selbst zu schreiben:

const int LOG_SIZE = 3;

struct Element
{
  byte hour;
  byte minute;
  byte second;
  byte day;
  byte month;
  //byte year;   //oder short für 4-stellige Jahreszahlen

  char text[20];
};

Element logBuffer[LOG_SIZE];

void setup()
{
  Serial.begin(9600);

  addLogEntry("Entry 1");
  addLogEntry("Entry 2");
  addLogEntry("Entry 3");
  printLog();

  addLogEntry("Entry 4");
  printLog();

  addLogEntry("Entry 5");
  addLogEntry("Entry 6");
  printLog();
}

void loop()
{
}

void addLogEntry(const char* text)
{
  static int index;

  logBuffer[index].hour = random(0, 24);
  logBuffer[index].minute = random(0, 60);
  logBuffer[index].second = random(0, 60);
  logBuffer[index].day = random(0, 32);
  logBuffer[index].month = random(0, 13);

  strncpy(logBuffer[index].text, text, sizeof(logBuffer[index].text));

  index = (index + 1) % LOG_SIZE;
}

void printLog()
{
  for (int i = 0; i < LOG_SIZE; i++)
  {
    Serial.print(logBuffer[i].hour);
    Serial.print(':');
    Serial.print(logBuffer[i].minute);
    Serial.print(':');
    Serial.print(logBuffer[i].second);
    Serial.print(" - ");
    Serial.print(logBuffer[i].day);
    Serial.print('.');
    Serial.print(logBuffer[i].month);
    Serial.print(" - ");
    Serial.println(logBuffer[i].text);
  }
  Serial.println("---");
}

Also nicht viel mehr als was ich oben geschrieben habe

Der Puffer ist 3 Einträge groß. Da sieht man schön was überschrieben wird

14

Funzt 1A, Super Danke =)

bist genial =)

15

mpl1337:
bist genial =)

Das weiß er bestimmt schon :wink: