Mehrere Initialiserungs- bzw. Deklarierungsfragen

Hallo Leute,

ich habe hier ein Projekt bei dem mehrere Leitung geprüft werden sollen. Später dazu mehr.
Ich möchte den Code übersichtlich halten und möchte gerne die Variablen Deklaration mit for-Schleifen erledigen.
Ich wollte euch mal Fragen, ob das so klappt:

  // Alle Pins des Arrays als Eingang
  for(int i = 1; i < 55; i++)
  pinMode(LeitungsEingang[i], INPUT);
  // Alle Eingänge werden über Pullup-Widerstand auf HIGH
  for(int i = 1; i < 55; i++)
  digitalwrite(LeitungsEingang[i], HIGH);
  // Zählhilfsvariablen deklarieren und mit 0 initialisieren (damit pro Leitung nur 1x gezählt wird)
  byte ZaehlerVariableLeitung[] =  0 
  for(int i = 1; i < 55; i++)
  ZaehlerVariableLeitung[i] = 0

Oder sollte man das so lieber nicht machen? Habe gerade den Arduino nicht hier....

Kann man machen.

Oder du schaust dir mal das an:

http://www.pighixxx.com/pgdev/Temp/ArduinoMega_b.png

Da kann man immer 8 Pins zusammen setzen. Das würde alle Pins von PortC (30-37) auf Ausgang, High schalten:
DDRC = 0xFF;
PORTC = 0xFF;

Die Funktion ist die gleiche, aber es geht wesentlich schneller. Auf dem Arduino Board sind die Pins aber zum Teil etwas durcheinander wenn man sie so anspricht, aber mit dem Pinout Bild kann man das rausfinden.

Wenn du das nur einmal machst (in setup()) ist aber eine for-Schleife jedoch lange gut.

Das geht allerdings nicht:

byte ZaehlerVariableLeitung[] =  0

Du musst schon die Größe angegeben

Kannst machen, warum auch nicht.
Ich würde aber z.B. die Schleifenvariable i nur als byte definieren. Braucht ja nur bis 55 gezählt zu werden.
Und du kannst die beiden Zeilen

pinMode(LeitungsEingang[i], INPUT);
digitalwrite(LeitungsEingang[i], HIGH);

Zu einer zusammenfassen:

pinMode(LeitungsEingang[i], INPUT_PULLUP);

3 geht so nicht. Was soll denn die 3 machen? Das Array auf null setzten?
Und Arrays fangen üblicherweise bei 0 an:

Dann würde ich das so machen:

  byte ZaehlerVariableLeitung[55]; 
  for(int i = 0; i < 55; i++) {
    pinMode(LeitungsEingang[i], INPUT_PULLUP); 
    ZaehlerVariableLeitung[i] = 0;
  }

Steh da gerade ein bisschen auf dem Schlauch.
Ich möchte gerne, dass alle Zählervariablen (1-54) auf 0 deklariert werden.
Wie müsste ich das Ändern?

Edit:
Es soll also eine einfache Variable sein, kein Pin.

Sowie oben. Es geht aber auch wesentlich einfacher:

const int size = 55;
byte zaehlerVariableLeitung[size];
memset(zaehlerVariableLeitung, 0, size);

memset() will du Anzahl der Bytes als 3. Parameter. Wenn das Array einen anderen Datentyp hätte, müsste man daher das machen:

const int size;
int zaehlerVariableLeitung[size];
memset(zaehlerVariableLeitung, 0, size * sizeof(int));

Außerdem eventuell beachten, dass globale Variablen - anders als lokale - auf Null initialisiert werden. Wenn das Array global ist, muss du es daher nicht in setup() initialisieren.

Das geht ja schneller wie die Polizei erlaubt hier. Fast ein Chat :wink:
Danke Leute !

So ich hefte das nochmal hier an. Hier ist mein Programm:

byte Leitung[54] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54}; // Leitungs-Array mit Pin-Werten
boolean ZaehlerVariableLeitung[54];

