Wie kann ich im initialisierungsvorgang aus verschiedenen Arrays auswählen?

Hallo Community,
ich grübel nun schon einige Zeit auf einem Problem herum.
Ich arbeite mit einigen Freunden an einem Projekt für einen Softdart Controller. Um die Matrix des Controllers auszuwerten wird ein Array benutzt:

const byte numRows = 4;
const byte numCols = 16;

const int keymap[numRows][numCols] = {
  {202, 102, 215, 115, 210, 110, 206, 106, 213, 113, 125, 302, 315, 310, 306, 313},
  {204, 104, 218, 118, 201, 101, 220, 120, 205, 105, 998, 304, 318, 301, 320, 305},
  {212, 112, 209, 109, 214, 114, 211, 111, 208, 108, 999, 312, 309, 314, 311, 308},
  {216, 116, 207, 107, 219, 119, 203, 103, 217, 117, 225, 316, 307, 319, 303, 317}
};

int rowPins[numRows] = {4, 2, 31, 29}; // Pin 19, 20, 1, 2
int colPins[numCols] = {27, 25, 23, 22, 17, 16, 15, 12, 11, 9, 7, 5, 3, 10, 8, 6}; // Pin 3 bis 18

nun habe ich das Problem, das es verschiede Arten von Dart-Matrixen gibt, die unterschiedlich ausgewertet werden. (Derzeit 13 Verschieden Versionen)

Ist es möglich, hier eine Variable Matrix zu erstellen ?
Die Arrays sind teilweise 16x4 und teilweise 8x8

Im habe bisher eine Abfrage geschrieben, in der über den Seriellen Monitor per Befehl eine Zahl (1-13) ins Rom Eeprom geschrieben wird. Diese Zahl möchte ich gerne Nutzen, um irgendwie die jeweilige Matrix auswerten zu können.

Ich hoffe, ich konnte mein Problem hier vernünftig schildern.

Danke schon einmal vorab für die Unterstützung.

Um es mal so knapp zu antworten wie du das Projekt beschreibst.
"ja das geht"

Diese drei dürren Worte helfen dir aber überhaupt nicht weiter.
Noch zu wenig Details. Es ist unklar ob du jetzt einen Universalcontroller bauen möchtest der an verschiedene Dartscheiben angeschlossen werden soll und sich dann die hardware-Verdrahtung unterscheidet und einmal 16x4 und mal 8x8 ist.

Oder ob die hardware-Verdrahtung immer gleich ist und nur die Feldunterteilung einmal
16x4 oder 8x8 ist.

Gibt es nur diese beiden Fälle oder noch weitere?
Bei zwei Fällen würde ich zwei functions
setupIO_Pins16x4
setupIO_Pins8x8

sowie zwei functions
scan16x4Matrix
scan8x8Matrix

programmieren.

Dann muss es irgendwie eine Auswahlmöglichkeit geben mit der in der function setup
eingestellt wird welche functions aufgerufen werden.

Wenn es mehr Varianten sind, dann lohnt es sich die Definitionen der Matrixen auch in Arrays zu definieren und dann abhängig von diesen Definitionen die IO-Pins auf Ausgang / Eingang zu schalten und auch den Code wie jetzt Ausgänge LOW/HIGH geschaltet werden müssen und welche IO-pins dann als Eingänge abgefragt werden müsen um die Matrix zu scannen.

vgs
vgs

@StefanL38 Die Pins sind jedsmal die selben, nur die Abfrage der Pins findet unterschiedlich statt.
hier mal die unterschiedlichen Varianten der Arays:

//MatrixConverter_v2.0.13_HW_v2.x_Cyberdine_Novomatic_1_gvul
const byte numRows = 8;
const byte numCols = 8;

const int keymap[numRows][numCols] = {
  {115, 117, 119, 116, 111, 109, 105, 101},
  {213, 999, 125, 113, 313, 104, 304, 204},
  {206, 225, 998, 106, 306, 118, 318, 218},
  {210, 202, 203, 207, 208, 214, 212, 220},
  {215, 217, 219, 216, 211, 209, 205, 201},
  {110, 102, 103, 107, 108, 114, 112, 120},
  {310, 302, 303, 307, 308, 314, 312, 320},
  {315, 317, 319, 316, 311, 309, 305, 301}
};

int rowPins[numRows] = {31, 29, 27, 25, 23, 22, 19, 17}; // Pin 1 bis 8
int colPins[numCols] = {15, 12, 11, 9, 7, 5, 3, 10}; // Pin 9 bis 16


//MatrixConverter_v2.0.13_HW_v2.x_Cyberdine_Novomatic_1_vul
const byte numRows = 8;
const byte numCols = 8;

const int keymap[numRows][numCols] = {
  {115, 117, 119, 116, 111, 109, 105, 101},
  {213, 999, 125, 113, 313, 104, 304, 204},
  {206, 225, 998, 106, 306, 118, 318, 218},
  {210, 202, 203, 207, 208, 214, 212, 220},
  {215, 217, 219, 216, 211, 209, 205, 201},
  {110, 102, 103, 107, 108, 114, 112, 120},
  {310, 302, 303, 307, 308, 314, 312, 320},
  {315, 317, 319, 316, 311, 309, 305, 301}
};

int rowPins[numRows] = {10, 3, 5, 7, 9, 11, 12, 15}; // Pin 1 bis 8
int colPins[numCols] = {17, 19, 22, 23, 25, 27, 29, 31}; // Pin 9 bis 16


//MatrixConverter_v2.0.13_HW_v2.x_GranBoard_62map_1_vul
const byte numRows = 7;
const byte numCols = 12;

const int keymap[numRows][numCols] = {
  {113, 106, 110, 115, 112, 125, 302, 317, 303, 319, 116, 225},
  {104, 306, 310, 315, 105, 996, 102, 117, 103, 119, 107, 997},
  {313, 118, 110, 115, 305, 202, 102, 117, 103, 108, 307, 215},
  {304, 106, 101, 120, 312, 217, 109, 114, 111, 119, 316, 210},
  {113, 318, 301, 320, 105, 203, 309, 314, 311, 308, 107, 206},
  {104, 118, 101, 120, 112, 219, 109, 114, 111, 108, 116, 213},
  {204, 218, 201, 220, 212, 207, 209, 214, 211, 208, 216, 205}
};

int rowPins[numRows] = {31, 29, 27, 25, 23, 22, 19}; // Pin Pin 1, 2, 3, 4, 5, 6, 7
int colPins[numCols] = {17, 15, 12, 11, 7, 5, 3, 10, 8, 6, 4, 9}; // Pin 1, 2, 3, 4, 6, 7, 8, 9, 10, 11, 12, 5


//MatrixConverter_v2.0.13_HW_v2.x_HiDarts_1_gvum
const byte numRows = 4;
const byte numCols = 16;

