Byte aus Array auslesen, Welches durch Zeiger + Zeichennummer übergeben wird

Hi

Ich verrenne mich gerade in Kleinigkeiten, will’s wohl zu schön machen :o
Momentan versuche ich, einen Sketch zum Auslesen meines eHz-Zähler zusammen zu bekommen und stolpere wohl darüber, daß Das ‘perfekt’ werden soll.

Der ganze Sketch (kompilerbar mit Warnungen, allerdings so nicht lauffähig) im 2.ten Post

… und wohl dem Unvermögen, Zeigern auf dem Arduino eine Logik abzugewinnen …

Zuerst erstelle ich die zu suchenden Sequenzen (Teile des Sketch aus dem Nachbar-Thread klick extrahiert)

const byte startSequenz[]       = { 0x1B, 0x1B, 0x1B, 0x1B, 0x01, 0x01, 0x01, 0x01 }; //start sequence of SML protocol
const byte stopSequenz[]        = { 0x1B, 0x1B, 0x1B, 0x1B, 0x1A }; //end sequence of SML protocol
const byte powerSequenz[]       = { 0x07, 0x01, 0x00, 0x10, 0x07, 0x00, 0xFF, 0x01, 0x01, 0x62, 0x1B, 0x52, 0x00, 0x55 }; //Sequenz folgt "Wirkleistung" (4 Bytes)
const byte verbrauchSequenz[]   = { 0x07, 0x01, 0x00, 0x01, 0x08, 0x00, 0xFF, 0x65, 0x00, 0x00, 0x01, 0x82, 0x01, 0x62, 0x1E, 0x52, 0xFF, 0x59 }; //Sequenz folgt "Gesamtverbrauch" (8 Bytes)

Daraus erstelle ich mir ein Array mit den relevanten Daten

typedef struct {
  byte laenge;            //Länge der zu suchenden Sequenz
  uint16_t pointer;       //dort ist der Anfang der Sequenz
  byte bereitsgefunden;   //aktuell zu Testendes Byte aus der Sequenz
  byte folgebytes;        //wenn wir die Sequenz gefunden haben, noch x Byte einlesen
} sequenzen;

const sequenzen sequenz[] = {
  {sizeof(startSequenz), startSequenz, 0, 0},
  {sizeof(stopSequenz), stopSequenz, 0, 0},
  {sizeof(powerSequenz), powerSequenz, 0, 4},
  {sizeof(verbrauchSequenz), verbrauchSequenz, 0, 8},
};

Die Daten des eHz-Zähler werden in einem Ring-Puffer per CNY70 eingelesen, wobei nur jeweils der Schreib und Lese-Zeiger entsprechend versetzt wird, wodurch ich ‘unendlich’ schreiben kann.

        if (mySerial.available()) {
          anzahl++;                                       // für Debug, die Anzahl wird bei Pausen >500ms (const) genullt
          digitalWrite(LED_BUILTIN, HIGH);    //Daten vorhanden - Was für's Auge
          lastIRempfang = millis();           //Zeitpunkt merken um das TimeOut zu erkennen
          empfangsPuffer[writePos] = mySerial.read();   //in Puffer schreiben
          writePosPlus(); //Schreib-Zeiger erhöhen
        }

Solange ich mit dem Lesen hinterher komme - wenn nicht, wird der Lese-Zeiger mit weggeschoben.

//####################
//erhöht die Lese-Position im Ringspeicher
void readPosPlus() {
  readPos++;              //Lesezeiger verschieben
  if (readPos > maxPos) { //ist der Lesezeiger am Ende angekommen?
    readPos = 0;          //dann Den wieder auf Anfang setzen
  }
}

//####################
//erhöht die Schreib-Position im Ringspeicher
//Der Lese-Zeiger wird 'vorher geschoben'
void writePosPlus() {
  writePos++;               //Schreib-Porision erhöhen
  if (writePos > maxPos) {  //am Ende angekommen?
    writePos = 0;             //auf Anfang setzen
  }
  if (writePos == readPos) { //Schreibzeiger auf Lese-Zeiger aufgelaufen?
    readPosPlus();
  }
}