void setup()
{
  // Alle Pins des Arrays als Eingang und mit Pullup-widerstand auf HIGH gesetzt
  for(byte i = 1; i < 55; i++)
  pinMode(Leitung[i], INPUT_PULLUP);
  
  // Leitungsbezeichnungen (Ausgabe auf dem Display)
  char Leitung1[] = "";
  char Leitung2[] = "";
  char Leitung3[] = "";
  char Leitung4[] = "";
  char Leitung5[] = "";
  char Leitung6[] = "";
  char Leitung7[] = "";
  char Leitung8[] = "";
  char Leitung9[] = "";
  char Leitung10[] = "";
  char Leitung11[] = "";
  char Leitung12[] = "";
  char Leitung13[] = "";
  char Leitung14[] = "";
  char Leitung15[] = "";
  char Leitung16[] = "";
  char Leitung17[] = "";
  char Leitung18[] = "";
  char Leitung19[] = "";
  char Leitung20[] = "";
  char Leitung21[] = "";
  char Leitung22[] = "";
  char Leitung23[] = "";
  char Leitung24[] = "";
  char Leitung25[] = "";
  char Leitung26[] = "";
  char Leitung27[] = "";
  char Leitung28[] = "";
  char Leitung29[] = "";
  char Leitung30[] = "";
  char Leitung31[] = "";
  char Leitung32[] = "";
  char Leitung33[] = "";
  char Leitung34[] = "";
  char Leitung35[] = "";
  char Leitung36[] = "";
  char Leitung37[] = "";
  char Leitung38[] = "";
  char Leitung39[] = "";
  char Leitung40[] = "";
  char Leitung41[] = "";
  char Leitung42[] = "";
  char Leitung43[] = "";
  char Leitung44[] = "";
  char Leitung45[] = "";
  char Leitung46[] = "";
  char Leitung47[] = "";
  char Leitung48[] = "";
  char Leitung49[] = "";
  char Leitung50[] = "";
  char Leitung51[] = "";
  char Leitung52[] = "";
  char Leitung53[] = "";
  char Leitung54[] = "";
  
  // Zählhilfsvariablen deklarieren und mit 0 initialisieren (damit pro Leitung nur 1x gezählt wird)
  for(byte i = 0; i < 55; i++)
  ZaehlerVariableLeitung[i] = 0;
}


void loop()
{
  if (digitalRead(Leitung1)=1 && ZaehlerVariableLeitung1=0)
    ZaehlerVariableLeitung1=1;
    
    if (digitalRead(Leitung2)=1 && ZaehlerVariableLeitung2=0)
    ZaehlerVariableLeitung1=1;
}

Noch nicht fertig, hab nur mal überprüft.
Jetzt habe ich doch die Variablen deklariert oder nicht?
Ich bekomme diese Fehler bei der Überprüfung angezeigt:

TobiV1.cpp: In function ‘void loop()’:
TobiV1.cpp:77:19: error: ‘Leitung1’ was not declared in this scope
TobiV1.cpp:77:34: error: ‘ZaehlerVariableLeitung1’ was not declared in this scope
TobiV1.cpp:80:21: error: ‘Leitung2’ was not declared in this scope
TobiV1.cpp:80:36: error: ‘ZaehlerVariableLeitung2’ was not declared in this scope
TobiV1.cpp:81:5: error: ‘ZaehlerVariableLeitung1’ was not declared in this scope

Die Strings sind später für die Anzeige auf dem LCD da.
Aber was ist da falsch?

Nein. Du benutzt da Variablen ohne Deklaration.

Und nicht-dynamische Arrays solltest du dir noch mal generell ansehen. Die Größe von Arrays muss bei C zur Compile-Zeit fest stehen! Wenn du das machst:
char Leitung1[] = "";

Ist das ein Array 1 groß. Und kann nie(!) größer werden. Du kannst da nie einen größeren string rein kopieren. Du musst ein char Array groß genug für den größten String + 1 machen (wegen dem Null-Terminator). Also:
char Leitung1[5] = "";
Für 4 Zeichen

Das geht aber nicht:

char Leitung1[5] = "";
Leitung 1 = "test"

Sondern so:

char Leitung1[5] = "";
strcpy(Leitung1, "test");

Es gibt übrigens auch String Arrays. Sind einfach zwei-dimensionale Arrays aus char:
char stringArray[50][11];
-> 50 Strings mit 10 Zeichen

Aber überlege dir mal ob das nicht anders geht. So bekommst du nämliche schnell Probleme mit dem RAM wenn die strings eine gewisse Länge haben. Wie lang sollen die strings werden? Müssen die wirklich alle dauerhaft abgespeichert werden?

Geht nicht sowas in der Richtung?

lcd.print("Leitung: ");
lcd.print(leitungsNummer);

Wobei der Mega mit seinen 8kB da noch geht wenn du sonst nichts RAM-intensives machst. 50 Strings mit 10 Zeichen hätten 550 Byte.

Und Arrays fangen generell bei Index 0 an! Nicht mit 1. Ein Array der Größe 54 hat die Indices 0 bis 53.