const int keymap[numRows][numCols] = {
  {202, 102, 215, 115, 210, 110, 206, 106, 213, 113, 125, 302, 315, 310, 306, 313},
  {204, 104, 218, 118, 201, 101, 220, 120, 205, 105, 998, 304, 318, 301, 320, 305},
  {212, 112, 209, 109, 214, 114, 211, 111, 208, 108, 999, 312, 309, 314, 311, 308},
  {216, 116, 207, 107, 219, 119, 203, 103, 217, 117, 225, 316, 307, 319, 303, 317}
};

int rowPins[numRows] = {29, 31, 2, 4}; // Pin 19, 20, 1, 2
int colPins[numCols] = {6, 8, 10, 3, 5, 7, 9, 11, 12, 15, 17, 19, 22, 23, 25, 27}; // Pin 3 bis 18


//MatrixConverter_v2.0.13_HW_v2.x_Loewen_Compumatic_1_gvul
const byte numRows = 4;
const byte numCols = 16;

const int keymap[numRows][numCols] = {
  {202, 102, 215, 115, 210, 110, 206, 106, 213, 113, 125, 302, 315, 310, 306, 313},
  {204, 104, 218, 118, 201, 101, 220, 120, 205, 105, 998, 304, 318, 301, 320, 305},
  {212, 112, 209, 109, 214, 114, 211, 111, 208, 108, 999, 312, 309, 314, 311, 308},
  {216, 116, 207, 107, 219, 119, 203, 103, 217, 117, 225, 316, 307, 319, 303, 317}
};

int rowPins[numRows] = {29, 31, 2, 4}; // Pin 19, 20, 1, 2
int colPins[numCols] = {6, 8, 10, 3, 5, 7, 9, 11, 12, 15, 17, 19, 22, 23, 25, 27}; // Pin 3 bis 18


//MatrixConverter_v2.0.13_HW_v2.x_Loewen_Compumatic_1_vul
const byte numRows = 4;
const byte numCols = 16;

const int keymap[numRows][numCols] = {
  {202, 102, 215, 115, 210, 110, 206, 106, 213, 113, 125, 302, 315, 310, 306, 313},
  {204, 104, 218, 118, 201, 101, 220, 120, 205, 105, 998, 304, 318, 301, 320, 305},
  {212, 112, 209, 109, 214, 114, 211, 111, 208, 108, 999, 312, 309, 314, 311, 308},
  {216, 116, 207, 107, 219, 119, 203, 103, 217, 117, 225, 316, 307, 319, 303, 317}
};

int rowPins[numRows] = {4, 2, 31, 29}; // Pin 19, 20, 1, 2
int colPins[numCols] = {27, 25, 23, 22, 19, 17, 15, 12, 11, 9, 7, 5, 3, 10, 8, 6}; // Pin 3 bis 18


//MatrixConverter_v2.0.13_HW_v2.x_Loewen_Compumatic_2_gvlo
const byte numRows = 4;
const byte numCols = 16;

const int keymap[numRows][numCols] = {
  {216, 116, 207, 107, 219, 119, 203, 103, 217, 117, 125, 316, 307, 319, 303, 317},
  {202, 102, 215, 115, 210, 110, 206, 106, 213, 113, 999, 302, 315, 310, 306, 313},
  {204, 104, 218, 118, 201, 101, 220, 120, 205, 105, 998, 304, 318, 301, 320, 305},
  {212, 112, 209, 109, 214, 114, 211, 111, 208, 108, 225, 312, 309, 314, 311, 308}
};

int rowPins[numRows] = {29, 31, 2, 4}; // Pin 19, 20, 1, 2
int colPins[numCols] = {6, 8, 10, 3, 5, 7, 9, 11, 12, 15, 17, 19, 22, 23, 25, 27}; // Pin 3 bis 18


//MatrixConverter_v2.0.13_HW_v2.x_Loewen_Compumatic_2_vlo
const byte numRows = 4;
const byte numCols = 16;

const int keymap[numRows][numCols] = {
  {216, 116, 207, 107, 219, 119, 203, 103, 217, 117, 125, 316, 307, 319, 303, 317},
  {202, 102, 215, 115, 210, 110, 206, 106, 213, 113, 999, 302, 315, 310, 306, 313},
  {204, 104, 218, 118, 201, 101, 220, 120, 205, 105, 998, 304, 318, 301, 320, 305},
  {212, 112, 209, 109, 214, 114, 211, 111, 208, 108, 225, 312, 309, 314, 311, 308}
};

int rowPins[numRows] = {4, 2, 31, 29}; // Pin 19, 20, 1, 2
int colPins[numCols] = {27, 25, 23, 22, 19, 17, 15, 12, 11, 9, 7, 5, 3, 10, 8, 6}; // Pin 3 bis 18


//MatrixConverter_v2.0.13_HW_v2.x_Loewen_Compumatic_3_gvor
const byte numRows = 4;
const byte numCols = 16;

const int keymap[numRows][numCols] = {
  {212, 112, 209, 109, 214, 114, 211, 111, 208, 108, 125, 312, 309, 314, 311, 308},
  {216, 116, 207, 107, 219, 119, 203, 103, 217, 117, 998, 316, 307, 319, 303, 317},
  {202, 102, 215, 115, 210, 110, 206, 106, 213, 113, 999, 302, 315, 310, 306, 313},
  {204, 104, 218, 118, 201, 101, 220, 120, 205, 105, 225, 304, 318, 301, 320, 305}
};


//MatrixConverter_v2.0.13_HW_v2.x_Loewen_Compumatic_3_vor
const byte numRows = 4;
const byte numCols = 16;

const int keymap[numRows][numCols] = {
  {212, 112, 209, 109, 214, 114, 211, 111, 208, 108, 125, 312, 309, 314, 311, 308},
  {216, 116, 207, 107, 219, 119, 203, 103, 217, 117, 998, 316, 307, 319, 303, 317},
  {202, 102, 215, 115, 210, 110, 206, 106, 213, 113, 999, 302, 315, 310, 306, 313},
  {204, 104, 218, 118, 201, 101, 220, 120, 205, 105, 225, 304, 318, 301, 320, 305}
};

int rowPins[numRows] = {4, 2, 31, 29}; // Pin 19, 20, 1, 2
int colPins[numCols] = {27, 25, 23, 22, 19, 17, 15, 12, 11, 9, 7, 5, 3, 10, 8, 6}; // Pin 3 bis 18


//MatrixConverter_v2.0.13_HW_v2.x_Loewen_Compumatic_4_gvru
const byte numRows = 4;
const byte numCols = 16;

const int keymap[numRows][numCols] = {
  {204, 104, 218, 118, 201, 101, 220, 120, 205, 105, 125, 304, 318, 301, 320, 305},
  {212, 112, 209, 109, 214, 114, 211, 111, 208, 108, 999, 312, 309, 314, 311, 308},
  {216, 116, 207, 107, 219, 119, 203, 103, 217, 117, 998, 316, 307, 319, 303, 317},
  {202, 102, 215, 115, 210, 110, 206, 106, 213, 113, 225, 302, 315, 310, 306, 313}
};

