zweidimensionale Arrays an Funktion übergeben

Hallo,
ich bin noch absoluter Anfänger in C und versuche schon seit Tagen
die Elemente bzw. Daten eines zweidimensionalen Arrays in einer
Funktion zu Verarbeiten.

Sofern sich das Array INNERHALB der Funktion befindet ist es einfach.
Die Funktion gibt die Daten des Arrays an den Seriellen Monitor aus.
Siehe erstes Programm.

Aber sobald ich die Arrays AUSSERHALB der Funktion (Global) anlege
habe ich Schwierigkeiten Auf die Daten der Zeilen und Spalten zuzu
-greifen.
Ich habe einige Beispiele im Netz gefunden die ich leider nicht
verstanden habe. Sehr unübersichtlich diese Zeiger.

Ich würde den Arrayzugriff gerne wie im zweiten Beispiel realisieren.
Kann mir einer erklären wie das geht ? Mit Beispielcode ?

/*zweidimensionales Array INNERHALB einer Funktion*/

void funktion()
{

int feld[3][15] = {
                       {
                         0xB0,0xB1,0xB2,0xB3,0xB4                          
                       },

                       {
                         7,11,13,17,23 
                       },

                       {
                         0b0001,0b0010,0b0011,0b0100,0b0101
                       }                                        
                  };

  
int anzahl_im_array =sizeof(feld) / sizeof(int) / 3 / 3;

int erste_Zeile;
int zweite_Zeile;
int dritte_Zeile;

for(int zaehler = 0 ; zaehler<anzahl_im_array ; zaehler++)
  {

Serial.begin(115200);
//Serial.println(anzahl_im_array);
/*Die Zahlen im Array ausgeben*/
Serial.println(" ");
Serial.println(" ");
Serial.println(feld[0][erste_Zeile],HEX);
Serial.println(feld[1][zweite_Zeile]);
Serial.println(feld[2][dritte_Zeile],BIN);

erste_Zeile++;
zweite_Zeile++;
dritte_Zeile++; 
  }
}



void setup() 
{
funktion();
}




Serieller Monitor:

 C!(j
7
1
!j
 
B1
11
10
 
 
B2
13
11
 
 
B3
17
100
 
 
B4
23
101

So würde ich es gerne machen:

/*Array AUßERHALB einer Funktion*/
/*zweidimensionales Array an eine Funktion übergeben*/

int array_eins[3][21] = {
                            {
                             0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6                          
                            },

                            {
                             4,6,8,10,12,14,16 
                            },

                            {
                             0b100000,0b100001,0b100010,0b100011,0b100100,
                             0b1000101,0b100110
                            }                                        
                        };




int array_zwei[3][15] = {
                            {
                             0xB0,0xB1,0xB2,0xB3,0xB4                          
                            },

                            {
                             7,11,13,17,23 
                            },

                            {
                             0b0001,0b0010,0b0011,0b0100,0b0101
                            }                                        
                         };


void funktion(int feld)
{



  
int anzahl_im_array =sizeof(feld) / sizeof(int) / 3 / 3;

int erste_Zeile;
int zweite_Zeile;
int dritte_Zeile;

for(int zaehler = 0 ; zaehler<anzahl_im_array ; zaehler++)
  {

Serial.begin(115200);
/*Die Zahlen im Array ausgeben*/
Serial.println(" ");
Serial.println(" ");
Serial.println(feld[0][erste_Zeile],HEX);
Serial.println(feld[1][zweite_Zeile]);
Serial.println(feld[2][dritte_Zeile],BIN);

erste_Zeile++;
zweite_Zeile++;
dritte_Zeile++; 
  }
}



void setup() 
{
funktion(array_eins);
}
void funktion(int feld)

Der Parameter ist überflüssig. Globale Variablen kannst Du direkt mit ihrem Namen ansprechen, sie gelten ja überall. Also

void funktion() {
...
... sizeof(array_eins) ...

Tip: Wenn deine Zahlen Bytes darstellen sollen, dann verwende auch byte als Datentyp

Hierzu gibt es drei Optionen. Die Beispiele sind etwas konstruiert mit den Konstanten. Und wie gesagt braucht man das als Parameter gar nicht, da es globale Variablen sind! Das ist nötig wenn man die Arrays lokal hat.
Oder wenn man eine Funktion haben will die mit unterschiedlichen Arrays umgehen kann.

Beide Dimensionen bei der Deklaration:

byte data[3][5] = 
{
  { 1, 2, 3, 4, 5},
  { 0xAA, 0xBB, 0xCC, 0xDD, 0xEE },
  { 44, 55, 66, 77, 88 }
};

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

  print(data);
}

void loop()
{
}

void print(byte data[3][5])
{
  for (unsigned int i = 0; i < 3; i++)
  {
    for (unsigned int j = 0; j < 5; j++)
    {
      Serial.print(data[i][j]);
      Serial.print(' ');
    }
    Serial.println();
  }
}

Nur eine Dimension bei der Deklaration. Die zweite als Parameter übergeben:

const int DIM_X = 5;

void print(byte data[][DIM_X], unsigned int dimY);    //Funktions-Prototyp damit die Konstante bekannt ist

byte data[][DIM_X] = 
{
  { 1, 2, 3, 4, 5},
  { 0xAA, 0xBB, 0xCC, 0xDD, 0xEE },
  { 44, 55, 66, 77, 88 }
};

const int DIM_Y = sizeof(data) / DIM_X / sizeof(data[0][0]);

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

  print(data, DIM_Y);
}