Damit bist du in ungültigem Speicher:
for(byte i = 1; i < 55; i++)

Lege dir am besten eine const Variable für die Größe an. Dann macht man da weniger Fehler:

const int size = 54;
byte ZaehlerVariableLeitung[size] 
for(int i = 0; i < size; i++)
  ZaehlerVariableLeitung[i] = 0

Wobei du in diesem Fall ZaehlerVariableLeitung[] wie gesagt nicht in setup() beschreiben musst. Das Array ist global deklariert und wird daher automatisch mit 0 initialisiert. Lokale Variablen sind was anderes.

Noch ein Fehler:
Die Strings sind in setup() deklariert und auch nur dort sichtbar:

Bezüglich der Strings habe ich mich hier dran gehalten:
-> http://arduino.cc/de/Reference/String
In diese Strings kommen nachher die Leitungsfarben. /Beispiel gr/ge
Wurden hier aber noch nicht eingetragen.

Nachher soll es so laufen, dass man sich eine beliebige Leitung nimmt und gegen Masse hält. Der Arduino soll dann den Leitungsfarbcode anzeigen und den Zähler um 1 hochgehen lassen.
Damit man nicht versehentlich 2 x die selbe Leitung zählen lassen kann, darf der Zähler nur 1 mal pro Leitung hochzählen.
Letztendlich soll das nachher so auf dem Display aussehen:


|Leitungsnummer Leitungszähler|
| Leitungsfarbcode |


Der Leitungsfarbcode soll schnell geändert werden können.
Das ganze soll nachher ein Prüfadapter für verschiedene Kabel werden.

Sehe auch gerade einen Fehler. Ich habe die Pins genauso benannt wie die Strings. Das ist natürlich blöd.
Das kommt, wenn man immer so hibbelig da ran geht :wink:
Und die Strings sollte ich dann auch ganz oben über void setup () deklarieren, oder unter void loop() in der Hauptschleife?
Vielen Dank für die Hilfe, ich kann es nicht oft genug wiederholen!

So ähnlich habe ich während dem Studium mal ein Kabelmessgerät für jemanden entwickelt. Der auch noch Widerstände im Kabel messen wollte. Atmega32 und zwei 32-Pin Analog-Multiplexer um jede Leitung mit jeder anderen Leitung zu verbinden...

C-Strings (char Arrays) sind hier etwas ausführlicher erklärt (auch mit Funktionen zur Manipulation):

(Menü rechts und unten mit dem Pfeil weiter)

Generell brauchst du halt eine Größe. Man kann das machen:
char str[ ] = "arduino";

Dann nimmt der Compiler die Größe aus dem Literal auf der rechten Seite. Aber wenn du das machst:
char str[ ] = "";
Ist das ein leerer String + NULL. Das Array ist also 1 groß. Du musst daher die Größe in den eckigen Klammern angeben wenn du es erst später mit strcpy() oder sprintf() beschreibst:
http://www.cplusplus.com/reference/cstdio/sprintf/

Und die Strings sollte ich dann auch ganz oben über void setup () deklarieren, oder unter void loop() in der Hauptschleife?

Oben. Das ist dann eine globale Variable. Und die wird automatisch auf 0 initialisiert und ist für alle Funktionen sichtbar.

Ich empfehle dir da wie gesagt ein zwei-dimensionales Array. Wesentlich einfacher als 50 Variablen:
char stringArray[50][11];
Größe nach Bedarf anpassen

Und wenn du for-schleifen hast wie gesagt die Größe in einem const int speichern:
const int stringAnzahl = 50;
const int stringLaenge = 11; //inklusive NULL Terminator
Und dann die Variable in die eckigen Klammer schreiben und auf (i < stringAnzahl) abfragen

Ich habe mein Post vorhin nochmal editiert. Lies es vielleicht nochmal durch, wenn du das noch nicht gesehen hast. Vor allem den Teil mit den Array Indices!

Habe jetzt das Programm überarbeitet. Die Deklarationen sind jetzt über der viod setup ()
Allerdings kommt immer noch die Fehlermeldung?
Hier nochmal das Programm.

// Leitungs-Array mit Pin-Werten
byte Leitung[54] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53};

// Anzahl der Kabel für die Schleifen
const byte KabelMenge = 54;

// Zählervariablen deklarieren zwecks einmaligem hochzählen pro Leitung
boolean ZaehlerVariableLeitung[54];