Wenn ich ungelesene Zeichen habe, möchte ich das Nächste davon einlesen und mit allen Sequenzen vergleichen.

  if (readPos != writePos) {
    //Es sind auszuwertende Bytes vorhanden
    byte readbyte = empfangsPuffer[readPos];  //nächstes Byte aus dem Puffer einlesen
    readPosPlus();
    for (byte i = 0; i < sizeof(sequenz) / sizeof(sequenz[0]); i++) {  //mit jeder Sequenz prüfen, ob diese Byte als Nächstes dort gefunden wurde
      if (sequenzbyte(sequenz[i].pointer+sequenz[i].bereitsgefunden)==readbyte){
        //Byte in der Sequenz entspricht dem gelesenem Byte
      }
    }
  }

In der letzten IF möchte ich Überprüfen, ob das aktuelle Byte dem nächstem Byte dieser Sequenz entspricht.
(wenn, ‘bereitsgefunden’ erhöhen, sofern nicht die Anzahl korrekter Bytes bereits gefunden wurde aka ‘laenge’)

Meinem Verständnis nach übergebe ich der Funktion sequenzbyte() die Start-Position des i-ten Array plus das zu Suchende Byte dieser Sequenz (bereitsgefunden) - also die Adresse/Speicherposition des bereitsgefunden’en Bytes des i-ten Array.

Die Funktion

//####################
// soll das Byte aus dem Speicher auslesen, berechnet wird die Position zuvor durch Start-Array + Zeichennummer
byte sequenzbyte(uint16_t pointer){
  return &pointer;
}

soll mir eigentlich dieses gesuchte Zeichen zurück geben, laut Compiler-Warnungen wird Das aber nicht passieren, denn

C:\...\CNY70_E21_Testmessung.ino:144:27: warning: address of local variable 'pointer' returned [-Wreturn-local-addr]
C:\...\CNY70_E21_Testmessung.ino:44:1: warning: invalid conversion from 'const byte* {aka const unsigned char*}' to 'uint16_t {aka unsigned int}' [-fpermissive]

Meine Pointer im Struct mag Er auch nicht - zumindest interpretiere ich Das so - Zeile 44 ist die schließende Klammer des Struct.
Zeile 144 das ‘return &pointer;’

Der Code ist noch im Entstehen, nicht lauffähig und noch etwas wirr ‘verdrahtet’

#include <SoftwareSerial.h>

#include <LiquidCrystal_I2C.h>  //  übergibt die Daten für's Display an I2C-Chip
LiquidCrystal_I2C lcd(0x27, 20, 4); // LCD I2C Adresse + Abmessungen

uint32_t lastIRempfang = millis();  //letzte EMpfangszeit
const uint16_t IrTimeout = 500;     //TimeOut, Zeit, die Anzahl der empfangenen Zeichen auszugeben
uint16_t const maxPos = 1000;       //Pufferlänge ist 1 länger (Zugriff per 0...xxx)
char empfangsPuffer[maxPos + 1];    //Ringspeicher
uint16_t writePos = 0;
uint16_t readPos = 0;
byte const IRpin = 8;

const byte startSequenz[]       = { 0x1B, 0x1B, 0x1B, 0x1B, 0x01, 0x01, 0x01, 0x01 }; //start sequence of SML protocol
const byte stopSequenz[]        = { 0x1B, 0x1B, 0x1B, 0x1B, 0x1A }; //end sequence of SML protocol
const byte powerSequenz[]       = { 0x07, 0x01, 0x00, 0x10, 0x07, 0x00, 0xFF, 0x01, 0x01, 0x62, 0x1B, 0x52, 0x00, 0x55 }; //Sequenz folgt "Wirkleistung" (4 Bytes)
const byte verbrauchSequenz[]   = { 0x07, 0x01, 0x00, 0x01, 0x08, 0x00, 0xFF, 0x65, 0x00, 0x00, 0x01, 0x82, 0x01, 0x62, 0x1E, 0x52, 0xFF, 0x59 }; //Sequenz folgt "Gesamtverbrauch" (8 Bytes)

