Arrays befüllen und Array mit neuem Inhalt

International Deutsch
1

Hallo ,
2 Fragen:

1. Frage
ich möchte ein gesamtes Array zurücksetzen und mache das mit der for.. schleife.
gibt es eine einfachere Lösung ? (zB array[] = false

for (int i = 0; i < felderfusszeile; i++) {freigabetouchunten[i] = false; zeitfreigabetouchunten[i] = 0;}

2. Frage
Weiters möchte ich ein Array nach der Definition/Initalisierung nochmal mit neuen Werten befüllen.
das geht mit memcopy von einem Array zum anderen.
kann ich das einfach nochmal mit der unteren Methode definieren (dann ohne String vorne)?
Hab das schon probiert, hat aber nicht funktioniert.
die unteren Codezeilen sind nur aus einem Test - final wird das etwas anders aussehen.
Code funktioniert, aber wenn ich zB einen 2. Screen machen möchte, brauch ich nochmal eine 2. Maske mit neuen Messwerten, die ich dann am 4" display anzeigen lasse .
Möchte mit Srings arbeiten, weil es übersichtlicher/einfacher ist als mit char []

String messwerttext[zeilen][felder] {   //     Messwertefeldertext))
{"Aussentemp.:","","",String(werteEG[2]),"o","C","Dach Solar:","","","115","o","C"},
{"EG:",String(werteEG[1]),"%",String(werteEG[2]),"o","C","VL Solar:","","",String(werteEG[2]),"o","C"},
{"Warmw. Oben:","","",String(werteEG[6]),"o","C","Sonnenstrahlg.:","","",String(werteEG[5]),"%",""},
{"Warmw. Unten:","","",String(werteEG[2]),"o","C","Ventilator Klima:","","","68.7","o","C"},
{"VL Heizung:","","","78.7","o","C","K-Heizg:",String(feuchteKG, 0),"%",String(tempKG, 1),"o","C"},
{"RL Heizung:","","",String(werteEG[4]),"o","C","K-Gross:","73","%",String(werteEG[4]),"o","C"},
{"Fernwaerme:","","",String(werteEG[2]),"o","C","K-WR:","65","%",String(werteEG[3]),"o","C"},
{String(licht),"","","","","","KG Wasser :","","",String(oknot),"",""}
};       // Ende String messwerttext [zeilen] [felder]
3

danke ...
weißt du auch wie ich das 2. Thema löse? (ganzes array nochmal neu befüllen im Code)

LG

4

Welchen Arduino verwendest Du denn? Bei den kleineren (AVR) bekommst Du da leicht Probleme - vor allem wenn Du das so intensiv und dynamisch nutzt.

5

ist ein ESP32 - da geht das ohne Performanceprobleme

6

@peter26
2.)
das liest sich alles ein wenig verworren.
Was möchtest in Wirklichkeit machen?

7

Wenn Du mit Strings arbeitest, hast Du keine festen Speicheradressen. Da dürfte das mit dem memcopy problematisch werden.
Du redest auf der einen Seite von Arrays, auf der anderen Seite von Strings. Strings sind aber nicht einfach c-arrays. Und Arrays von Strings sind nochmal was anderes...

8

wozu überhaupt leeren wenn danach sowieso neu bescribenen wird?

9

messwertetext definiert eine "Anzeigemaske" die dann auf einem 4" TFT dargestellt werden und ich brauche halt eine 2. Definition im Code für eine weitere Anzeigemaske.

Ich möchte den String messwertetext ein 2.Mal im Code mit neuen Werten befüllen.
Also einmal passiert das ja bei der Definition - wie im Code dargestellt und dann nochmal (wird für eine 2.Seite verwendet)

10

Was hilft dir das zweidimensionale Array pro "Anzeigemaske"?
Warum schreibst du dir nicht zwei Funktionen und gibts entweder die "Anzeigemaske A" oder die "Anzeigemaske B" aus?

11

ja geht natürlich auch mit der Übernahme des arrays in die Funktion zur Anzeige.

definiere ich 2 weitere Arrays und übergibe das dann an ein Array in der Funktion .
Nachdem auf den ESP schon sehr viele Funktionen laufen, dachte ich, das meine Methode schonender ist und ich komme mit einem array aus

12

Also ich finde das array als solches schon überflüssig. Warum nicht einfach ausgeben? Du hast Feldprompter und du hast Werte. Gib sie am Display aus. Ende. Wozu in ein Array kopieren und dann erst ausgeben?

13

Nein!
memcpy() macht flache Kopien. Du brauchst tiefe.

Ich sehe da keine Gemeinsamkeit mit dem Array.

14

Für die (formatierte) Ausgabe in einer Ausgabemaske halte ich c-strings und printf auch für wesentlich einfacher und übersichtlicher als Strings.

15

Es gibt
memset(array, 0, sizeof(array)); // nutzt aus, dass false und 0 dasselbe ist.

Und es gibt in C++ auch sowas wie foreach

for ( auto& elem: array )
  elem = 0; // Oder sonst eine Aktion, die für jedes array-Element ausgeführt werden soll

Statt auto kann man natürlich auch ordentlich den richtigen Datentyp der array-Elemente angeben.
Und es gibt andere Container statt Arrays.

16