// Leitungsfarbcodes für die Ausgabe auf dem LCD
char FarbcodeLeitung1[] = "";
char FarbcodeLeitung2[] = "";
char FarbcodeLeitung3[] = "";
char FarbcodeLeitung4[] = "";
char FarbcodeLeitung5[] = "";
char FarbcodeLeitung6[] = "";
char FarbcodeLeitung7[] = "";
char FarbcodeLeitung8[] = "";
char FarbcodeLeitung9[] = "";
char FarbcodeLeitung10[] = "";
char FarbcodeLeitung11[] = "";
char FarbcodeLeitung12[] = "";
char FarbcodeLeitung13[] = "";
char FarbcodeLeitung14[] = "";
char FarbcodeLeitung15[] = "";
char FarbcodeLeitung16[] = "";
char FarbcodeLeitung17[] = "";
char FarbcodeLeitung18[] = "";
char FarbcodeLeitung19[] = "";
char FarbcodeLeitung20[] = "";
char FarbcodeLeitung21[] = "";
char FarbcodeLeitung22[] = "";
char FarbcodeLeitung23[] = "";
char FarbcodeLeitung24[] = "";
char FarbcodeLeitung25[] = "";
char FarbcodeLeitung26[] = "";
char FarbcodeLeitung27[] = "";
char FarbcodeLeitung28[] = "";
char FarbcodeLeitung29[] = "";
char FarbcodeLeitung30[] = "";
char FarbcodeLeitung31[] = "";
char FarbcodeLeitung32[] = "";
char FarbcodeLeitung33[] = "";
char FarbcodeLeitung34[] = "";
char FarbcodeLeitung35[] = "";
char FarbcodeLeitung36[] = "";
char FarbcodeLeitung37[] = "";
char FarbcodeLeitung38[] = "";
char FarbcodeLeitung39[] = "";
char FarbcodeLeitung40[] = "";
char FarbcodeLeitung41[] = "";
char FarbcodeLeitung42[] = "";
char FarbcodeLeitung43[] = "";
char FarbcodeLeitung44[] = "";
char FarbcodeLeitung45[] = "";
char FarbcodeLeitung46[] = "";
char FarbcodeLeitung47[] = "";
char FarbcodeLeitung48[] = "";
char FarbcodeLeitung49[] = "";
char FarbcodeLeitung50[] = "";
char FarbcodeLeitung51[] = "";
char FarbcodeLeitung52[] = "";
char FarbcodeLeitung53[] = "";
char FarbcodeLeitung54[] = "";
  
// Leitungsbezeichnung für die Ausgabe auf dem LCD
char BezeichnungLeitung1[] = "";
char BezeichnungLeitung2[] = "";
char BezeichnungLeitung3[] = "";
char BezeichnungLeitung4[] = "";
char BezeichnungLeitung5[] = "";
char BezeichnungLeitung6[] = "";
char BezeichnungLeitung7[] = "";
char BezeichnungLeitung8[] = "";
char BezeichnungLeitung9[] = "";
char BezeichnungLeitung10[] = "";
char BezeichnungLeitung11[] = "";
char BezeichnungLeitung12[] = "";
char BezeichnungLeitung13[] = "";
char BezeichnungLeitung14[] = "";
char BezeichnungLeitung15[] = "";
char BezeichnungLeitung16[] = "";
char BezeichnungLeitung17[] = "";
char BezeichnungLeitung18[] = "";
char BezeichnungLeitung19[] = "";
char BezeichnungLeitung20[] = "";
char BezeichnungLeitung21[] = "";
char BezeichnungLeitung22[] = "";
char BezeichnungLeitung23[] = "";
char BezeichnungLeitung24[] = "";
char BezeichnungLeitung25[] = "";
char BezeichnungLeitung26[] = "";
char BezeichnungLeitung27[] = "";
char BezeichnungLeitung28[] = "";
char BezeichnungLeitung29[] = "";
char BezeichnungLeitung30[] = "";
char BezeichnungLeitung31[] = "";
char BezeichnungLeitung32[] = "";
char BezeichnungLeitung33[] = "";
char BezeichnungLeitung34[] = "";
char BezeichnungLeitung35[] = "";
char BezeichnungLeitung36[] = "";
char BezeichnungLeitung37[] = "";
char BezeichnungLeitung38[] = "";
char BezeichnungLeitung39[] = "";
char BezeichnungLeitung40[] = "";
char BezeichnungLeitung41[] = "";
char BezeichnungLeitung42[] = "";
char BezeichnungLeitung43[] = "";
char BezeichnungLeitung44[] = "";
char BezeichnungLeitung45[] = "";
char BezeichnungLeitung46[] = "";
char BezeichnungLeitung47[] = "";
char BezeichnungLeitung48[] = "";
char BezeichnungLeitung49[] = "";
char BezeichnungLeitung50[] = "";
char BezeichnungLeitung51[] = "";
char BezeichnungLeitung52[] = "";
char BezeichnungLeitung53[] = "";
char BezeichnungLeitung54[] = "";