typedef struct {
  byte laenge;            //Länge der zu suchenden Sequenz
  uint16_t pointer;       //dort ist der Anfang der Sequenz
  byte bereitsgefunden;   //aktuell zu Testendes Byte aus der Sequenz
  byte folgebytes;        //wenn wir die Sequenz gefunden haben, noch x Byte einlesen
} sequenzen;

const sequenzen sequenz[] = {
  {sizeof(startSequenz), startSequenz, 0, 0},
  {sizeof(stopSequenz), stopSequenz, 0, 0},
  {sizeof(powerSequenz), powerSequenz, 0, 4},
  {sizeof(verbrauchSequenz), verbrauchSequenz, 0, 8},
};

enum prgstatus {Einlesen, Stop};
enum irstatus {suchestart, suchestop, suchepower};
SoftwareSerial mySerial(IRpin, LED_BUILTIN); // RX, TX (muß angegeben werden, die Bord-LED ist dafür ganz ok)

void setup() {
  //Der Photo-Transistor der CNY70 ist an IRpin angeschlossen, wo SoftSerial auf Saten wartet
  mySerial.begin(9600);
  lcd.begin(20, 04); //(Zeichen,Zeilen);
  //lcd.backlight(); lcd.nobacklight(); lcd.clear();
  // NOTE: Cursor Position: (X,Y) start at 0
  lcd.setCursor(4, 0);
  lcd.print("Hello, world!");
  lcd.setCursor(0, 1); //Start at character 4 on line 0
  pinMode(LED_BUILTIN, OUTPUT);   //auch als TX für SoftSerial benutzt - am 'Lesekopf' unbenutzt
}

void loop() {
  byte status = Einlesen;
  uint16_t anzahl = 0;
  switch (status) {
    case Einlesen: {
        if (mySerial.available()) {
          anzahl++;
          digitalWrite(LED_BUILTIN, HIGH);    //Daten vorhanden
          lastIRempfang = millis();           //Zeitpunkt merken
          empfangsPuffer[writePos] = mySerial.read();   //in Puffer schreiben
          writePosPlus();
        }
        break;
      }
    case Stop: {
        break;
      }
    default:
      break;
  }
  if (millis() - lastIRempfang > IrTimeout) {
    //xx ms keine neuen Daten - wir sind wohl am Ende angekommen
    digitalWrite(LED_BUILTIN, LOW);
    //Ausgabe der Anzahl der empfangenen Bytes auf's Display
    anzahl = 0;
  }

  //Hier bei jedem Durchlauf jede Sequenz auf das nächste Byte prüfen, sofern ein neues Byte empfangen wurde
  if (readPos != writePos) {
    //Es sind auszuwertende Bytes vorhanden

    byte readbyte = empfangsPuffer[readPos];  //nächstes Byte aus dem Puffer einlesen
    readPosPlus();
    for (byte i = 0; i < sizeof(sequenz) / sizeof(sequenz[0]); i++) {  //mit jeder Sequenz prüfen, ob diese Byte als Nächstes dort gefunden wurde
      if (sequenzbyte(sequenz[i].pointer+sequenz[i].bereitsgefunden)==readbyte){
        //Byte in der Sequenz entspricht dem gelesenem Byte
      }
    }
  }
}


//####################
//erhöht die Lese-Position im Ringspeicher
void readPosPlus() {
  readPos++;              //Lesezeiger verschieben
  if (readPos > maxPos) { //ist der Lesezeiger am Ende angekommen?
    readPos = 0;          //dann Den wieder auf Anfang setzen
  }
}

//####################
//erhöht die Schreib-Position im Ringspeicher
//Der Lese-Zeiger wird 'vorher geschoben'
void writePosPlus() {
  writePos++;               //Schreib-Porision erhöhen
  if (writePos > maxPos) {  //am Ende angekommen?
    writePos = 0;             //auf Anfang setzen
  }
  if (writePos == readPos) { //Schreibzeiger auf Lese-Zeiger aufgelaufen?
    readPosPlus();
  }
}

//####################
// soll das Byte aus dem Speicher auslesen, berechnet wird die Position zuvor durch Start-Array + Zeichennummer
byte sequenzbyte(uint16_t pointer){
  return &pointer;
}

