Abfrage nach Element in Array

[Max (Gast)]

Hallo,
ich habe ein Array aus 10 Elementen und möchte nun bei einer 
eingegebenen Variable abfragen, ob der Wert der Variable im Array 
vorkommt.
Die Abfrage würde ich gerne als Funktion lösen, die dann ein true oder 
false zurückgibt.

Leider scheint da aber beim return etwas nicht zu stimmen, da das immer 
wahr ist.

Das array:

#define ARSIZE 10
byte sensor_OR[ARSIZE] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
byte ID = 3;
//byte ID = 2;

void setup() {
  sensor_OR[0] = 18;
  sensor_OR[1] = 2;  
}

  if (testinArray_OR(ID)) {
     Serial.print(ID); Serial.println(" in Array");
  }

Die Funktion

boolean testinArray_OR(byte test) {
  for (int i = 0; i < ARSIZE; i++) {
    if (test == sensor_OR[i]) {
      Serial.println(i);
      return true;
    }
  }
}

[Oliver S. (oliverso)]

Du hast nicht alle Warnungen des Compilers eingeschaltet oder beachtet.

Wenn der Sourcecode im Original genauso formatiert ist wie hier, sagt 
dir eigentlich schon, was das Problem ist.

Oliver

[Vincent H. (vinci)]

Max schrieb:
> Die Abfrage würde ich gerne als Funktion lösen, die dann ein true oder
> false zurückgibt.

Das gibts bereits in der Standard-Library:
https://en.cppreference.com/w/cpp/algorithm/all_any_none_of
https://en.cppreference.com/w/cpp/algorithm/ranges/all_any_none_of

Beispiel:
https://godbolt.org/z/n8banq

[Interessierter (Gast)]

Max schrieb:
> Die Abfrage würde ich gerne als Funktion lösen, die dann ein true oder
> false zurückgibt.

Dein Funktion kann "true" zurückgeben, wenn sie was findet.

Aber wo kann sie "false" zurück geben, wenn sie nichts findet?

[Tom K. (ez81)]

Das sieht nach Arduino aus. Da gibt es weder Warnungen (sind (oder waren 
zumindest früher) in Standardeinstellung deaktiviert) noch STL.

[Schlaumaier (Gast)]

Deklariere die Return-variale am Anfang der Funktion bzw. gib ihr den 
den Wert FALSE. Entweder die Schleife ändert sie oder halt nicht.

So einfach ist das.

[Schlaumaier (Gast)]

Nachtrag:

Bin ich blind oder finde ich die Deklarierung von TEST nicht.

 if (test == sensor_OR[i]) {  ' <- die da meine ich

Also meine Compiler melden eigentlich "nicht deklariere Variable". Aber 
vielleicht bin ich ja echt blind.

Dann sorry.

[in der Kürze liegt die Würze (Gast)]

Max schrieb:
> byte sensor_OR[ARSIZE] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};

ist nicht nötig.

Hier wird genauso alles auf 0 gesetzt und man muss nichts abzählen:

byte sensor_OR[ARSIZE] = {0};

[in der Kürze liegt die Würze (Gast)]

Max schrieb:
> Die Abfrage würde ich gerne als Funktion lösen, die dann ein true oder
> false zurückgibt.

Du willst doch auch bestimmt die Position im Array haben. Besser wäre es 
byte* als Rückgabewert zu definieren und NULL (nicht gefunden) bzw. die 
Position (gefunden) zurückzugeben.

[Flo (Gast)]

@Schlaumaier
Die Variable 'test' ist der Parameter der Funktion 'testinArray_OR'

@Max
Deine Funktion müsste so aussehen:

boolean testinArray_OR(byte test)
{
  for (int i = 0; i < ARSIZE; i++)
  {
    if (test == sensor_OR[i])
    {
      Serial.println(i);
      return true;
    }
  }
  return false;
}

Oder du nimmst eine Funktion aus der Std-Library, wie von  Vincent H. 
(vinci) vorgeschlagen.

Grüße Flo

[Markus E. (markus_e176)]