void setup()
{
  // Alle Pins des Arrays als Eingang und mit Pullup-widerstand auf HIGH gesetzt
  for(byte i = 0; i < KabelMenge; i++)
  pinMode(Leitung[i], INPUT_PULLUP);  
}


void loop()
{
  if (!digitalRead(Leitung1) && ZaehlerVariableLeitung1==0)
    ZaehlerVariableLeitung1=1;
    
    if (!digitalRead(Leitung2) && ZaehlerVariableLeitung2==0)
    ZaehlerVariableLeitung1=1;
}

Ist auch noch der Farbcode hinzugekommen.
Hoffe jemand mag das nochmal anschauen.
Hier auch nochmal die Fehlermeldung:

TobiV1.cpp: In function ‘void loop()’:
TobiV1.cpp:134:20: error: ‘Leitung1’ was not declared in this scope
TobiV1.cpp:134:33: error: ‘ZaehlerVariableLeitung1’ was not declared in this scope
TobiV1.cpp:137:22: error: ‘Leitung2’ was not declared in this scope
TobiV1.cpp:137:35: error: ‘ZaehlerVariableLeitung2’ was not declared in this scope
TobiV1.cpp:138:5: error: ‘ZaehlerVariableLeitung1’ was not declared in this scope

Die Variablen sind immer noch nicht deklariert.

Wenn du das machst:
ZaehlerVariableLeitung1=1;

Musst du irgendwann mal das machen:
byte ZaehlerVariableLeitung1;

Da der Wert von einem Aufruf von loop() zum nächsten Erhalten werden muss, machst du das auch global.

Variablen Namen sollten übrigens mit Kleinbuchstaben anfangen. Das ist nicht zwingend nötig, hat sich aber als Konvention eingebürgert.

EDIT:
Du hast da jetzt ein bool Array:
boolean ZaehlerVariableLeitung[54];

Dann musst du aber in loop anders drauf zugreifen:
ZaehlerVariableLeitung[1] = true;

Das gleiche gilt für Leitung1. Das gibt es nicht. Was es gibt ist Leitung[1]. Aber auch hier die Array Indices beachten! Leitung Nummer 1 ist Leitung[0], da das Array mit 0 anfängt. Der höchste Index ist 53 für Leitung 54. Oder du passt gleich mal deine Nummerierung an und fängst mit 0 an. Das ist vielleicht weniger verwirrend.
/EDIT

Und deine char Arrays funktionieren so nicht! Selbst wenn das kompiliert, geht es nicht. Das Schlimme mit Arrays in C ist, dass du auch auf dem PC (und schon gar nicht embedded) keine expliziten Fehler bekommst wenn du über Array Grenzen schreibst. Die Größe muss daher unbedingt korrekt definiert sein.

Du musst da zwei-dimensionale Arrays draus machen:

const int anzahlStrings = 54;
const int stringLaenge = 11;   //anpassen auf sichtbare Zeichen +1

farbcodeLeitung[anzahlStrings][stringLaenge];
bezeichnungLeitung[anzahlStrings][stringLaenge];

Das ist ein Array aus Arrays, und da Strings char Arrays sind, ein Array aus Strings.

Schreibender Zugriff dann darauf mit strcopy() oder snprintf() für komplexere Formatierungen. Das ist bräuchtest du aber auch wenn du die Strings irrsinnigerweise so einzeln deklarierst.

z.B:

int i = 10;
char code[] = "gelb";
snprintf(farbcodeLeitung[i - 1], stringLaenge, "Farbcode von Leitung %d: %s", leitung, code);

Danach steht im String 10 (Index 9) das: "Farbcode von Leitung 10: gelb" (jedenfalls wenn stringLaenge ausreichend wäre)

Nur zur Veranschaulichung. Schon klar, dass das dann anders aussieht. Aber man kann so beliebig Text und Variablen kombinieren und in einer Anweisung in einen Puffer schreiben.