void loop()
{
}

void print(byte data[][DIM_X], unsigned int dimY)
{
  for (unsigned int i = 0; i < dimY; i++)
  {
    for (unsigned int j = 0; j < DIM_X; j++)
    {
      Serial.print(data[i][j]);
      Serial.print(' ');
    }
    Serial.println();
  }
}

Hiermit wäre es Möglich Arrays zu übergeben die sich in der einen Dimension unterscheiden

Oder man übergibt beide Dimensionen als Parameter und einen Zeiger für das Array:

const int DIM_X = 5;

byte data[][DIM_X] = 
{
  { 1, 2, 3, 4, 5},
  { 0xAA, 0xBB, 0xCC, 0xDD, 0xEE },
  { 44, 55, 66, 77, 88 }
};

const int DIM_Y = sizeof(data) / DIM_X / sizeof(data[0][0]);

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

  print((byte*)data, DIM_X, DIM_Y);

  //oder: print(&data[0][0], DIM_X, DIM_Y);
}

void loop()
{
}

void print(byte* data, unsigned int dimX, unsigned int dimY)
{
  for (unsigned int i = 0; i < dimY; i++)
  {
    for (unsigned int j = 0; j < dimX; j++)
    {
      Serial.print(*((data + i * dimY) + j));
      Serial.print(' ');
    }
    Serial.println();
  }
}

Sooo - Jetzt klappt es so wie ich es mir vorgestellt habe. Noch mal vielen Dank für die Tipps.

#include <stdio.h>
#include <stdlib.h>

int mein_erstes_Array[3][5] = {                                     
						 {
                                                   7,  11, 13, 17, 19,    
                                	          },

                                 	          {
                                        	    23, 29, 59, 61, 67,                  
						  },

                                	          {
                                         	    71, 73, 79, 83,  89,  
                                 	          }
                              		       };


int zeige_Grafik(int zeile, int spalte, int unbek_array[zeile][spalte])
{
printf("\n\n");
int gesamtanzahl_Elemente = zeile * spalte;
int zeilenzaehler0 = 0;
int zeilenzaehler1 = 0;
int zeilenzaehler2 = 0;

for(int i = 0 ; i < gesamtanzahl_Elemente / 3 ; i++)
    {
printf("\n\n");
printf("Zahlen aus dem Array: %d\n", unbek_array[0][zeilenzaehler0]);
printf("Zahlen aus dem Array: %d\n", unbek_array[1][zeilenzaehler1]);
printf("Zahlen aus dem Array: %d\n", unbek_array[2][zeilenzaehler2]);
zeilenzaehler0++;
zeilenzaehler1++;
zeilenzaehler2++;
    }
}

void main()
{
zeige_Grafik(3,7,mein_erstes_Array);
printf("\n\n");
}

AUSGABE am Terminal:

Zahlen aus dem Array: 7
Zahlen aus dem Array: 23
Zahlen aus dem Array: 71

Zahlen aus dem Array: 11
Zahlen aus dem Array: 29
Zahlen aus dem Array: 73

Zahlen aus dem Array: 13
Zahlen aus dem Array: 59
Zahlen aus dem Array: 79

Zahlen aus dem Array: 17
Zahlen aus dem Array: 61
Zahlen aus dem Array: 83

Zahlen aus dem Array: 19
Zahlen aus dem Array: 67
Zahlen aus dem Array: 89