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 
//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