Aaaah jetzt ist der Groschen gefallen....tut mir leid, manchmal kann ich mich auch nicht genau genug ausdrücken.
Wie sollen denn die Variablen aussehen? So in etwa?
zAEHLERvARIABLElEITUNG[0] ?
Ich kannte das nur so wie ich es vorher hatte aus der Lehre, ist aber schon etwas her und kann sich geändert haben. In der Computerwelt benennt man ja auch Dateien so wie ich es gemacht habe. Eventuell die Wörter noch mit _ getrennt.
Die Char Strings sollen wie gesagt nicht so bleiben.
Das ist noch Vorschau :wink:
Hatte nur mal kurz mit einem geliehenen LCD gespielt und habe dann
char a[] = Moin Patsche
print(irgendwas) a
und er hat es korrekt ausgegeben.
Diese Vorgaben sind fest und werden nicht durch das Programm verändert.
Das Bedeutet ich trage bevor ich den Sketch kompiliere und übertrage alles zwischen den " " ein und diese Angaben bleiben auch konstant.
Als Beispiel (leider fällt mir der Befehl für das LCD nicht ein gerade):

if  (!digitalRead(Leitung[0]) && ZaehlerVariableLeitung[0]==false)
    ZaehlerVariableLeitung[0]=true;
    Zaehler ++ ;
    printf BezeichnungLeitung1 FarbcodeLeitung1 Zaehler

Oder geht das garnicht so?

Du fängst mit den Variablen mit einem Kleinbuchstaben an. Danach wird jedes weitere Wort am Anfang groß geschrieben. Nennt sich Camel Case:

z.B. diesIstEineStringVariable

Aber zum wichtigeren:
Erst mal musst du wenn du mit if() mehrere Zeilen ausführen willst, das in Code-Blöcke setzen:

if(....)
{ 
      ....
}

Ansonsten wird nur die erste Zeile danach konditional ausgeführt und die anderen immer. Das ist nicht gut.

Der korrekte Befehlt ist snprintf. Formatierung in einen Puffer. Verwendet aber die gleiche Syntax wie printf:
http://www.cplusplus.com/reference/cstdio/snprintf/
http://www.cplusplus.com/reference/cstdio/printf/

Printf schreibt auf den Standard Output. Das geht nur auf dem PC.

Auf dem LCD dann lcd.print(puffer) wie du es schon gesehen hast :slight_smile:

Du kannst auch einfach print() Anweisungen verketten

int i = 10;
lcd.print("Leitung: ");
lcd.print(i);

Ich hatte das halt erwähnt weil du leere Strings anlegst. Das geht natürlich, aber man kann die nicht einfach mit einer Zuweisung beschreiben:

leitung[i] = "String"

Geht nicht, da du keine Zeiger auf Literale machen kannst. Deshalb muss man den String mit einer Funktion kopieren.

Bei dir würde das glaube so ähnlich aussehen:

snprintf(bezeichnungLeitung[i], stringLaenge, "%s %d", farbcodeLeitung[i], zaehler);

%s = string
%d = decimal

Du musst halt irgendwie auf die Indizes kommen. Normalerweise hat man da dann for-Schleifen oder eine Zählvariable dafür.

Ich versteh nicht was du damit meinst.

Wenn es um die Namensvergabe geht, die bleibt dir völlig offen. Du kannst es auch mit meine_Var schreiben. Aber idR findet man die Variablennamen wie folgt meineVar. Jedes neue Wort startet mit einem Großbuchstaben zur Darstellung der Trennung.

Bzgl. des Codes, das sollte, wenn es sich um Variablen handelt so aussehen

lcd.print(BezeichnungLeitung1); lcd.print(FarbcodeLeitung1); lcd.print(Zaehler);

wenn es sich um feste Textkonstanten handelt, wird einfach (" ") gemacht.

Ich habe ja gesagt, dass es nicht zwingend ist (der Compiler schluckt alles mögliche) und, dass es weniger wichtig ist. Vor allem angesichts der anderen Probleme im Code :slight_smile:

Also erst mal auf die anderen Sachen konzentrieren. Danach kann man Verschönerung betreiben.

Ich muss mich wirklich nochmal bedanken.
Tatsächlich hatte ich es so vor, wie sschultewolter es geschrieben hat mit der LCD Ausgabe.
Mir fehlte zuerstmal der Anstoß dass ich jetzt Leitung[1] abfrage und nicht Leitung1 ohne [].
Da fehlte mir mein Wissen.
Der Hinweis zu dem Camel_Case kam auch genau richtig. Wenn dann will ich es auch nach neusten Konventionen schreiben.
So gewöhnt man sich gleich den standardAn :slight_smile:
Ihr und vorallem Serenifly habt mir den Tag gerettet.
So ein E-Workshop macht doch immer laune.
Wenn man dann noch fachkundige Menschen in einem Forum vorfindet, denen es auch Spaß macht zu helfen, dann ist die Welt noch in Ordnung.
Ich handhabe es auch so, dass ich hinsichtlich Linux(Debian) viele Wiki-Artikel schreibe um anderen Menschen zu helfen von closed-ware weg zu kommen.
Aber das soll jetzt nicht zum Gefühlsthread konvertieren hier :wink:
Super Forum, tolle Leute. Danke!