Steht doch genau da was falsch ist:

warning: address of local variable 'pointer' returned [-Wreturn-local-addr]

Du gibst die Adresse einer lokalen Variable zurück. Du übergibst ein Byte als Parameter und & ist die Adresse davon. Was genau das Gegenteil ist was du eigentlich tun willst

Das wird auch davon kommen:

warning: invalid conversion from 'const byte* {aka const unsigned char*}' to 'uint16_t {aka unsigned int}' [-fpermissive]

Adressen sind 16 Bit und die machst einen impliziten Cast auf Byte

Hi

Serenifly:
Steht doch genau da was falsch ist:Du gibst die Adresse einer lokalen Variable zurück. Du übergibst ein Byte als Parameter und & ist die Adresse davon. Was genau das Gegenteil ist was du eigentlich tun willst

Ok - dann übergebe ich hier:

if (sequenzbyte(sequenz[i].pointer+sequenz[i].bereitsgefunden)==readbyte){

wohl das erste Zeichen von sequenz*.pointer, statt dem von mir angedachten Pointer/Zeiger?*
Hier wollte ich ganz gerne auf das 'Original-Array' zeigen und von dort die entsprechenden Werte mit einander verrechnen, daß ich auf das aktuelle Byte des i.ten Array zeige.
> Das wird auch davon kommen:Adressen sind 16 Bit und die machst einen impliziten Cast auf Byte
Wo?
Meine Intention war, daß ich das Byte zurück gebe, Welches von der übergebenen Speicherstelle ausgelesen werden soll, wobei diese Speicherstelle aus dem Startpunkt des Array und einem Offset besteht.
Da das Array selber nur Bytes enthält, reicht addieren - nur kommt noch nicht raus, was ich will.
Sorry, kam erst jetzt wieder dazu, etwas hier zu machen - der Heizungskühler des Brüderchen hatte mich den Tag voll in der Hand - und wohl nächstes Wochenende auch noch :confused: (hätte am Rechner bleiben sollen).
MfG

Wieso willst du da Zeiger verwenden wenn du nicht damit umgehen kannst? Mit Zeigern kann man allerlei Unsinn und Fehler machen. Daher sollte man sie nur verwenden wenn es auch wirklich nötig ist.

Einen Offset kannst du auch im Subskript Operator drauf addieren:

byte var = array[index + offset];

Hi

Dabei dürfte Es aber relativ egal sein, wo ich auf X zwei drauf addiere, oder?

Wo mache ich hier Unsinn?
Oder anders: wie komme ich zu Dem, was ich ursprünglich wollte: das Byte in Speicher an Adresse X?
Klar kann ich der Funktion auch Start und Offset separat übergeben - da mich nur das Byte der Endadresse interessiert, wäre mir dieser Weg noch relativ egal - verstehen wöllte ich Diesen aber schon ganz gerne.

Das 'nicht damit umgehen können' wird wohl so ziemlich an JEDER Stelle auftreten, wo 'egal wer' mit irgend etwas anfängt.
Wenn dort Jeder 'oha - nix gut, besser lassen' kommt, sind wir bald wieder in der Steinzeit - also, darf ich Das lernen, oder soll JEDER besser wieder mit Basic anfangen?

Gerade, weil mir Zeiger und Referenzen beim Arduino bisher keinen Sinn gegeben haben, wäre Es doch echt toll, wenn Du Das bei mir ändern könntest?
Ich will den Kram doch auch nur verstehen - daran hapert Es derzeit extrem!
Früher hüstel war mov AX,BX 'lase AX mit dem Wert BX und mov AX,[BX] lase AX mit dem Inhalt der Speicher-Adresse DS:BX - so etwas vermisse ich beim Arduino - oder bin derzeit einfach zu blöd dafür.
(Ja, die zwei Beispiele sind Assembler, Da weiß man wenigstens, Was man hat)

Wenn cih mit meiner Idee auf dem Holzweg bin - korrigiert mich!
Wenn nicht - helft mir doch einfach :wink:
Prügelt mich in die richtige Richtung - wenn Ihr zu grob werdet, wird's Das wohl gewesen sein - aber Jesses - 'thats live' :wink:

MfG

Sei doch froh, daß Du Dich am Arduino nicht mit Segmenten und Offsets und Registern herumschlagen mußt, und stattdessen leserlichen C oder C++ Code schreiben kannst. Segmentregister gibt es bei den Arduinos nicht, die werden auch bei den Intel Prozessoren schon lange nicht mehr verwendet.

Wo Du beim x86 Assembler DS:[BX+2*AX] schreiben mußtest, geht das in C mit MyArray[ax]. Da steht MyArray für DS:BX, und ax hier nicht für den Offset, sondern die Nummer (Index) des Elements. Bei Bytes macht das keinen Unterschied zwischen Index und Offset, aber bei einem int Array muß man den Index mit 2 multiplizieren (Anzahl Bytes pro Element), um den richtigen Offset zu bekommen. Und diese Rechnerei macht der Compiler für Dich, und erzeugt auch noch die richtigen Befehle für das Übertragen der zusammengehörenden Bytes eines Elements.

Und weil sich das Hantieren mit Adressen als sehr fehleranfällig erwiesen hat (Pufferüberlauf...), wurden in C++ noch Referenzen eingeführt. Sie haben die gleiche Funktion wie Pointer, enthalten also Adressen, nur sind Referenzen nicht änderbar, und können auch nicht NULL (ungültig) sein. Also vergiß Pointer und Adressen, und verwende stattdessen Arrays und Indices. Dann hast Du den ersten Schritt vom Byteschubser zum Programmierer geschafft :slight_smile:

wenn Ihr zu grob werdet, wird's Das wohl gewesen sein

Kein Problem, grob kann ich!

... und wohl dem Unvermögen, Zeigern auf dem Arduino eine Logik abzugewinnen .

Eigentlich bist du ja gar nicht mal so ganz doof!
Also kann sich das Unvermögen eigentlich nur aus 2 Komponenten zusammen setzen.

Nichtwissen und innerer Abwehr.

Gegen das nicht wissen hilft ein Fachbuch.
Und in Sachen Pointer darf es ein beliebiges C/C++ Buch sein.
Denn bis auf den nullptr sind C und C++ da weitgehend gleich.

So das war Teil 1.

Teil 2:

Auch Michael Schumacher wurde nicht von seiner Mutter in das F1 Cockpit rein geboren.
Er musste fahren lernen.
Und ist klein angefangen. Kart.
Selbst da waren die ersten Runden noch keine Wertungsrunden.

So bei dir auch....
Teste im kleinen.
Bevor du deine neu gewonnenen Erfahrungen auf einen doch recht komplexen Parser los lässt.

Kann ich dir dabei helfen?
Ja, ich könnte dir Bücher nennen.
Oder auf konkrete Fragen antworten.

Aber ich kann dir nicht deinen inneren Widerstand gegen Zeiger nehmen.
Das ist deine alleinige Baustelle.

Tipp:
Die Arbeit mit Zeigern in C/C++, nennt ein Assemblerprogrammierer, "Indirekte Adressierung".
Das ist das gleiche!
Nur, dass der Assemblerprogrammierer für die Adressarithmetik selber verantwortlich ist, und C/C++ die Pointerarithmetik schon eingebaut hat.

Noch Fragen?
Dann frage!

Hi

So, habe etwas gespielt, rausgekommen sind die Ausgabe mehrerer Arrays per Zeiger, wie im loop() die Prüfung der Eingaben via Terminal an mehreren Sequenzen wie Deren Fund - oder eben nicht.

#Array,#Zeiger,#Pointer,#Arduino :slight_smile:

//void printarray(byte *pointer);  //wird wohl automatisch von der IDE erstellt

byte test = 137;
byte *pointer = &test;          //pointer zeigt auf Speicherstelle von test
byte testarray[] = {101, 202, 22, 66, 78,0}; // Null angehangen, da sonst Endprüfung fehlerhaft!!
byte *arraypointer2 = testarray;     //arraypointer zeigt auf Speicherstelle von testarray[0], da testarray selber schon ein Zeiger auf das erste Array-Element ist, entfällt das & (??)
byte *arraypointer3 = &testarray[0]; //arraypointer zeigt auf Speicherstelle von testarray[0]

//Sequenzen, Die im Eingabestrom gefunden werden sollen
const byte test1[] = {'H', 'a', 'l', 'l', 'o'};
const byte test2[] = {'B', 'a', 'l', 'l', 'o'};
const byte test3[] = {'T', 'e', 's', 't'};
const byte test4[] = {'T', 'e', 's', 't', '2'};
const byte test5[] = {'H', 'a', 'l', 'l', 'o', 'e', 'l', 'e'};

typedef struct {                   // Erstellen des Datentyp 'sequenzen'
  const byte laenge;            //Länge der zu suchenden Sequenz
  const byte *pointer;          //dort ist der Anfang der Sequenz
  byte bereitsgefunden;       //aktuell zu Testendes Byte aus der Sequenz, änderbar
  const byte folgebytes;      //wenn wir die Sequenz gefunden haben, noch x Byte einlesen (hier nicht benutzt)
} sequenzen;

sequenzen sequenz[] = {    //Anlegen der 5 zu testenden Sequenzen sequenz[0...5] im Datentyp sequenzen
  {sizeof(test1) / sizeof(test1[0]), &test1[0], 0, 0},
  {sizeof(test2) / sizeof(test2[0]), &test2[0], 0, 0},
  {sizeof(test3) / sizeof(test3[0]), &test3[0], 0, 0},
  {sizeof(test4) / sizeof(test4[0]), &test4[0], 0, 0},
  {sizeof(test5) / sizeof(test5[0]), &test5[0], 0, 0},
};


void setup() {
  Serial.begin(9600);                     //Serielle Schnittstelle mit xxx Baud öffnen
  Serial.print("*poniter=");              //und diverses Zeug ausgeben
  Serial.println(*pointer);                //die Byte-Variable
  Serial.print("*arrayponiter2=");
  Serial.println(*arraypointer2);       //das erste Element des Array
  Serial.print("*arrayponiter3=");
  Serial.println(*arraypointer3);       //ernuet das erste Element des Array

  Serial.println("Original-Array");    //Ausgabe des Array-Inhalt über das Array selber
  byte i = 0;
  while (testarray[i]) {
    Serial.print(testarray[i]);
    Serial.print(" ");
    i++;
  }
  Serial.println();

  Serial.println("Zeiger auf Byte-Variable");  //die Byte-Variable
  Serial.print(*pointer);
  Serial.println();

  Serial.println("Zeiger auf Array-Name");   //das Array über den Zeiger auf den Array-Namen
  i = 0;
  while (*(arraypointer2 + i)) {
    Serial.print(*(arraypointer2 + i));
    Serial.print(" ");
    i++;
  }
  Serial.println();

  Serial.println("Zeiger auf Array[0]");        //das Array über den Zeiger auf das erste Array-Element
  i = 0;
  while (*(arraypointer3 + i)) {
    Serial.print(*(arraypointer3 + i));
    Serial.print(" ");
    i++;
  }
  Serial.println();

  Serial.println("Funktionsaufruf arraypointer2");   //Ausgabe des Array per Funktion durch Übergabe des Zeiger auf den Namen
  printarray(arraypointer2);
  Serial.println("Funktionsaufruf arraypointer3");   //Ausgabe des Array per Funktion durch Übergabe des Zeiger auf das erste Element
  printarray(arraypointer3);
}

void loop() {
  if (Serial.available()) {
    //Es wurde mindestens ein Zeichen übergeben
    //Hier alle Sequenzen durchprüfen, ob das nächste Zeichen dieser Sequenz dem Übergebenem entspricht
    byte a = Serial.read();     //Zeichen einlesen
    if (a >= 0x20) {            //Wenn kein Steuerzeichen, dann Prüfen (da zum Test Eingabe via Terminal)
      Serial.print("Eingelesen: ");
      Serial.write(a);
      Serial.println();
      for (byte i = 0; i < sizeof(sequenz) / sizeof(sequenz[0]); i++) { //alle Sequenzen durchprüfen
        boolean rescan = 0;               //bei Abbruch wird diese Sequenz erneut getestet, ob das Zeichen das Startzeichen ist
        Serial.print("Teste Sequenz ");
        Serial.print(i);
        if (*(sequenz[i].pointer + sequenz[i].bereitsgefunden) == a) {  //stimmt das Zeichen überein
          Serial.print("*");
          if (sequenz[i].bereitsgefunden == sequenz[i].laenge - 1) {    //sind wir am Ende der Sequenz? -1, da der Index bei 0 beginnt, die Länge aber bei 1
            Serial.print(" gefunden");                                  //ja, Erkennung wieder von Vorne
            sequenz[i].bereitsgefunden = 0;
          } else {
            sequenz[i].bereitsgefunden++;                               //nein, auf nächstes Zeichen stellen
          }
        } else {
          if (sequenz[i].bereitsgefunden != 0) {                        //unpassendes Zeichen gefunden - Das passt aber vll. am Anfang
            rescan = 1;                                                 // -> neu Prüfen (Schleife mit gleichem Wert erneut durchlaufen)
          }
          sequenz[i].bereitsgefunden = 0;                               //zu Prüfendes Zeichen auf Anfang stellen
        }
        Serial.print(" (");                                             //Anzeigen der zu Prüfenden Stelle
        Serial.print(sequenz[i].bereitsgefunden);
        Serial.println(")");
        if (rescan) i--;  //Schleife erneut durchlaufen                 //bei erneuter Prüfung die Zähl-Variable um 1 verringern
      }
    }
  }
}

void printarray(byte *pointer) {  //Übergabe des Byte-Pointer - mir fiel auf, daß 'byte* pointer' und 'byte * pointer' ebenfalls klappt, gerade Letzteres sollte man aber, laut Buch (C++ Entwicklung mit Linux) unterlassen
  byte i = 0;                           //Offset auf 0
  while (*(pointer + i)) {           //solange kein Null-Byte gelesen wurde
    Serial.print(*(pointer + i));   //Zeichen-Code ausgeben
    Serial.print(" ");                 //Leerzeichen für bessere Übersicht
    i++;                                 //Offset erhöhen
  }
  Serial.println();                    //neue Zeile
}

Denke, So ungefähr wollte ich Das haben.
Ich denke allerdings auch, daß meine Prüfung auf das Ende des Array in der Funktion printarray() zumindest unsauber ist, da ich dem Array nicht explizit eine Null anhänge, um das Ende zu markieren - klappt aber trotzdem - warum?
Theoretisch müsste sich doch die Byte-Variable direkt hinter dem Array finden lassen (wobei ich noch nicht heraus bekommen habe, wie ich mir die Werte der Zeiger anzeigen lassen kann).
Öh - hatte zuvor das Byte nach dem Array erst deklariert - macht aber keinen Unterschied (gerade erst gesehen, daß das Array ‘das Letzte’ ist, somit ist eine Null dahinter wahrscheinlich, oder?
Kaum probiert man etwas herum, schon klappt die Ende-Erkennung nicht mehr - denke, habe ‘Überreste’ im Speicher.
Also entweder über Anhängen einer Null, oder Mithalten der Länge!!

Besten Dank schon Mal für Eure Unterstützung bis hier hin.
Vll. kann ja Wer dieses Pointer-Beispiel gebrauchen - selber denke ich, auf dem richtigen Weg zu sein.

MfG

Theoretisch müsste sich doch die Byte-Variable direkt hinter dem Array finden lassen

Die Reihenfolge der Variablen im Speicher ist undefiniert.

(wobei ich noch nicht heraus bekommen habe, wie ich mir die Werte der Zeiger anzeigen lassen kann).

Normalerweise gibts dazu keine Notwendigkeit!

Aber gehen tuts das.

byte test = 137;
byte *pointer = &test;          //pointer zeigt auf Speicherstelle von test



void setup() 
{
  Serial.begin(9600);
  Serial.println(reinterpret_cast<uint32_t>(pointer));// 32 Bit, damits auch auf ARM und ESP klappt
}

void loop() 
{
}