Ich glaube, dass das hier nicht hilft....

Memset ist hier sicherlich mehr als gefährlich/falsch.
Was schlicht daran liegt, dass String Instanzen kaputt gehen, wenn man deren Eigenschaften mit Nullen überschreibt.
Zusätzlich: Es drohen Memory leaks ohne Ende...

Die anderen Ideen sind dagegen gar recht passend, aus meiner Sicht..

17

Naja, das Muster der Zeilen ist immer ähnlich und es ist umständlich jede Zeile extra zu definieren. Zudem erfolgt die Ausgabe einmal über einen 4" TFT und woanders mit weniger Platz über einen 2,4" TFT - damit ist das zukünftig viel leichter portierbar auf andere Displays
Das mit dem Array und dem Anzeigen der Felder ist die bessere Methode ..

for (int z = 0; z < zeilen; z++) {    
  spaltenzaehler = 0;
  
  for (int f = 0; f < felder; f++) {   
    spaltenzaehler = spaltenzaehler + spalte[f];   
    if ((f == 1 || f == 7) & messwerttext[z][f] != "") display.fillRect(spaltenzaehler, beginnzeile + (z - 1) * zeilenabstand + 5, spalte[f+1], zeilenabstand, BLACK);  // löscht Felder mit Messwert1
    if ((f == 3 || f == 9) & messwerttext[z][f] != "") display.fillRect(spaltenzaehler, beginnzeile + (z - 1) * zeilenabstand + 5, spalte[f+1], zeilenabstand, BLACK);  // löscht Felder mit Messwert2

    if (messwerttext[z][f] == "o") {         // bei o wird hochgestellt und damit das Grad Celsius Zeichen dargestellt (das gibts nicht im ASCII Satz des TFT)
     display.setCursor(spaltenzaehler, (beginnzeile + z * zeilenabstand - korrcelsius));    // horizontal/ vertikal 
     display.setFont();
     display.print(String(messwerttext[z][f]));
     display.setFont(&FreeSans10pt7b);
    }    
    else {
     display.setCursor(spaltenzaehler, (beginnzeile + z * zeilenabstand));    // horizontal/ vertikal       
     display.print(String(messwerttext[z][f]));
    }      

   }      // end if  f
  }     // end if  z
18

Da hast du Recht: memset und String Objekte passt nicht zusammen.
Ich persönlich sehe das Problem bei den Strings, die eine nicht vorhandene Einfachheit suggerieren.
Meine Antwort bezog sich (verspätet) auf die allgemeinen Fragen in #1.

Über ein zweidimensionales Array von String Objekten sag ich nichts. außer dass ich allen Recht gebe, die von Strings und/oder von Arrays abraten :stuck_out_tongue:

19

Die hingetürkte Grad Ausgabe passt gut in eine eigene Funktion.
Der Unterschied von 4" und 2.4" kann sich ja eigentlich nur auf unterschiedliche x/y Angaben beziehen.

20

ja das auch, aber auch Zeilenabstand und Spaltenbreiten

Spaltenbreiten : ist dann jeweils so definiert für 4":

    // |0 abstandrand|1 bezeichnung|2 messwert1|4 einheit|5 messwert2|6 grad-symbol|7 einheit und abstand|8 bezeichnung|9 messwert3|10 einheit|11 messwert4 |12 grad-symbol|13 einheit|
  int spalte [felder] {5, 87, 25, 38, 43, 7, 54, 0, 0, 0, 0, 0};  // definition der pixelstartpunkte der 8 spalten    beginnend mit spalte [0]   
  for (int i = 1; i < 6; i++) spalte[i+6] = spalte [i] ;  // breite der spalten 1-3 nach 4-7 kopieren

bzw als Bsp das kleinere Display:

    // |0 abstandrand|1 bezeichnung|2 messwert1|4 einheit|5 messwert2|6 grad-symbol|7 einheit und abstand|8 bezeichnung|9 messwert3|10 einheit|11 messwert4 |12 grad-symbol|13 einheit|
  int spalte [felder] {2, 56, 20, 23, 33, 6, 28, 0, 0, 0, 0 , 0};  // definition der pixelstartpunkte der 8 spalten    beginnend mit spalte [0]   
  for (int i = 1; i < 6; i++) spalte[i+6] = spalte [i] ;  // breite der spalten 1-3 nach 4-7 kopieren

sieht dann im Testaufbau so aus ... (Werte sind zum Großteil noch aus der random-funktion)...

TFT 4 - testaufbau
TFT 4 - testaufbau1920×1360 308 KB

21

Dann definiere die Arrays doch als Konstant innerhalb einer Präprozessordirektive

#define display 4
#if display == 4
   const int spalte [felder] {5, 87, 25, 38, 43, 7, 54, 0, 0, 0, 0, 0};  // definition der pixelstartpunkte der 8 spalten    beginnend mit spalte [0]   
#else
  const int spalte [felder] {2, 56, 20, 23, 33, 6, 28, 0, 0, 0, 0 , 0};  // definition der pixelstartpunkte der 8 spalten    beginnend mit spalte [0]   
#endif

Das Display wir sich ja wohl kaum zur Laufzeit ändern.
Wobei byte anstelle int genügen würde.

Gruß Tommy

Edit: const ergänzt.