Eine Frage fällt mir heute Abend doch noch ein:
Ist das Möglich?

char farbcodeLeitung1[] = ""    bezeichnungLeitung1[] = "";

Dann wäre es noch übersichtlicher...
Oder sollte man das lieber untereinander machen?
So wäre der Vorteil, dass eine Leitungsänderung innerhalb einer Zeile geändert werden könnte, wenn sich da im Verlauf der Kabelentwicklung was tut?

Das Problem dabei ist wie willst du die ansprechen?

Willst du 50 mal sowas schreiben:

if(variable == 1)
    farbcodeLeitung1...
else if(variable == 2)
    farbcodeLeitung2...
else if(variable == 3)
    farbcodeLeitung3...

Arrays (in diesem Fall Arrays von Arrays) verwendet man da, weil man mit einem Index leicht darauf zugreifen kann.

Du kannst dann sowas machen

for(int i =0; i < arrayAnzahl; i++)
{
       if(...)
           farbcodeLeitung[i]....
}

Das gleiche mit Lese-Zugriff falls da nur Konstanten drinstehen. Mit einem String Array kannst du einfach eine Konstante aus dem Array picken und woanders hinschreiben. Und du kannst mit dem gleichen Code auf Index 5 zugreifen wie auf Index 0. Ansonsten hast du für jeden String einen Variablen-Namen und der String kann nur über diesen angesprochen werden.

String Array aus Konstanten geht so:

char stringArray[][6] =
{
    "blau",
    "gruen",
    "rot"
};

Die zweite Dimension muss dann groß genug für den größten String + 1 sein. Die erste Dimension wird automatisch aus der Anzahl der Strings in den Intialisierungs-Klammern bestimmt. Wobei das genaugenommen keine Konstanten sind. Man kann immer noch auf den String schreiben. Aber die Werte sind halt vorgegeben.

Hier nochmal mein jetziger Code:

// Zur Benennung der Variablen wurde die Camel-Case-Konvention verwendet

// Anzahl der Kabel für die Schleifen
const byte kabelMenge = 50;

// Leitungs-Array mit Pin-Werten
byte leitung[kabelMenge] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49};

// Zählervariablen deklarieren zwecks einmaligem hochzählen pro Leitung
boolean zaehlerVariableLeitung[kabelMenge];

// Deklaration des Zählers für das LCD
byte zaehler ;

