Moin,
gibt es eine schnelle und saubere Möglichkeit eine Bedingung zu vergleichen wenn die Werte im array[] stecken --> genauer gesagt:
array[5] = { 0,0,1,0,0,0 };
nun will ich eine if() abfrage haben und schauen ob alle anderen Werte als
array[1] = 0;
sind. Wei kann ich das schnell und einfach in einer if() abfrage verpacken?
Beste
Z
nun will ich eine if() abfrage haben und schauen ob alle anderen Werte als
Code: [Select]
array[1] = 0;sind.
Würde ja gerne einen Tipp geben, aber verstehe die Frage nicht.
haha okay das war ein bischen schlecht ausgedrückt:
Schalter 2 hat position array[1] im array und würde Led 2 zum blinken bringen. Nun will ich schauen ob eine andere Led schon blinkt. deswegen will ich schauen:
if( (Schalter 2 = =True) && (alle anderen Werte im array == False)) --> dann hau raus
bis jetzt hab ich nur die idee jede einzelne stelle im array abzufragen:
if( (Schalter 2 = =True) && (array[0] == 0) && (array[2] == 0) && (so weiter))) --> dann hau raus
Das geht nicht:
gnom:
array[5] = { 0,0,1,0,0,0 };
das geht: [edit] noch mit der zweiten Variante ausgestattet[/edit]
bool array[6] = {0, 1, 0, 0, 0, 1};
void setup() {
Serial.begin(115200);
Serial.println(F("Start...."));
bool vergleichsposition = 1;
for (int i = 0; i < sizeof(array); i++)
if (i != vergleichsposition)
{
if (array[i] != array[vergleichsposition])
{
Serial.print(F("ungleicher Inhalt Position "));
Serial.print(i);
Serial.print(F(" Inhalt: "));
Serial.println(array[i]);
}
if (array[i] == array[vergleichsposition])
{
Serial.print(F("gleicher Inhalt Position "));
Serial.print(i);
Serial.print(F(" Inhalt: "));
Serial.println(array[i]);
}
}
}
void loop() {
// put your main code here, to run repeatedly:
}
wenn du deine LEDs einfach je einer Bitposition in einer Variable activeLeds zuweist (statt einem Array), sparst du dir nicht nur SRAM (weil du pro 8 LEDs nur ein byte brauchst) sonder du hättest auch einen einfachen Vergleich mittells
activeLeds > 0
gnom:
... schnell und einfach
Merker vom Typ bool kann man auch bitweise speichern, siehe Bits und Bytes der Sprach-Referenz. Mit bitClear löscht man dann das zu prüfende Bit. Ist das Ergebnis ungleich Null, ist noch ein anderes Bit gesetzt. Die Bits werden von rechts nach links gezählt und starten bei 0.
void setup() {
Serial.begin(9600);
Serial.println(F("\nStart...."));
// 76543210
byte blinkendeLeds = 0b00010000;
byte pos = 3;
blinkts(blinkendeLeds, pos);
pos = 4;
blinkts(blinkendeLeds, pos);
}
void loop() {
// put your main code here, to run repeatedly:
}
void blinkts(byte bitmuster, byte vergleichsposition) {
if (bitClear(bitmuster, vergleichsposition)) {
Serial.print(F("Eine LED blinkt an anderer Position als "));
} else {
Serial.print(F("Eine LED blinkt nicht an anderer Position als "));
}
Serial.println(vergleichsposition);
}
Herr Rothschopf war schneller!
array[5] = { 0,0,1,0,0,0 };
Du kannst nicht 6 Werte in ein 5 Element-Array speichern.
Grüße Uwe
agmue:
Herr Rothschopf war schneller!
nur weil ich kein Beispiel gemacht habe ^^
byte activeLeds = 0;
void checkMyVariable()
{
Serial.print(activeLeds, BIN);
if (activeLeds) Serial.println(" ->irgendwas ist an"); else Serial.println(" -> ois is aus");
}
void setup() {
// put your setup code here, to run once:
Serial.begin(9600);
checkMyVariable();
// einschalten:
activeLeds |= bit(0); // OR
checkMyVariable();
bitSet(activeLeds, 2); // geht auch
checkMyVariable();
activeLeds |= bit(4);
checkMyVariable();
// ausschalten
bitClear(activeLeds, 0);
checkMyVariable();
bitClear(activeLeds, 2);
checkMyVariable();
bitClear(activeLeds, 4);
checkMyVariable();
}
void loop() {
}
0 -> ois is aus
1 ->irgendwas ist an
101 ->irgendwas ist an
10101 ->irgendwas ist an
10100 ->irgendwas ist an
10000 ->irgendwas ist an
0 -> ois is aus
Meinst du sowas?
bool everythingElseIsZero(uint8_t element, bool *Array, uint8_t len) {
for (uint8_t i = 0; i < len; i++) {
if (i == element) continue;
if (Array[i]) return 0;
}
return 1;
}
void setup() {
Serial.begin(115200);
bool Array[] = {0, 0, 1, 0, 0, 0};
if (everythingElseIsZero(2, Array, sizeof(Array)))
Serial.println("Außer dem 2. Element sind alle Elemente 0");
else
Serial.println("Außer dem 2. Element sind nicht alle Elemente 0");
if (everythingElseIsZero(4, Array, sizeof(Array)))
Serial.println("Außer dem 4. Element sind alle Elemente 0");
else
Serial.println("Außer dem 4. Element sind nicht alle Elemente 0");
}
gruß lorenz
Ich denke, der TO sollte uns erst mal mitteilen, ob das Beispiel, dass alle Werte 0/1 sind zwingend ist oder ob auch andere Werte auftreten konnen.
Gruß Tommy
Tommy56:
auch andere Werte auftreten konnen.
Davon war ich auch ausgegangen.
Aber mein #3 hat sich mit seinem #2 überschnitten und da klärt er auf, das es nur um true/false geht.
Ich hätte dann ne Mischung aus agmue (bitClear() und noiasca x>0 mit einer Zwischenvariablen angeboten.
Danke, das #2 habe ich irgendwie überlesen.
Ich würde den gesuchten Wert ermitteln (0 oder 1 an Position x) und dann über das Array in einer for-Schleife laufen und wenn der Wert != dem x-Wert ist mit return false (einer ist anders) zurück gehen. Am Ende mit return true (alle gleich)
Gruß Tommy
Kabooooom - minblowin'!
Ihr macht mich fertig. Vielen Dank für die vielen Antworten...ich sehe ich muss mir das mit den bits nochmal anschauen - ich habe sowas von keinen plan worüber ihr grad redet....also jedenfalls nur grundlegend. Das es am Anfang eben immer noch etwas zu lernen gibt.
Ich frage mal vorsichtig....Wann machen bits Sinn und wann arbeite ich mit integern ( ich hoffe ich drücke mich richtig aus)?
PS. natürlich macht ein array[5] mit 6 werten kein Sinn - wer zählen kann ist klar im Vorteil - aber auch nicht beabsichtig
gnom:
Ich frage mal vorsichtig....Wann machen bits Sinn und wann arbeite ich mit integern ( ich hoffe ich drücke mich richtig aus)?
Zustände werden gespeichert in einem Bit. (true/false - HIGH/LOW - 0/1)
Wenn Du nur Zustände brauchst, reicht ein Bit.
Dann kannst Du mit einem Byte 8 Bits erschlagen und brauchst keine 8 bytes (im Array).
Du kannst auch zwei Byte nutzen und damit 16 Zustände darstellen und nicht 16 Bytes benutzen.
Das Bimbrosium darum ist zwar erstmal gewöhnungsbedürftig, aber bei reinen Zustandsabfragen schnell gelernt.
Für den ersten Einsatz siehe #3. Da wird jeder Zustand als byte genommen. Ich bin davon ausgegangen, das Du da irgendwelche Steuerwerte reinschreibst für die LED.
Für die Zukunft dann agmue seinem Vorschlag folgen.
Ergänzung: Und int für Zustände schon überhaupt nicht, weil das 2 Bytes braucht.
Gruß Tommy
Equivalente mit einem 8Bit-Integer satt eines bool Arrays:
uint8_t activeLEDs=0b00010000; //Entspricht: bool Array[8]={0,0,0,1,0,0,0,0};
activeLEDs=activeLEDs | (1<<N); //Entspricht: Array[N]=1;
activeLEDs=activeLEDs & ~(1<<N); //Entspricht: Array[N]=0;
activeLEDs=activeLEDs ^ (1<<N); //Entspricht: Array[N]= !Array[N];
if ((activeLEDs>>N)&1) //Entspricht: if (Array[N]==1)
if (!(activeLEDs>>N)&1) //Entspricht: if (Array[N]==0)
Sieht erstmal kompliziert aus, ermöglicht aber sehr effiziente Abfragen, wie von dir gewünscht:
if (activeLEDs ^ (1<<N) //Prüfen ob mindestens ein anderes Bit gleich 1 ist
if (!(activeLEDs ^ (1<<N)) //Prüfen ob alle anderen Bits gleich 0 sind
gruß lorenz
gnom:
Wann machen bits Sinn und wann arbeite ich mit integern
Ganz grundsätzlich kann man diese Frage nicht beantworten, das hängt von einem selbst und der Umgebung ab.
Ich habe mit Z80 und Speichergrößen angefangen, die in Kilobytes gemessen wurden. Da war Speicher sehr kostbar. Das gilt auch für die kleinen Arduinos, weshalb ich da immer etwas knauserig bin.
bool array[6] = {0, 1, 0, 0, 0, 1};
Das ist der klassische Ansatz, vollkommen OK. Auch wenn nur sechs Bits gespeichert werden, so werden aber sechs Bytes Speicher benötigt.
byte blinkendeLeds = 0b00010000;
Hier können bis zu acht binäre Zustände in nur einem Byte gespeichert werden, das spart Speicher, ist aber nicht meine Hauptmotivation.
gnom:
... schnell und einfach in einer if() abfrage ...
Das mache ich hier:
if (bitClear(bitmuster, vergleichsposition)) { ...
Wunsch erfüllt, Aufgabe gelöst 
Programmieren ist kreativ, weshalb es auch viele Wege zum Ziel gibt, mit unterschiedlichen Vor- und Nachteilen. Darum bin ich hier aktiv, weil ich die Wege der anderen kennenlernen möchte und meine zur Diskussion stelle.
Katschinggggg!
Okay ich hab mich über Datentypen schlau gemacht und das wird heute nochmal meine Aufgabe sein mich damit zu befassen was, wann, wo und warum. Ich danke euch für die vielen Informationen...ich muss das als Anfänger erst einmal verarbeiten! Aber Bombe das so ein Feedback kam und so genau auf meine Frage eingegangen wurde! ich kann da nur einen ganz großen zitieren:
Reeespekt! - Ali G in da house 2002
gnom:
Kabooooom - minblowin'!
Mach dir keine Sorgen....
Bei dem Einen geht es wieder, und andere kommen da nie raus.
gnom:
Ich frage mal vorsichtig....Wann machen bits Sinn und wann arbeite ich mit integern ( ich hoffe ich drücke mich richtig aus)?
Das ist doch klar!
Das liegt genau und exakt an deinen Prioritäten!
Und daran, was die Hardware so von Natur aus kann und welche Möglichkeiten der Kompiler bietet.
Wohin soll die "Optimierung" gehen?
Speicherverbrauch, Faulheit oder Speed, stehen zur Auswahl.
Wenn es sich nur um das zählen von LEDs in einem Bitfeld dreht...
#include <Streaming.h>
void setup()
{
unsigned int bitfeld {0b001000101};
Serial.begin(9600);
Serial << "Es blinken "<< __builtin_popcount(bitfeld) << " Leds" << endl;
}
void loop(){}