int rowPins[numRows] = {29, 31, 2, 4}; // Pin 19, 20, 1, 2
int colPins[numCols] = {6, 8, 10, 3, 5, 7, 9, 11, 12, 15, 17, 19, 22, 23, 25, 27}; // Pin 3 bis 18


//MatrixConverter_v2.0.13_HW_v2.x_Loewen_Compumatic_4_vru
const byte numRows = 4;
const byte numCols = 16;

const int keymap[numRows][numCols] = {
  {204, 104, 218, 118, 201, 101, 220, 120, 205, 105, 125, 304, 318, 301, 320, 305},
  {212, 112, 209, 109, 214, 114, 211, 111, 208, 108, 999, 312, 309, 314, 311, 308},
  {216, 116, 207, 107, 219, 119, 203, 103, 217, 117, 998, 316, 307, 319, 303, 317},
  {202, 102, 215, 115, 210, 110, 206, 106, 213, 113, 225, 302, 315, 310, 306, 313}
};

int rowPins[numRows] = {4, 2, 31, 29}; // Pin 19, 20, 1, 2
int colPins[numCols] = {27, 25, 23, 22, 19, 17, 15, 12, 11, 9, 7, 5, 3, 10, 8, 6}; // Pin 3 bis 18


//MatrixConverter_v2.0.13_HW_v2.x_Merkur_1_vul
const byte numRows = 4;
const byte numCols = 16;

const int keymap[numRows][numCols] = {
  {113, 213, 313, 106, 206, 306, 110, 210, 310, 115, 215, 315, 104, 204, 304, 998},
  {101, 201, 301, 120, 220, 320, 105, 205, 305, 112, 212, 312, 118, 218, 318, 125},
  {108, 208, 308, 111, 211, 311, 114, 214, 314, 109, 209, 309, 116, 216, 316, 999},
  {119, 219, 319, 103, 203, 303, 117, 217, 317, 102, 202, 302, 107, 207, 307, 225}
};

int rowPins[numRows] = {27, 25, 31, 29}; // Pin 3, 4, 1, 2
int colPins[numCols] = {23, 22, 19, 17, 15, 12, 11, 9, 7, 5, 3, 10, 8, 6, 4, 2}; // Pin 5 bis 20

diese werden wenn das Aray am Anfang definiert ist im folgenden so abgefragt:

int getKey() {
  int key = 0;
  for(int column = 0; column < numCols; column++) {
    digitalWrite(colPins[column],LOW);
    for(int row = 0; row < numRows; row++) {
      if(digitalRead(rowPins[row]) == LOW) {
        delay(intDebounceTime);
        key = keymap[row][column];
        Serial.print(F("MATRIXV1"));
        Serial.println(key);
        Serial1.print(F("MATRIXV1"));
        Serial1.println(key);

ich hoffe, das ich damit deine Fragen / Verständnisprobleme erklären konnte.

Die Auswahl der Matrix / Array soll einmalig am Anfang stattfinden und auf dem gespeicherten wert im Eeprom beruhen.
Also initial einmal auswählen, und dann in der Zukunft immer diese eine Matrix / Array nutzen.

nein.

Wenn ich das richtig analysiert habe dann gibt es drei verschiedene hardware-Verdrahtungen:

7x12 = 84
8x8 = 64
16x4 = 64

also entweder drei Sätze an functions
setupIO_Pins_7x12 und scanMatrix_7x12
int rowPins_7x12 [numRows_7x12] = ...
int colPins_7x12[numCols_7x12] = ....

setupIO_Pins_8x8 und scanMatrix_8x8
int rowPins_8x8 [numRows_8x8] = ...
int colPins_8x8[numCols_8x8] = ....

setupIO_Pins_16x4 und scanMatrix_16x4
int rowPins_16x4 [numRows_16x4] = ...
int colPins_16x4[numCols_16x4] = ....

oder du programmierst zweidimensionale arrays wo dann über die zweite Dimension die Auswahl der hardware-Verdrahtung stattfindet.

Dann muss aber die Anzahl Array-Elemente Row 16 und Columm 12 sein damit alle Varianten reinpassen.

Die Zuweisung der keymap-Werte würde ich dann durch das Übertragen der Zahlen aus dem const-array in einen variablen-array programmieren.

Egal welche Variante es wird, zum Testen ob alles richtig ausgewertet wird würde ich mir als Zahlen in dem keymap-array die Koordinaten des Array-Elements reinschreiben

const int keymap[numRows][numCols] = {
  {1001, 1002, 1003,...},
  {2001, 2002, 2003,...},
  {3001, 3002, 3003,...},
  {4001, 4002, 4003,...},
};

Dann sieht man sofort an der Zahl welches Array-Element das ist
3002 = dritte Reihe, zweite Spalte

oder wenn du das besser findest bei 0 beginnen.

evtl. macht es auch Sinn den Programmablauf mit kleineren Arrays zu testen
also 3x4, 5x6 wenn das Prinzip mit diesen Zahlen funktioniert kann man dann die Zahlen erhöhen. Da läuft ja dann nur die entsprechende Schleife bis zur größeren Zahl aber der prinzipielle Ablauf bleibt gleich

vgs

Wenn ich dich richtig verstehe,

die 3 Layouts - "Dart-Matrixen" sollten einmal aus dem EEPROM abegerufen werden können, aber dann zur Laufzeit verwendest du nur jeweils eine Matrix - bis zum nächstem Neustart (?) oder wie stellst du aktuell von einer Matrix auf die andere um?

Der Plan dahinter ist der, das der Controller jede Art von Matrix auswerten können soll, ohne das man für jede Matrix einen neuen Controller programmieren muss.
Die Auswahl der Matrix findet über einen Befehl (serieller Monitor) statt. Dieser hinterlegt dann einen Wert (1 - 13) im Eeprom.
Aufgrund dieses Wertes möchte ich es realisieren, das die ausgewählte Matrix ausgewertet werden kann.
ich habe es bereits versucht über if Abfragen, welche aber leider nicht im Initbereich des Programms funktionieren. wenn ich diese If Abfrage erst im Setup mache, bekomme ich Fehler, weil die Werte dann nicht (const byte, Const int, numRows, numCols ...) deklariert wurden.
Ich hatte auch schon überlegt ob sowas mit einer Library realisierbar wäre, leider bin ich nicht fit genug um sowas zu realisieren.

Hier einmal das komplette Programm wie es derzeit aussieht, mit der Möglichkeit die Matrixauswahl ins Eeprom zu schreiben. In diesem Code ist im ersten Bereich ein Array fest definiert. Um dieses geht es in meiner Frage, ob man hier das Array anders definieren kann bezogen auf die Auswahl des im Eeprom hinterlegten Wertes.

// EEPROM
#include <EEPROM.h>
int intSetDefaultAddr = 0;
int intEepromValueDefault = 0;
int intSetIrSensorThresholdAddr = 2;
int intEepromValueIrSensorThreshold = 500;
int intSetIrSensorEndDelayAddr = 4;
int intEepromValueIrSensorEndDelay = 1000;
int intSetPiezoThresholdAddr = 6;
int intEepromValuePiezoThreshold = 300;
int intSetDigitalIrAddr = 8;
int intEepromValueDigitalIr = 0;
int intSetMatrixTypeAddr = 10;
int intEepromValueMatrixType = 0;

//Version
char charVersion[] = "v2.0.14 Multimatrix (HW v2.1) by dart4fee.de";

// Zeit
unsigned long currentMillis = 0;

// Matrix
const byte numRows = 4;
const byte numCols = 16;
const int intDebounceTime = 20;
String MatrixType;


const int keymap[numRows][numCols] = {
  {202, 102, 215, 115, 210, 110, 206, 106, 213, 113, 125, 302, 315, 310, 306, 313},
  {204, 104, 218, 118, 201, 101, 220, 120, 205, 105, 998, 304, 318, 301, 320, 305},
  {212, 112, 209, 109, 214, 114, 211, 111, 208, 108, 999, 312, 309, 314, 311, 308},
  {216, 116, 207, 107, 219, 119, 203, 103, 217, 117, 225, 316, 307, 319, 303, 317}
};

int rowPins[numRows] = {4, 2, 31, 29}; // Pin 19, 20, 1, 2
int colPins[numCols] = {27, 25, 23, 22, 17, 16, 15, 12, 11, 9, 7, 5, 3, 10, 8, 6}; // Pin 3 bis 18

// Person
const int intSensorIR = A15;
const int intLoewenSensor = A1;

int intIrSensorThreshold = 0;
int intValueSensor = 0;
int intTempValueSensor = 0;
//int intValueSensorTemp = 0;
int intStateIrSensor = 0;
//int intStateSensor = 0;
int intPersonDetected = 0;
int intTestSensor = 0;

unsigned long sensorTimeStart = 0;
unsigned long sensorTimeEnd = 0;
unsigned long sensorTimeStartDelay = 200;
unsigned long sensorTimeEndDelay = 1000;

String stringValueIrSensorThreshold = "";
String stringValueIrSensorEndDelay = "";

// Fehlwurf
const int intPiezo1 = A13;
const int intPiezo2 = A14;

//int intThreshold =5;
int intPiezoThreshold = intEepromValuePiezoThreshold;
int intValuePiezo = 0;
int intValuePiezoRead = 0;
int intValuePiezoTemp = 0;
int intValuePiezoSend = 0;
int intStatePiezo = 0;
int intSendPiezo = 0;

int intStopPiezo = 0;

unsigned long piezoTimeStart = 0;
unsigned long piezoTimeDelay = 500;
unsigned long piezoSendTimeStart = 0;
unsigned long piezoSendTimeDelay = 200;

String stringValuePiezoThreshold = "";

// Tasten
const int intButton1 = 30;

int intValueButton1 = 0;
int intStateButton1 = 0;
int intDetectedButton1 = 0;
int intBlinkOn = 0;

unsigned long buttonTimeStart = 0;
unsigned long buttonTimeEnd = 0;
unsigned long buttonTimeStartDelay = 10;
unsigned long buttonTimeEndDelay = 500;

const int intButton1LED = 32;
unsigned long blinkTimeStart = 0;


void setDefault() {
    EEPROM.put(intSetDefaultAddr, 0);
    EEPROM.put(intSetIrSensorThresholdAddr, 500);
    EEPROM.put(intSetIrSensorEndDelayAddr, 1000);
    EEPROM.put(intSetPiezoThresholdAddr, 300);
    EEPROM.put(intSetDigitalIrAddr, 0);
    Serial.println(F("Einmalig default Werte gesetzt!"));
    Serial.println();
}

void setReset() {
  asm volatile ("jmp 0");
  return;
}

void checkCommand() {
  if (Serial.available() <= 0) {
    return;
  }

  String strIncomming = Serial.readString();
  strIncomming.toLowerCase() ;

  if (strIncomming.substring(0, 7) == "blinkv1") {
    String strIntValue = strIncomming.substring(7);
    strIntValue.trim();
    int intValue = strIntValue.toInt();
    intBlinkOn = HIGH;
    blinkTimeStart = millis();
    return;
  }

  if (strIncomming.substring(0, 7) == "blinkv0") {
    String strIntValue = strIncomming.substring(7);
    strIntValue.trim();
    int intValue = strIntValue.toInt();
    intBlinkOn = LOW;
    digitalWrite(intButton1LED,LOW);
    return;
  }

  if (strIncomming.substring(0, 7) == "blinkv2") {
    String strIntValue = strIncomming.substring(7);
    strIntValue.trim();
    int intValue = strIntValue.toInt();
    intBlinkOn = LOW;
    digitalWrite(intButton1LED,HIGH);
    return;
  }

  if (strIncomming.substring(0, 8) == "setpiezo") {
    stringValuePiezoThreshold = strIncomming.substring(8);
    stringValuePiezoThreshold.trim();
    String stringPiezoThreshold = stringValuePiezoThreshold.substring(0, 4);
    if (stringPiezoThreshold.toInt() > 2000) {
      intPiezoThreshold = 2000;
      Serial.println();
      Serial.print(F("Gewaehlte Piezoempfindlichkeit: "));
      Serial.print(stringPiezoThreshold.toInt());
      Serial.println(F(" (maximal erlaubt: 2000)"));
      Serial.print(F("Die Piezoempfindlichkeit wird gesetzt auf: "));
      Serial.println(intPiezoThreshold);
      Serial.println();
      EEPROM.put(intSetPiezoThresholdAddr, intPiezoThreshold);
    }
    else if (stringPiezoThreshold.toInt() < 1) {
      intPiezoThreshold = 1;
      Serial.println();
      Serial.print(F("Gewaehlte Piezoempfindlichkeit: "));
      Serial.print(stringPiezoThreshold.toInt());
      Serial.println(F(" (minimum erlaubt: 1)"));
      Serial.print(F("Die Piezoempfindlichkeit wird gesetzt auf: "));
      Serial.println(intPiezoThreshold);
      Serial.println();
      EEPROM.put(intSetPiezoThresholdAddr, intPiezoThreshold);
    }
    else {
      intPiezoThreshold = (stringPiezoThreshold.toInt());
      Serial.println();
      Serial.print(F("Gewaehlte Piezoempfindlichkeit:  "));
      Serial.println(intPiezoThreshold);
      Serial.print(F("Die Piezoempfindlichkeit wird gesetzt auf: "));
      Serial.println(intPiezoThreshold);
      Serial.println();
      EEPROM.put(intSetPiezoThresholdAddr, intPiezoThreshold);
    }
    return;
  }

  if (strIncomming.substring(0, 5) == "setir") {
    stringValueIrSensorThreshold = strIncomming.substring(5);
    stringValueIrSensorThreshold.trim();
    String stringIrSensorThreshold = stringValueIrSensorThreshold.substring(0, 4);
    if (stringIrSensorThreshold.toInt() > 1000) {
      intIrSensorThreshold = 1000;
      Serial.println();
      Serial.print(F("Gewaehlte IR-Sensorempfindlichkeit: "));
      Serial.print(stringIrSensorThreshold.toInt());
      Serial.println(F(" (maximal erlaubt: 1000)"));
      Serial.print(F("Die IR-Sensorempfindlichkeit wird gesetzt auf: "));
      Serial.println(intIrSensorThreshold);
      Serial.println();
      EEPROM.put(intSetIrSensorThresholdAddr, intIrSensorThreshold);
    }
    else if (stringIrSensorThreshold.toInt() < 100) {
      intIrSensorThreshold = 100;
      Serial.println();
      Serial.print(F("Gewaehlte IR-Sensorempfindlichkeit: "));
      Serial.print(stringIrSensorThreshold.toInt());
      Serial.println(F(" (minimum erlaubt: 100)"));
      Serial.print(F("Die IR-Sensorempfindlichkeit wird gesetzt auf: "));
      Serial.println(intIrSensorThreshold);
      Serial.println();
      EEPROM.put(intSetIrSensorThresholdAddr, intIrSensorThreshold);
    }
    else {
      intIrSensorThreshold = (stringIrSensorThreshold.toInt());
      Serial.println();
      Serial.print(F("Gewaehlte IR-Sensorempfindlichkeit:  "));
      Serial.println(intIrSensorThreshold);
      Serial.print(F("Die IR-Sensorempfindlichkeit wird gesetzt auf: "));
      Serial.println(intIrSensorThreshold);
      Serial.println();
      EEPROM.put(intSetIrSensorThresholdAddr, intIrSensorThreshold);
    }
    return;
  }

  if (strIncomming.substring(0, 13) == "setswitchtime") {
    stringValueIrSensorEndDelay = strIncomming.substring(13);
    stringValueIrSensorEndDelay.trim();
    String stringIrSensorEndDelay = stringValueIrSensorEndDelay.substring(0, 5);
    if (stringIrSensorEndDelay.toInt() > 10000) {
      sensorTimeEndDelay = 10000;
      Serial.println();
      Serial.print(F("Gewaehlte IR-Sensor Umschaltzeit: "));
      Serial.print(stringIrSensorEndDelay.toInt());
      Serial.println(F(" (maximal erlaubt: 10000ms)"));
      Serial.print(F("Die IR-Sensor Umschaltzeit wird gesetzt auf: "));
      Serial.print(sensorTimeEndDelay);
      Serial.println(F("ms"));
      Serial.println();
      EEPROM.put(intSetIrSensorEndDelayAddr, sensorTimeEndDelay);
    }
    else if (stringIrSensorEndDelay.toInt() < 100) {
      sensorTimeEndDelay = 100;
      Serial.println();
      Serial.print(F("Gewaehlte IR-Sensor Umschaltzeit: "));
      Serial.print(stringIrSensorEndDelay.toInt());
      Serial.println(F(" (minimum erlaubt: 100ms)"));
      Serial.print(F("Die IR-Sensor Umschaltzeit wird gesetzt auf: "));
      Serial.print(sensorTimeEndDelay);
      Serial.println(F("ms"));
      Serial.println();
      EEPROM.put(intSetIrSensorEndDelayAddr, sensorTimeEndDelay);
    }
    else {
      sensorTimeEndDelay = (stringIrSensorEndDelay.toInt());
      Serial.println();
      Serial.print(F("Gewaehlte  IR-Sensor Umschaltzeit: "));
      Serial.println(sensorTimeEndDelay);
      Serial.print(F("Die IR-Sensor Umschaltzeit wird gesetzt auf: "));
      Serial.print(sensorTimeEndDelay);
      Serial.println(F("ms"));
      Serial.println();
      EEPROM.put(intSetIrSensorEndDelayAddr, sensorTimeEndDelay);
    }
    return;
  }
 if (strIncomming.substring(0, 13) == "setmatrixtype") {          //Matrixtyp festlegen
   String stringValueMatrixType = strIncomming.substring(13);
    stringValueMatrixType.trim();
  String stringMatrixType = stringValueMatrixType.substring(0, 2);
    if (stringMatrixType.toInt() > 13) {
      int ValueMatrixType = 13;
     
    Serial.println();
      Serial.print("Ausgewählte Matrix:  ");
      Serial.print(ValueMatrixType);
      Serial.print("");
      Serial.print(MatrixType);
      Serial.println("");
      EEPROM.put(intSetMatrixTypeAddr, ValueMatrixType);
    }
    else if (stringMatrixType.toInt() < 1) {
      int ValueMatrixType = 1;
      Serial.println();
      Serial.print(F("Ausgewählte Matrix:  "));
      Serial.print(ValueMatrixType);
      Serial.println("");
      Serial.print(MatrixType);
      Serial.println("");
      EEPROM.put(intSetMatrixTypeAddr, ValueMatrixType);
    }
    else {
      int ValueMatrixType = (stringMatrixType.toInt());
      Serial.println();
      Serial.print(F("Ausgewählte Matrix:  "));
      Serial.print(ValueMatrixType);
      Serial.print(" ");
      Serial.print(MatrixType);
      Serial.println("");
      EEPROM.put(intSetMatrixTypeAddr, ValueMatrixType);
    }
    return;
  }
  if (strIncomming.substring(0, 8) == "setreset") {
    setReset();
    return;
  }

  if (strIncomming.substring(0, 10) == "setdefault") {
    EEPROM.put(intSetIrSensorThresholdAddr, 500);
    EEPROM.put(intSetIrSensorEndDelayAddr, 1000);
    EEPROM.put(intSetPiezoThresholdAddr, 300);
    EEPROM.put(intSetDigitalIrAddr, 0);
    Serial.println();
    Serial.println(F("Default Werte wurden gesetzt."));
    delay(1000);
    Serial.println(F("Restart in 3s."));
    delay(1000);
    Serial.println(F("Restart in 2s."));
    delay(1000);
    Serial.println(F("Restart in 1s."));
    delay(1000);
    setReset();
    return;
  }

  if (strIncomming.substring(0, 13) == "setdigitalir1") {
    EEPROM.put(intSetDigitalIrAddr, 1);
    intEepromValueDigitalIr = 1;
    Serial.println();
    Serial.println(F("Digitaler Sensor an A1 aktiviert!"));
    Serial.println();
    return;
  }

  if (strIncomming.substring(0, 13) == "setdigitalir0") {
    EEPROM.put(intSetDigitalIrAddr, 0);
    intEepromValueDigitalIr = 0;
    Serial.println();
    Serial.println(F("Digitaler Sensor an A1 deaktiviert!"));
    Serial.println();
    return;
  }

  if (strIncomming.substring(0, 5) == "test1") {
    intTestSensor = 1;
    return;
  }

  if (strIncomming.substring(0, 5) == "test0") {
    intTestSensor = 0;
    return;
  }
  
}

// Setup
void setup() {
//  analogReference(EXTERNAL);
//  analogReference(INTERNAL2V56);
  analogReference(INTERNAL1V1);
  Serial.begin(115200);
  Serial.setTimeout(50);
  Serial1.begin(115200);

// Version
  Serial.println();
  Serial.print(F("dart4free-mega "));
  Serial.println(charVersion);
  Serial.println();

// Default Werte einstellen wenn der Controller das erste Mal bespielt wurde
  EEPROM.get(intSetDefaultAddr, intEepromValueDefault);
  Serial.print(F("Default Speicher: "));
  Serial.println(intEepromValueDefault);
  Serial.println();
  if (intEepromValueDefault != 0) {
    setDefault();
    Serial.println(F("Default Speicher dauerhaft auf 0 gesetzt!"));
    Serial.println();
  }

// Testbefehle
  Serial.print(F("Testbefehle: "));
  Serial.println(F("test 1 oder 0 : Startet oder beendet den Analog-IR-Sensor/Digital-IR-Sensor/Piezos Test"));
  Serial.println();

// Matrix
  for (int row = 0; row < numRows; row++) {
    pinMode(rowPins[row],INPUT_PULLUP);
  }
  for (int column = 0; column < numCols; column++) {
    pinMode(colPins[column],OUTPUT);
    digitalWrite(colPins[column],HIGH);
  }

// Person
  pinMode(intLoewenSensor, INPUT_PULLUP);
  Serial.println(F("Ein digitaler IR-Sensor (original Loewen) kann an A1 genutzt werden."));
  Serial.println();
  EEPROM.get(intSetDigitalIrAddr, intEepromValueDigitalIr);
  Serial.print(F("EEPROM Speicher fuer setDigitalIr: "));
  Serial.println(intEepromValueDigitalIr);
  Serial.print(F("Einstellbefehl: "));
  Serial.println(F("setdigitalir 1 oder 0 : Aktiviert bzw. deaktiviert den digitalen IR-Sensor an A1"));
  Serial.println();
  EEPROM.get(intSetIrSensorThresholdAddr, intEepromValueIrSensorThreshold);
  intIrSensorThreshold = intEepromValueIrSensorThreshold;
  Serial.print(F("EEPROM Speicher fuer setIr: "));
  Serial.print(intEepromValueIrSensorThreshold);
  Serial.println();
  Serial.print(F("Einstellbefehl: "));
  Serial.println(F("setir x (x = Wert 100-1000 fuer die Schwelle vom IR-Sensor)"));
  Serial.println();
  EEPROM.get(intSetIrSensorEndDelayAddr, intEepromValueIrSensorEndDelay);
  sensorTimeEndDelay = intEepromValueIrSensorEndDelay;
  Serial.print(F("EEPROM Speicher fuer setSwitchTime: "));
  Serial.print(intEepromValueIrSensorEndDelay);
  Serial.println();
  Serial.print(F("Einstellbefehl: "));
  Serial.println(F("setswitchtime x (x = Wert 100-10000 in ms = 0,1-10s Umschaltzeit vom IR-Sensor)"));
  Serial.println();

// Taste
  pinMode(intButton1, INPUT_PULLUP);
  pinMode(intButton1LED, OUTPUT);
  digitalWrite(intButton1LED,HIGH);
  delay(1000);
  
// Fehlwurf
  EEPROM.get(intSetPiezoThresholdAddr, intEepromValuePiezoThreshold);
  intPiezoThreshold = intEepromValuePiezoThreshold;
  Serial.print(F("EEPROM Speicher fuer setPiezo: "));
  Serial.print(intEepromValuePiezoThreshold);
  Serial.println();
  Serial.print(F("Einstellbefehl: "));
  Serial.println(F("setpiezo x (x = Wert 1-2000 fuer die Schwelle vom Fehlwurfsensor)"));
  Serial.println();
  
// setmatrix
  EEPROM.get(intSetMatrixTypeAddr, intEepromValueMatrixType);
  int ValueMatrixType = intEepromValueMatrixType;
if (ValueMatrixType == 1)
{
  MatrixType = ("Cyberdine_Novomatic_1_gvul");
  }
else if (ValueMatrixType == 2)
{
  MatrixType = ("Cyberdine_Novomatic_1_vul");
}  
else if (ValueMatrixType == 3)
{
  MatrixType = ("GranBoard_62map_1_vul");
}
else if (ValueMatrixType == 4)
{
  MatrixType = ("HiDarts_1_gvum");
}
else if (ValueMatrixType == 5)
{
  MatrixType = ("Loewen_Compumatic_1_gvul");
}
else if (ValueMatrixType == 6)
{
  MatrixType = ("Loewen_Compumatic_1_vul");
}
else if (ValueMatrixType == 7)
{
  MatrixType = ("Loewen_Compumatic_2_gvlo");
}
else if (ValueMatrixType == 8)
{
  MatrixType = ("Loewen_Compumatic_2_vlo");
}
else if (ValueMatrixType == 9)
{
  MatrixType = ("Loewen_Compumatic_3_gvor");
}
else if (ValueMatrixType == 10)
{
  MatrixType = ("Loewen_Compumatic_3_vor");
}
else if (ValueMatrixType == 11)
{
  MatrixType = ("Loewen_Compumatic_4_gvru");
}
else if (ValueMatrixType == 12)
{
  MatrixType = ("Loewen_Compumatic_4_vru");
}
else if (ValueMatrixType == 13)
{
  MatrixType = ("Merkur_1_vul");
}
  Serial.print(F("EEPROM Speicher fuer setmatrixtype: "));
  Serial.print(intEepromValueMatrixType);
  Serial.print(" ");
  Serial.print(MatrixType);
  Serial.println();
  Serial.println();
  Serial.println(F("Setup der Matrix = setmatrixtype xx"));
  Serial.println(F("01 = Cyberdine_Novomatic_1_gvul"));
  Serial.println(F("02 = Cyberdine_Novomatic_1_vul"));
  Serial.println(F("03 = GranBoard_62map_1_vul"));
  Serial.println(F("04 = HiDarts_1_gvum"));
  Serial.println(F("05 = Loewen_Compumatic_1_gvul"));
  Serial.println(F("06 = Loewen_Compumatic_1_vul"));
  Serial.println(F("07 = Loewen_Compumatic_2_gvlo"));
  Serial.println(F("08 = Loewen_Compumatic_2_vlo"));
  Serial.println(F("09 = Loewen_Compumatic_3_gvor"));
  Serial.println(F("10 = Loewen_Compumatic_3_vor"));
  Serial.println(F("11 = Loewen_Compumatic_4_gvru"));
  Serial.println(F("12 = Loewen_Compumatic_4_vru"));
  Serial.println(F("13 = Merkur_1_vul"));
  Serial.println();
  Serial.println();
  
// Startanimation
  Serial.println(F("check it out!"));
  Serial.println();
  Serial.println(F("ready in 3s..."));
  Serial.println();
  digitalWrite(intButton1LED,LOW);
  delay(1000);
  Serial.println(F("ready in 2s..."));
  Serial.println();
  digitalWrite(intButton1LED,HIGH);
  delay(1000);
  Serial.println(F("ready in 1s..."));
  Serial.println();
  digitalWrite(intButton1LED,LOW);
  delay(1000);
  Serial.println("good darts!");
  Serial.println();
  Serial1.println();
  Serial1.print(F("dart4free-mega "));
  Serial1.println(charVersion);
  Serial1.println(F("check it out!"));
  Serial1.println();
  Serial1.println("good darts!");
  Serial1.println();
  digitalWrite(intButton1LED,HIGH);
  delay(100);
  digitalWrite(intButton1LED,LOW);
  delay(100);
  digitalWrite(intButton1LED,HIGH);
  delay(100);
  digitalWrite(intButton1LED,LOW);
  delay(100);
  digitalWrite(intButton1LED,HIGH);
  delay(100);
  digitalWrite(intButton1LED,LOW);
  delay(100);
  digitalWrite(intButton1LED,HIGH);
  delay(100);
  digitalWrite(intButton1LED,LOW);
  delay(100);
  digitalWrite(intButton1LED,HIGH);
  delay(100);
  digitalWrite(intButton1LED,LOW);
  delay(100);
  digitalWrite(intButton1LED,HIGH);
  delay(100);
//  digitalWrite(intButton1LED,LOW);
}

// Loop
void loop() {

// Zeit
  currentMillis = millis() + sensorTimeEndDelay + 10000;

// Matrix
  int key = getKey();

  if( key == 0) {
    checkCommand();
    testSensor();
    detectPiezo ();
    detectButton ();
    detectPerson ();
  }

  key = 0;
  Serial.flush();
}

// Sensoren testen
void testSensor(){
  if (intTestSensor == 1) {
    Serial.print(F("Analog-IR-Sensor/Digital-IR-Sensor/Piezos: "));
    Serial.print(intValueSensor);
    Serial.print(F(" / "));
    Serial.print(digitalRead(intLoewenSensor));
    Serial.print(F(" / "));
    Serial.println(intValuePiezoRead);
  }
}

// Person erkennen
void detectPerson(){
  if (intEepromValueDigitalIr == LOW) {
    intValueSensor = analogRead(intSensorIR);
  }

// Loewen Sensor
  if (digitalRead(intLoewenSensor) == LOW && intEepromValueDigitalIr == HIGH) {
    intTempValueSensor = 1500;
  }
  if (digitalRead(intLoewenSensor) == HIGH && intEepromValueDigitalIr == HIGH) {
    intTempValueSensor = 1;
  }

// Sharp IR-Sensor
  if (intValueSensor > intIrSensorThreshold && intEepromValueDigitalIr == LOW) {
    intTempValueSensor = 1500;
  }
  if (intValueSensor < intIrSensorThreshold -49 && intEepromValueDigitalIr == LOW) {
    intTempValueSensor = 1;
  }
  if (intTempValueSensor > intIrSensorThreshold -50 && intStateIrSensor == LOW) {
    sensorTimeStart = currentMillis;
    intStateIrSensor = HIGH;
    digitalWrite(intButton1LED, LOW);
  }
  if (intTempValueSensor < intIrSensorThreshold -50 && intStateIrSensor == HIGH) {
    sensorTimeEnd = currentMillis;
    intStateIrSensor = LOW;
    intValuePiezoTemp = 0;
    piezoTimeStart = currentMillis;
    digitalWrite(intButton1LED, HIGH);
  }
  if (intStateIrSensor == HIGH && intPersonDetected == LOW && currentMillis - sensorTimeStartDelay >= sensorTimeStart) {
    Serial.println(F("SENSORV1"));
    Serial1.println(F("SENSORV1"));
    intPersonDetected = HIGH;
  }
  if (intStateIrSensor == LOW && intPersonDetected == HIGH && currentMillis - sensorTimeEndDelay >= sensorTimeEnd) {
    Serial.println(F("SENSORV0"));
    Serial1.println(F("SENSORV0"));
    intPersonDetected = LOW;
  }
}

// Fehlwurf
void detectPiezo () {
  intValuePiezoRead = analogRead(intPiezo1) + analogRead(intPiezo2);
  if (intStopPiezo == LOW && intValuePiezoRead >= intValuePiezoTemp && intValuePiezoRead >= intPiezoThreshold  && currentMillis - piezoTimeStart >= piezoTimeDelay) {
    intValuePiezoTemp = intValuePiezoRead;
    if(intValuePiezoTemp >= intPiezoThreshold) {
      intValuePiezo = intValuePiezoTemp;
      intStopPiezo = HIGH;
    }
  }
  if (currentMillis - piezoTimeStart >= piezoTimeDelay && intValuePiezo >= intPiezoThreshold && intStatePiezo == LOW) {
    intStatePiezo = HIGH;
    piezoSendTimeStart = currentMillis;
    intValuePiezoSend = intValuePiezo;
  }
}

// Taste
void detectButton () {
  intValueButton1 = digitalRead(intButton1);
  if (intValueButton1 == LOW && intStateButton1 == LOW) {
    buttonTimeStart = currentMillis;
    intStateButton1 = HIGH;
  }
  if (intValueButton1 == HIGH && intStateButton1 == HIGH) {
    buttonTimeEnd = currentMillis;
    intStateButton1 = LOW;
    intValuePiezo = 0;
    intValuePiezoTemp = 0;
    piezoTimeStart = currentMillis;
  }
  if (intStateButton1 == HIGH && intDetectedButton1 == LOW && currentMillis - buttonTimeStartDelay >= buttonTimeStart) {
    Serial.println(F("BUTTON1V1"));
    Serial1.println(F("BUTTON1V1"));
    intDetectedButton1 = HIGH;
  }
  if (intStateButton1 == LOW && intDetectedButton1 == HIGH && currentMillis - buttonTimeEndDelay >= buttonTimeEnd) {
    Serial.println(F("BUTTON1V0"));
    Serial1.println(F("BUTTON1V0"));
    intDetectedButton1 = LOW;
  }
  if  (intBlinkOn == HIGH && currentMillis - blinkTimeStart >= 250){
    blinkTimeStart = currentMillis;
    digitalWrite(intButton1LED,!digitalRead(intButton1LED));
  }
}

// Matrix
int getKey() {
  int key = 0;
  for(int column = 0; column < numCols; column++) {
    digitalWrite(colPins[column],LOW);
    for(int row = 0; row < numRows; row++) {
      if(digitalRead(rowPins[row]) == LOW) {
        delay(intDebounceTime);
        key = keymap[row][column];
        Serial.print(F("MATRIXV1"));
        Serial.println(key);
        Serial1.print(F("MATRIXV1"));
        Serial1.println(key);
        if (intStatePiezo == HIGH) {
          intSendPiezo = LOW;
          intStatePiezo = LOW;
          piezoTimeStart = currentMillis;
        }
        blinkTimeStart = millis();
        while(digitalRead(rowPins[row]) == LOW){
          if (millis() - blinkTimeStart >= 200){
            blinkTimeStart = millis();
            digitalWrite(intButton1LED,!digitalRead(intButton1LED));
          }
        }
        Serial.print(F("MATRIXV0"));
        Serial.println(key);
        Serial1.print(F("MATRIXV0"));
        Serial1.println(key);
        piezoTimeStart = currentMillis;
        intValuePiezo = 0;
        intValuePiezoTemp = 0;
        intStopPiezo = LOW;
        intBlinkOn = LOW;
        digitalWrite(intButton1LED,HIGH);
      }
    }
    digitalWrite(colPins[column],HIGH);
    while(digitalRead(colPins[column]) == LOW);
  }
  if (key == 0 && intSendPiezo == LOW && intStatePiezo == HIGH && currentMillis - piezoSendTimeStart >= piezoSendTimeDelay) {
    intSendPiezo = HIGH;
    Serial.print(F("PIEZOV"));
    Serial.println(intValuePiezoSend);
    Serial1.print(F("PIEZOV"));
    Serial1.println(intValuePiezoSend);
    intSendPiezo = LOW;
    intStatePiezo = LOW;
    piezoTimeStart = currentMillis;
    intValuePiezo = 0;
    intValuePiezoTemp = 0;
    intStopPiezo = LOW;
  }
  return key;
}

wäre es nicht einfacher:

a) Ein Initialisierungs - Programm das alle 13 (?) Arrays ins Eeprom schreibt - Einmal zum Ausführen

b) Ein Spiel-Programm das dann (woher auch immer) weis mit welchem Array es arbeiten soll und genau das aus dem EEPROM liest und verwendet?

Oder bin ich falsch unterwegs?

Du erstellt eine Definition alle arrays als const
const myConst_rowPins[13][....]....
const myConstkeymap[13][...] ....
const myConst_numRows [13] ....;
const myConstnumCols[13]....

im EEPROM wird eine Zahl 1-13 gespeichert.
Diese Zahl wird eingelesen
myMatrixNr = read-from-eeprom;

Abhängig von dieser Zahl werden dann

myVariable_rowPins[....] = myConst_rowPins[myMatrixNr][....]
usw. zugewiesen und dein Programm arbeitet dann immer mit den Variablen

vgs

Ich würde für die Auswahl der Matrix DIP-Switches benutzen.

Hallo,
wenn ich das richtig verstanden habe suchst Du ja nach einer Lösung um die Arrays abhängig von einer Variablen unterschiedlich zu dimensionieren. Und das klappt jetzt nicht weil Du die Variable dazu erst im Setup aus dem Eprom ausliest, deinen Arrays allerdings jetzt global definiert sind. Ich hab sowas noch nicht versucht, aber eventuell könnte man die Array erst im loop einmalig dimensionieren und mittels swich case auswählen welche variante, dann wären sie allerdings da lokal und man müsste sie an die Funktionen die sie benötigen z.B als Referenz übergeben.

wahrscheinlich gibt es aber eine gescheitere Lösung mal sehen was da noch so kommt.
Heinz

Nachtrag : ich hab das mal versucht das wird nichts.

Das Problem ist, das ich beim compilieren des ganzen immer Verweisfehler bekomme wenn ich die Arrays erst später definiere. ich hatte schon probiert, die Variable aus dem Eeprom zu lesen, sie in eine Variable zu schreiben, diese dann in mehrere if, else if schleifen zu verpacken, das er die zur Variable gehörige Kombination einliest, aber dann meckert der Compiler jedesmal, das die ganzen werte (numCols, usw. ) nicht definiert sind, da der Compiler erst das Programm durchläuft und dann erst den Rest erkennt. Er überspringt die ganzen voids im Vorfeld, wo aber auch das Array initialisiert wird.
Ich habe schon vieles versucht, mit meinem begrenzten Wissen in der Programmierung, leider bisher ohne Erfolg. leider muss ich die Werte des Arrays ja als const definieren, da sonst das Array nicht compiliert wird.

Wie meinst du das ? ich bin leider noch nicht firm im programmieren, könntest du mir das als Bespiel innerhalb meines codes zeigen ?

wenn meinst du jetzt StefanL38 oder Heinz (user Rentner) ?

Du definierst alle const arrays.
Du definierst zusätzlich zu den const arrays einen variablen-array

und in der function setup wird der Zahlenwert für die Dartscheibe eingelesen. Ich nenne das jetzt die DartscheibenTYP-Nummer Das ist die Zahl zwischen 1 und 13

Und dann gibt es if-bedingungen oder ein switch-case
das in Abhängigkeit der DartscheibenTYP-Nummer die Zahlen in den variablen-array schreibt

if ( DartscheibenTYP-Nummer == 1) {
speichere Zahlensatz 1 im variablen-array
}

if ( DartscheibenTYP-Nummer == 2) {
speichere Zahlensatz 2 im variablen-array
}

usw.

Das bedeutet zu den const arrays kommt ein variablen-array dazu.
Da der Variablen-array auch gleich zu Anfang und global deklariert wird ist der variablen-array auch immer bekannt und der compiler findet ihn und ist zufrieden.

vgs

Im übrigen solltest du dir angewöhnen mit functions zu programmieren.
Damit wird der code sehr viel übersichtlicher, einfacher zu testen und einfacher zu verändern wenn du später mal Änderungen machen willst.

Wie gut kannst du englisch? Es gibt ein englisches Tutorial das die Sachen leicht verständlich erklärt und auf den Punkt bringt.
vgs

um die Verwirrung von @der_scotty perfekt zu machen:

eigentlich könnte man alle Arrays gleich im PROGMEM halten und dann halt auf die eine oder andere zugreifen.

@der_scotty

wenn das jetzt für dich schwierig zu verstehen ist, dann ist es Zeit umzuschalten und an einem viiiiel einfacheren Beispiel zu erlernen was arrays sind, was constanten sind, und was variablen sind.
vgs

@StefanL38 Mein Englisch ist relativ gut. Daher lerne ich gerne etwas dazu. mit functions habe ich noch nicht wirklich gearbeitet, sollte ich mal sehen, wo ich dazu etwas lernen kann.
Was das Tehma Variable Arrays angeht, das hatte ich versicht indem ich das Const weglasse bei meinen Arrays, dann bekam ich aber immer Fehler das ich int(int) nicht nutzen kann.

@noiasca PROGMEM ist mir bisher noch kein Begriff, aber ich werde es googlen :slight_smile:

Ich werde mich mal versuchen in die Themen einzulesen, vielleicht finde ich dann ja die Lösung, die bei meinem Problem funktioniert. habe ja Dank eurer Hilfe schon mal einige Gedankenstützen bekommen.

für PROGMEM empfehle ich dir das:

http://www.gammon.com.au/progmem

wenn du beantworten könntest wie du am Sketch dann von einer map auf die andere umschalten willst, und auch mal drei Maps reinstellst, vieleicht ist dann jemand gewillt, ein Muster zu machen,

ist ja gerade Feiertag bei den Katholiken ^^

Das ist das englisch-sprachige Tutorial
Arduino Programming Course

vgs

int(int) wird da auch nicht gebraucht.
Wenn es an der Stelle geklemmt hat, dass wäre eine schöne spezifische Frage die man sehr schnell beantworten kann was da wie abgeändert werden muss damit es dan funktioniert.
vgs