// Leitungskennzeichnung für das LCD (Farbe, Kennzeichnung)
char farbcodeLeitung1[] = ""   ,   bezeichnungLeitung1[] = "";
char farbcodeLeitung2[] = ""   ,   bezeichnungLeitung2[] = "";
char farbcodeLeitung3[] = ""   ,   bezeichnungLeitung3[] = "";
char farbcodeLeitung4[] = ""   ,   bezeichnungLeitung4[] = "";
char farbcodeLeitung5[] = ""   ,   bezeichnungLeitung5[] = "";
char farbcodeLeitung6[] = ""   ,   bezeichnungLeitung6[] = "";
char farbcodeLeitung7[] = ""   ,   bezeichnungLeitung7[] = "";
char farbcodeLeitung8[] = ""   ,   bezeichnungLeitung8[] = "";
char farbcodeLeitung9[] = ""   ,   bezeichnungLeitung9[] = "";
char farbcodeLeitung10[] = ""  ,   bezeichnungLeitung10[] = "";
char farbcodeLeitung11[] = ""  ,   bezeichnungLeitung11[] = "";
char farbcodeLeitung12[] = ""  ,   bezeichnungLeitung12[] = "";
char farbcodeLeitung13[] = ""  ,   bezeichnungLeitung13[] = "";
char farbcodeLeitung14[] = ""  ,   bezeichnungLeitung14[] = "";
char farbcodeLeitung15[] = ""  ,   bezeichnungLeitung15[] = "";
char farbcodeLeitung16[] = ""  ,   bezeichnungLeitung16[] = "";
char farbcodeLeitung17[] = ""  ,   bezeichnungLeitung17[] = "";
char farbcodeLeitung18[] = ""  ,   bezeichnungLeitung18[] = "";
char farbcodeLeitung19[] = ""  ,   bezeichnungLeitung19[] = "";
char farbcodeLeitung20[] = ""  ,   bezeichnungLeitung20[] = "";
char farbcodeLeitung21[] = ""  ,   bezeichnungLeitung21[] = "";
char farbcodeLeitung22[] = ""  ,   bezeichnungLeitung22[] = "";
char farbcodeLeitung23[] = ""  ,   bezeichnungLeitung23[] = "";
char farbcodeLeitung24[] = ""  ,   bezeichnungLeitung24[] = "";
char farbcodeLeitung25[] = ""  ,   bezeichnungLeitung25[] = "";
char farbcodeLeitung26[] = ""  ,   bezeichnungLeitung26[] = "";
char farbcodeLeitung27[] = ""  ,   bezeichnungLeitung27[] = "";
char farbcodeLeitung28[] = ""  ,   bezeichnungLeitung28[] = "";
char farbcodeLeitung29[] = ""  ,   bezeichnungLeitung29[] = "";
char farbcodeLeitung30[] = ""  ,   bezeichnungLeitung30[] = "";
char farbcodeLeitung31[] = ""  ,   bezeichnungLeitung31[] = "";
char farbcodeLeitung32[] = ""  ,   bezeichnungLeitung32[] = "";
char farbcodeLeitung33[] = ""  ,   bezeichnungLeitung33[] = "";
char farbcodeLeitung34[] = ""  ,   bezeichnungLeitung34[] = "";
char farbcodeLeitung35[] = ""  ,   bezeichnungLeitung35[] = "";
char farbcodeLeitung36[] = ""  ,   bezeichnungLeitung36[] = "";
char farbcodeLeitung37[] = ""  ,   bezeichnungLeitung37[] = "";
char farbcodeLeitung38[] = ""  ,   bezeichnungLeitung38[] = "";
char farbcodeLeitung39[] = ""  ,   bezeichnungLeitung39[] = "";
char farbcodeLeitung40[] = ""  ,   bezeichnungLeitung40[] = "";
char farbcodeLeitung41[] = ""  ,   bezeichnungLeitung41[] = "";
char farbcodeLeitung42[] = ""  ,   bezeichnungLeitung42[] = "";
char farbcodeLeitung43[] = ""  ,   bezeichnungLeitung43[] = "";
char farbcodeLeitung44[] = ""  ,   bezeichnungLeitung44[] = "";
char farbcodeLeitung45[] = ""  ,   bezeichnungLeitung45[] = "";
char farbcodeLeitung46[] = ""  ,   bezeichnungLeitung46[] = "";
char farbcodeLeitung47[] = ""  ,   bezeichnungLeitung47[] = "";
char farbcodeLeitung48[] = ""  ,   bezeichnungLeitung48[] = "";
char farbcodeLeitung49[] = ""  ,   bezeichnungLeitung49[] = "";
char farbcodeLeitung50[] = ""  ,   bezeichnungLeitung50[] = "";
  

void setup()
{
  // Alle Pins des Arrays als Eingang und mit Pullup-Widerstand auf HIGH gesetzt
  for(byte i = 0; i < kabelMenge; i++)
  pinMode(leitung[i], INPUT_PULLUP);   
}  


void loop()
{
  if (!digitalRead(leitung[0]) && zaehlerVariableLeitung[0]==false)
      {
        zaehlerVariableLeitung[0]=true;
        zaehler ++;
        lcd.print ("1"); lcd.print(bezeichnungLeitung1); lcd.print(farbcodeLeitung1); lcd.print(zaehler); 
      }
    
   if (!digitalRead(leitung[1]) && zaehlerVariableLeitung[1]==false)
      {
        zaehlerVariableLeitung[1]=true;
        zaehler ++;
        lcd.print ("2"); lcd.print(bezeichnungLeitung2); lcd.print(farbcodeLeitung2); lcd.print(zaehler);
      }
  
    if (!digitalRead(leitung[2]) && zaehlerVariableLeitung[2]==false)
      {
        zaehlerVariableLeitung[2]=true;
        zaehler ++;
        lcd.print ("3"); lcd.print(bezeichnungLeitung3); lcd.print(farbcodeLeitung3); lcd.print(zaehler);
      }
}

So in der Art wollte ich das machen...für jemanden der viel programmiert wirkt das vielleicht lächerlich, aber es sollte doch so funktionieren....