Schlaumaier schrieb:
> Nachtrag:
>
> Bin ich blind oder finde ich die Deklarierung von TEST nicht.
>
>  if (test == sensor_OR[i]) {  ' <- die da meine ich
>
> Also meine Compiler melden eigentlich "nicht deklariere Variable". Aber
> vielleicht bin ich ja echt blind.
>
> Dann sorry.

Die ist zwei Zeilen darüber, als Parameter der Funktion

> boolean testinArray_OR(byte test) {

[Schlaumaier (Gast)]

Ok ich gebs zu ich bin Scheuklappenblind.

Bei mir ist es halt anders herum deshalb hab ich das übersehen. Sorry.

[Flo (Gast)]

SoNicht! schrieb im Beitrag #6451518:
> seit wann gibts boolean in c?

Der TO programmiert wohl mit der Arduino Umgebung:
https://www.arduino.cc/reference/de/language/variables/data-types/boolean/

[Max (Gast)]

Hallo,

super danke für den Hinweis mit dem fehlenden false. Das hat 
funktioniert.

>Du willst doch auch bestimmt die Position im Array haben
Nein für mein Beispiel brauche ich das nicht.

Das Ziel soll sein am Ende, dass ich ein Array für ODER-Verknüpfungen 
habe und drei Arrays mit UND-Verknüpfungen.
Wenn eine Nummer im OR Array ist soll ausgelöst werden oder wenn eine 
Kombination im UND Array sich befindet etc. Als weitere Schwierigkeit 
kommt dann noch dazu, dass die UND Verknüpfungen innerhalb einer Sekunde 
zB stattfinden müssen
if (array_OR || array_AND_1 || array_AND_2 || array_AND_3) 
{ausloesen();}

..aber erstmal versuche ich mich dem Schrittweise zu nähern. Mit 
return-Werten hatte ich bis dato noch nicht zu tun.
Ein Empfänger liefert mir IDs von Sensoren, die Bewegung erkannt haben.
Diese IDs will ich nun mit den in den Arrays gespeicherten Nummern 
abgleichen und dann bei richtiger Bedingung einen Ausgang zu schalten.
Die Arrays deshalb, damit ich flexible auswählen kann welche IDs in 
Frage kommen und das ganze im EEPROM abspeicherbar ist.
Das ganze wird tatsächlich in der Arduino Umgebung programmiert

[Max (Gast)]

Hallo,

ich habe mal das ganze Programm angehängt.
Bei dem nächsten Schritt komme ich beim Ansatz nicht weiter.
Das ganze soll ja einen Ausgang schalten wenn alle Nummern eines 
AND-Arrays empfangen wurden und erfolgreich abglichen wurden.

Wird also 10,11 empfangen, dann wäre die Bedingung für das Array AND_1 
gültig:

sensor_AND_1[0] = 10;
sensor_AND_1[1] = 11;

Nun muss das ganze aber innerhalb von einer gewissen Zeit passieren, 
sagen wir 2 sek. Ebenso soll der µC so oft wie möglich schlafen, da 
Batteriebetrieb.


Die erste Idee, die noch im Code ist war wenn eine Zahl im Array 
auftaucht einen counter zu erhöhen: AND_1_counter++ und mit der Anzahl 
der Elemente im Array zu vergleichen. Funktioniert aber nicht, wenn zB 
zweimal die gleiche Zahl aufgerufen wird, dann wird der Counter um zwei 
erhöht und wäre fehlerhaft.

Eine Idee war ein zweites Array zusätzlich für jedes AND-Array in dem 
dann millis() gespeichert werden, oder eine Flag, an der entsprechenden 
Position.
Man könnte auch über eine RTC die aktuelle Uhrzeit+Datum holen.

Problem 1:  wenn der µC schläft, werden die millis() nicht erhöht, 
müsste man per wdt interrupt den µC vermutlich alle paar ms aufwecken 
und eine Variable erhöhen
Problem 2: Der Speicherplatz, wenn ich da noch für jedes Element im 
Array Zeit/Datum ablegen muss in meinem Atmega328P


Wie würdet ihr das angehen? (Das ganze kann auf einem Arduino Nano/Uno 
per Terminal getestet werden)

String Num1;
#define ARSIZE 10

byte sensor_OR[ARSIZE] = {0};
byte sensor_AND_1[ARSIZE] = {0};
byte sensor_AND_2[ARSIZE] = {0};
byte sensor_AND_3[ARSIZE] = {0};

int OR_counter=0;
int AND_1_counter=0;
int AND_2_counter=0;
int AND_3_counter=0;

int OR_isset_counter=0;
int AND_1_isset_counter=0;
int AND_2_isset_counter=0;
int AND_3_isset_counter=0;
  
void setup() {

  sensor_OR[0] = 18;
  sensor_OR[1] = 2;

  sensor_AND_1[0] = 10;
  sensor_AND_1[1] = 11;

  sensor_AND_2[0] = 20;
  sensor_AND_2[1] = 21;
  
  sensor_AND_3[0] = 30;
  sensor_AND_3[1] = 31;
  sensor_AND_3[2] = 32;

  Serial.begin(115200);
  
}


boolean testinArray(byte val, byte arr[], int arrsize)
{
  for (int i = 0; i < arrsize; i++)
  {
    if (val == arr[i])
    {
      return true;
    }
  }
  return false;
}


int isset_counter(byte arr[], int arrsize)
{  int count=0;
  for (int i = 0; i < arrsize; i++)
  {
    if (arr[i]>0) { count++; ArrayRecord[i]=millis(); } // wenn ID vorhanden, ID > 0
  }
  return count;
}

void loop() {

  //In der Praxis soll die Nummerneingabe von einem Funkmodul kommen was den µC per Interrupt aufweckt, der ansonsten schläft
  Serial.println("Enter Number : ");
  while (Serial.available() == 0)
  {}
  Num1 = Serial.readString();
  byte ID = Num1.toInt();
  
  
  Serial.print("ID "); Serial.println(ID);
   
  if (testinArray(ID, sensor_OR, ARSIZE ))    { Serial.println("Auslösen"); }
  if (testinArray(ID, sensor_AND_1, ARSIZE )) { AND_1_counter++; }
  if (testinArray(ID, sensor_AND_2, ARSIZE )) { AND_2_counter++; }
  if (testinArray(ID, sensor_AND_3, ARSIZE )) { AND_3_counter++; } 


  OR_isset_counter    = isset_counter(sensor_OR, ARSIZE);
  AND_1_isset_counter = isset_counter(sensor_AND_1, ARSIZE);
  AND_2_isset_counter = isset_counter(sensor_AND_2, ARSIZE);
  AND_3_isset_counter = isset_counter(sensor_AND_3, ARSIZE);
  

  Serial.print("OR_counter ");    Serial.print(OR_counter);     Serial.print(" / OR_isset_counter "); Serial.println(OR_isset_counter);
  Serial.print("AND_1_counter "); Serial.print(AND_1_counter);  Serial.print(" / AND_1_isset_counter "); Serial.println(AND_1_isset_counter);
  Serial.print("AND_2_counter "); Serial.print(AND_2_counter);  Serial.print(" / AND_2_isset_counter "); Serial.println(AND_2_isset_counter);
  Serial.print("AND_3_counter "); Serial.print(AND_3_counter);  Serial.print(" / AND_3_isset_counter "); Serial.println(AND_3_isset_counter);
  
  Serial.println();
}

[it doesn't matter (Gast)]

Ich hätte es wahrscheinlich so gemacht:

Einfach die ID's von Sensoren in einem 2D-Array speichern und die zweite 
Zeile gibt dann an, ob dieser Sensor schon mal aktiv war.

#define NUM_OF_SENSORS 6

#define SENSOR_ID 0
#define SENSOR_STATE 1

#define SENSOR_TEMP1    0 // SENSOR_ID==17
#define SENSOR_TEMP2    1 // SENSOR_ID==42
#define SENSOR_PRESSURE 2 // usw..
#define SENSOR_IR_FRONT 3
#define SENSOR_IR_LEFT  4
#define SENSOR_IR_RIGHT 5

uint8_t sensor[2][NUM_OF_SENSORS] = { { 17, 42, 92, 10, 38, 22 },
                                      { 0 } };

Eine Funktion zum Prüfen von gültigen ID's (gleichzeitig wird der Status 
bei gültigen ID's auf 1 gesetzt)

bool
is_valid_sensor_id(uint8_t sensor_id)
{
   for (size_t i = 0; i < NUM_OF_SENSORS; i++) {
      if (sensor[SENSOR_ID][i] == sensor_id) {
         sensor[SENSOR_STATE][i] = 1;
         return true;
      }
   }
   return false;
}

und dann bestimmte Kombinationen von Sensoren abfragen:

      if (is_valid_sensor_id(x)) {

         // sensors SENSOR_TEMP1 and SENSOR_IR_FRONT activated?
         if (sensor[SENSOR_STATE][SENSOR_TEMP1] &&
             sensor[SENSOR_STATE][SENSOR_IR_FRONT]) {
            
             do_something();

            // reset all states to 0
            memset(&sensor[SENSOR_STATE][0], 0, NUM_OF_SENSORS);
         }
      }

[Max (Gast)]

Hallo,
danke für deinen Vorschlag! Das klingt und sieht interessant aus. Ich 
versuche das zu verstehen und mal auszuprobieren

[Max (Gast)]

Hallo,

ich habe mal meine letzte Version hier angehängt. Deinen Vorschlag mit 
dem 2D Array fände ich gut, ich bin mir nur nicht sicher, wie man das 
implementieren könnte.
Deine Auswertung kann ich nicht übernehmen, da ich die IDs flexible über 
ein Menü in die einzelnen "Container" Arrays schieben möchte.
Also ob jetzt ID 12 im OR oder AND_1 Array ist, darf nicht im Programm 
fix sein.
Ich habe mal noch eine Zeichnung angehängt. Ansonsten macht mein 
Programm- bis auf die Bedingung, dass die AND Bedingungen innerhalb 2s 
erfolgen müssen- soweit alles korrekt. Bin mir nur sicher, man könnte es 
bestimmt noch effizienter und intelligenter machen. Das würde mich 
interessieren :)

#define NUM_OF_MAX_SENSORS 10

byte sensor_OR[NUM_OF_MAX_SENSORS] = {0}; 
byte sensor_AND_1[NUM_OF_MAX_SENSORS] = {0};
byte sensor_AND_2[NUM_OF_MAX_SENSORS] = {0};
byte sensor_AND_3[NUM_OF_MAX_SENSORS] = {0};

byte TRIGGERED_sensor_AND_1[NUM_OF_MAX_SENSORS] = {0}; //wenn ID gemeldet wurde, wird an der Position der ID eine 1 eingetragen
byte TRIGGERED_sensor_AND_2[NUM_OF_MAX_SENSORS] = {0};
byte TRIGGERED_sensor_AND_3[NUM_OF_MAX_SENSORS] = {0};


int OR_counter = 0;
int AND_1_counter = 0;
int AND_2_counter = 0;
int AND_3_counter = 0;

int OR_isset_counter = 0;
int AND_1_isset_counter = 0;
int AND_2_isset_counter = 0;
int AND_3_isset_counter = 0;


uint32_t start;
uint32_t stop;


void setup() {
/*
Es gibt 2 verschiedene Arten im Menü: Im Abschnitt OR sind alle Sensoren eingetragen, die ohne weitere Bedingung auslösen sollen
Im AND_1 Abschnitt werden IDs eingetragen, die nur dann auslösen, wenn alle darin eingetragenen IDs sich innerhalb von 2s melden.
AND_2 und AND_3 ebenso.
*/
  sensor_OR[0] = 18; 
  sensor_OR[1] = 2;

  sensor_AND_1[0] = 10;
  sensor_AND_1[1] = 11;

  sensor_AND_2[0] = 20;
  sensor_AND_2[1] = 21;

  sensor_AND_3[0] = 30;
  sensor_AND_3[1] = 31;
  sensor_AND_3[2] = 32;

  Serial.begin(115200);

}


boolean testinArray(byte val, byte arr[], int arrsize) //überprüft, ob ID im Array vorkommt
{
  for (int i = 0; i < arrsize; i++)
  {
    if (val == arr[i])
    {
      return true;
    }
  }
  return false;
}


int isset_counter(byte arr[], int arrsize)  //überprüft die Anzahl vorhandener Sensoren. 0=kein Sensor
{ int count = 0;
  for (int i = 0; i < arrsize; i++)
  {
    if (arr[i] > 0) {
      count++;  // wenn ID vorhanden, ID > 0
    }
  }
  return count;
}

void loop() {

  Serial.println("Enter Number : ");
  while (Serial.available() == 0)
  {}
  byte ID = Serial.readString().toInt();



  Serial.print("ID "); Serial.println(ID);

  if (testinArray(ID, sensor_OR, NUM_OF_MAX_SENSORS ))    {
    Serial.println("OR Auslösen");
  }


  int pos1 = linearSearchBreak(ID, sensor_AND_1, NUM_OF_MAX_SENSORS);
  if (pos1 > -1) {    TRIGGERED_sensor_AND_1[pos1] = 1;  }

  int pos2 = linearSearchBreak(ID, sensor_AND_2, NUM_OF_MAX_SENSORS);
  if (pos2 > -1) {    TRIGGERED_sensor_AND_2[pos2] = 1;  }

  int pos3 = linearSearchBreak(ID, sensor_AND_3, NUM_OF_MAX_SENSORS);
  if (pos3 > -1) {    TRIGGERED_sensor_AND_3[pos3] = 1;  }


  //Wenn die gemeldeten IDs innerhalb eines Arrays alle angekommen sind, dann wird ausgelöst.
  if (isset_counter(sensor_AND_1, NUM_OF_MAX_SENSORS) == isset_counter(TRIGGERED_sensor_AND_1, NUM_OF_MAX_SENSORS)) { Serial.println("AND 1 Auslösen"); memset(TRIGGERED_sensor_AND_1, 0, NUM_OF_MAX_SENSORS); }
  if (isset_counter(sensor_AND_2, NUM_OF_MAX_SENSORS) == isset_counter(TRIGGERED_sensor_AND_2, NUM_OF_MAX_SENSORS)) { Serial.println("AND 2 Auslösen"); memset(TRIGGERED_sensor_AND_2, 0, NUM_OF_MAX_SENSORS); }
  if (isset_counter(sensor_AND_3, NUM_OF_MAX_SENSORS) == isset_counter(TRIGGERED_sensor_AND_3, NUM_OF_MAX_SENSORS)) { Serial.println("AND 3 Auslösen"); memset(TRIGGERED_sensor_AND_3, 0, NUM_OF_MAX_SENSORS); }
 
 

  Serial.println();
}




int linearSearchBreak(byte val, byte arr[], int sz)
{
  int pos = -1;
  for (int i = 0; i < sz; i++)
  {
    if (arr[i] == val)
    {
      pos = i;
      break;
    }
  }
  return pos;
}

[Max (Gast)]

Hallo, etwas konnte ich das Programm nun noch zusammenraffen:
Das ist jetzt der letzte Stand. Sieht da jemand noch 
Verbesserungspotential und wie könnte ich am Geschicktesten etwas 
einbauen, damit ein Zeitfenster von 2 sekunden besteht während die AND.. 
Eingaben erfolgen müssen?

#define SENSOR_ID 0
#define SENSOR_STATE 1


#define NUM_OF_MAX_SENSORS 10

byte sensor_OR[NUM_OF_MAX_SENSORS] = { 0 };
byte sensor_AND_1[2][NUM_OF_MAX_SENSORS] = { { 0 }, { 0 } };
byte sensor_AND_2[2][NUM_OF_MAX_SENSORS] = { { 0 }, { 0 } };
byte sensor_AND_3[2][NUM_OF_MAX_SENSORS] = { { 0 }, { 0 } };



uint32_t start;
uint32_t stop;


void setup() {
/*
Es gibt 2 verschiedene Arten im Menü: Im Abschnitt OR sind alle Sensoren eingetragen, die ohne weitere Bedingung auslösen sollen
Im AND_1 Abschnitt werden IDs eingetragen, die nur dann auslösen, wenn alle darin eingetragenen IDs sich innerhalb von 2s melden.
AND_2 und AND_3 ebenso.
*/
  sensor_OR[0] = 18; 
  sensor_OR[1] = 2;

  sensor_AND_1[SENSOR_ID][0] = 10;
  sensor_AND_1[SENSOR_ID][1] = 11;

  sensor_AND_2[SENSOR_ID][0] = 20;
  sensor_AND_2[SENSOR_ID][1] = 21;

  sensor_AND_3[SENSOR_ID][0] = 30;
  sensor_AND_3[SENSOR_ID][1] = 31;
  sensor_AND_3[SENSOR_ID][2] = 32;

  Serial.begin(115200);

}



void loop() {

  Serial.println("Enter Number : ");
  while (Serial.available() == 0)
  {}
  byte ID = Serial.readString().toInt();

  if (is_valid_sensor_id_OR(ID)) { Serial.print(ID); Serial.println(" in OR ausgelöst"); }
  if (is_valid_sensor_id_AND_1(ID)) { Serial.print(ID); Serial.println(" in AND_1"); }
  if (is_valid_sensor_id_AND_2(ID)) { Serial.print(ID); Serial.println(" in AND_2"); }
  if (is_valid_sensor_id_AND_3(ID)) { Serial.print(ID); Serial.println(" in AND_3"); }

 start = micros();
 if (isset_counter(sensor_AND_1[SENSOR_STATE], NUM_OF_MAX_SENSORS)==isset_counter(sensor_AND_1[SENSOR_ID], NUM_OF_MAX_SENSORS)) { Serial.println(" AND_1 ausgelöst"); memset(sensor_AND_1[SENSOR_STATE], 0, NUM_OF_MAX_SENSORS); }
 if (isset_counter(sensor_AND_2[SENSOR_STATE], NUM_OF_MAX_SENSORS)==isset_counter(sensor_AND_2[SENSOR_ID], NUM_OF_MAX_SENSORS)) { Serial.println(" AND_2 ausgelöst"); memset(sensor_AND_2[SENSOR_STATE], 0, NUM_OF_MAX_SENSORS); }
 if (isset_counter(sensor_AND_3[SENSOR_STATE], NUM_OF_MAX_SENSORS)==isset_counter(sensor_AND_3[SENSOR_ID], NUM_OF_MAX_SENSORS)) { Serial.println(" AND_3 ausgelöst"); memset(sensor_AND_3[SENSOR_STATE], 0, NUM_OF_MAX_SENSORS); }

  stop = micros();
  Serial.println(stop - start);

 
  Serial.println();
}

boolean is_valid_sensor_id_OR(byte val) //überprüft, ob ID im Array vorkommt
{
  for (int i = 0; i < NUM_OF_MAX_SENSORS; i++)
  {
    if (val == sensor_OR[i])
    { 
      return true;
    }
  }
  return false;
}


bool is_valid_sensor_id_AND_1(uint8_t sensor_id)
{
   for (size_t i = 0; i < NUM_OF_MAX_SENSORS; i++) {
      if (sensor_AND_1[SENSOR_ID][i] == sensor_id) {
         sensor_AND_1[SENSOR_STATE][i] = 1;
         return true;
      }
   }
   return false;
}

bool is_valid_sensor_id_AND_2(uint8_t sensor_id)
{
   for (size_t i = 0; i < NUM_OF_MAX_SENSORS; i++) {
      if (sensor_AND_2[SENSOR_ID][i] == sensor_id) {
         sensor_AND_2[SENSOR_STATE][i] = 1;
         return true;
      }
   }
   return false;
}

bool is_valid_sensor_id_AND_3(uint8_t sensor_id)
{
   for (size_t i = 0; i < NUM_OF_MAX_SENSORS; i++) {
      if (sensor_AND_3[SENSOR_ID][i] == sensor_id) {
         sensor_AND_3[SENSOR_STATE][i] = 1;
         return true;
      }
   }
   return false;
}

int isset_counter(byte arr[], int arrsize)  //überprüft die Anzahl vorhandener Sensoren. 0=kein Sensor
{ int count = 0;
  for (int i = 0; i < arrsize; i++)
  {
    if (arr[i] > 0) {
      count++;  // wenn ID vorhanden, ID > 0
    }
  }
  return count;
}