Schleife für 1024 Binäre Möglichkeiten? "5Bit"

Ich möchte Funksteckdosen schalten und zwar möchte ich mittels Bruteforce alle 5Bit Möglichkeiten der Systemcodes und Steckdosen Codes abarbeiten. Später soll mir auf dem Display ausgeben werden welche Codes geschaltet werden gerade, das ist aber Nebensache.

Im moment zerbrech ich mir gerade den Kopf wie ich ne for schleife oder dergleichen mit der rcswitch Lib verbinde.

#include<RCSwitch.h>

RCSwitch mySwitch =RCSwitch();

void setup(){
  //Starte die Übertragung an Pin 10 oder wo Data angeschlossen sein mag
  mySwitch.enableTransmit(10);
}

void loop(){

  // Befehl zum Anschalten 
  // 1. Gruppe = Systemcode Register 1-5 
  // 2. Gruppe = Steckdose A-E (Register 6-9)

  mySwitch.switchOn("11011","00100");

Kann mir jemand nen Tip geben wie ich zuerst das Systemcode register generiere , dort alle 32 Möglichkeiten der 2.Gruppe abarbeite und danach in der ersten Gruppe eine Möglichkeit weiter gehen und dann wieder 2. Gruppe abarbeite.

Ich hoffe ihr versteht was ich meine.

Lg Oli

Sowas??

for(int Systemcode =0; Systemcode<32; Systemcode++)
  {
  for(int Steckdose =0; Steckdose<16; Steckdose++)
     {
     mySwitch.switchOn("Systemcode","Steckdose");
     }
  }

Hallo,

wollte gerade mit tippen anfangen nach Überlegung und dann war einer schneller ... :slight_smile:

Einen Link gebe ich aber noch dazu. http://c-buch.sommergut.de/Kapitel7/Verschachtelte-Schleifen.shtml

Das Problem könnte aber für ihn sein, dass er aus der for Schleife nicht eher rauskommt bevor sie fertig ist. Dann müßte er ohne for Schleifen inkremmentieren und Nullen usw.

Das ist auf jeden fall ne Idee, nur muss ich die zahlen halt in binär kriegen also ala 00101

Lg Oli

Doc_Arduino:
Das Problem könnte aber für ihn sein, dass er aus der for Schleife nicht eher rauskommt bevor sie fertig ist. Dann müßte er ohne for Schleifen inkremmentieren und Nullen usw.

Aus einer einzelnen for-Schleife kommt man mit break raus. Aus verschachtelten for-Schleifen auszubrechen ist eine der seltenen legitimen Verwendungen von goto :slight_smile:

Eine andere Alternative ist ein flag, das man mit der Schleifen-Bedingung abfragt und auf false setzt wenn man aufhören will.

Zyrusthc:
Das ist auf jeden fall ne Idee, nur muss ich die zahlen halt in binär kriegen also ala 00101

Zahlen in Strings mit verschiedenen Basen umzuwandeln geht mit itoa():
http://www.cplusplus.com/reference/cstdlib/itoa/
http://www.nongnu.org/avr-libc/user-manual/group__avr__stdlib.html#gaa571de9e773dde59b0550a5ca4bd2f00

  1. Parameter: Integer-Wert den man wandeln will
  2. Parameter: char Array das groß genug für den größten String + 1 ist
  3. Parameter: Basis des Zahlensystems, z.B. 2, 10 oder 16

Das rauskommen is nicht das problem, wie schon gesagt wurde nen break und das mit nen button verbinden zb.

Kann mir noch jemand sagen wie ich die Zahlen ins Binäre Format kriege?

Er soll ja so abarbeiten
00000
00001
00011
00111
01111
11111
01001
01011
01010
01110
01100
usw

Serenifly:

Zyrusthc:
Das ist auf jeden fall ne Idee, nur muss ich die zahlen halt in binär kriegen also ala 00101

Zahlen in Strings mit verschiedenen Basen umzuwandeln geht mit itoa():
http://www.cplusplus.com/reference/cstdlib/itoa/
avr-libc: <stdlib.h>: General utilities

  1. Parameter: Integer-Wert den man wandeln will
  2. Parameter: char Array das groß genug für den größten String + 1 ist
  3. Parameter: Basis des Zahlensystems, z.B. 2, 10 oder 16

Ach ja, wenn du unbedingt eine konstante Breite brauchst (also z.B. "000" statt "0") könnte man z.B. das machen:

	char buffer[9];
	const int WIDTH = 8;

	int value = 96;
	itoa(value, buffer, 2);

	int length = strlen(buffer);
	if(length < WIDTH)
	{
		memmove(buffer - length + WIDTH, buffer, length + 1);
		for(int i = 0; i < WIDTH - length; i++)
			*(buffer + i) = '0';
	}

Das verschiebt den resultierenden String um die Differenz zwischen gewünschter Breite und tatsächlicher Länge nach rechts und füllt dann links mit Nullen auf.

Also so wenn ich das richtig verstanden habe:

 for(int Systemcode =0; Systemcode<32; Systemcode++)
  {
  for(int Steckdose =0; Steckdose<16; Steckdose++)
     {
     char buf[6];
       mySwitch.switchOn(itoa(Systemcode, buf, 2) ,itoa(Steckdose, buf, 2));

Du brauchst zwei getrennte Puffer dafür! Sonst überschreibst du beim zweiten Aufruf den ersten String.

Und das produziert keine führenden Nullen. Keine Ahnung ob der String immer konstant 5 Zeichen breit sein muss. Habe oben mal eine Lösung hingeschrieben.
Sich selbst eine Konvertierungsfunktion zu schreiben die das von Anfang an macht wäre hier eventuell schneller.

Aber wenn du mit "0" statt "00000" oder "10" statt "00010" leben kannst, reicht einfach itoa()

Wobei man es auch ganz einfach machen könnte und einfach ein Array aus allen Strings anlegen könnte. Bei nur 5 Zeichen ist das nicht viel (32 * 6 Bytes). Dann kann man einfach mit der Zahl als Index den gewünschten String erhalten :slight_smile:

Es müssen definitiv werte wie 00010 sein. Hmmm . Ich bin kein C Kenner geb ich ganz ehrlich zu da qualmt mir immer der Kopf. Mal schauen wie ich das rein bekomme

Eine simple Tabelle ist wohl das einfachste und schnellste:

	char string_table[][6] =
	{
		"00000",
		"00001",
                ....
		"11111"
	};

Hat bei 5 Ziffern nur 2 ^ 5 = 32 Einträge. Dann kannst du einfach mit string_table[zahl] den String herauspicken

Danke für die Tips , so läuft es

#include<RCSwitch.h>

RCSwitch mySwitch =RCSwitch();

char string_table[][6] =
	{
          "00000",
          "00001",
          "00011",
          "00010",
          "00110",
          "00111",
          "00101",
          "00100",
          "01100",
          "01101",
          "01111",
          "01110",
          "01010",
          "01011",
          "01001",
          "01000",
          "11000",
          "11001",
          "11011",
          "11010",
          "11110",
          "11111",
          "11101",
          "11100",
          "10100",
          "10101",
          "10111",
          "10110",
          "10010",
          "10011",
          "10001",
          "10000"
};

void setup(){
  //Starte die Übertragung an Pin 10 oder wo Data angeschlossen ist
  mySwitch.enableTransmit(10);
  
  Serial.begin(9600);
  Serial.println("Testprogramm");
}

void loop(){

  // Befehl zum Anschalten 
  // 1. Gruppe = Systemcode Register 1-5 
  // 2. Gruppe = Steckdose A-E (Register 6-9)
 for(int Systemcode =0; Systemcode<32; Systemcode++)
  {
  for(int Steckdose =0; Steckdose<32; Steckdose++)
     {
  mySwitch.switchOn(string_table[Systemcode] ,string_table[Steckdose]);
  Serial.print(string_table[Systemcode]); Serial.print("\t"); Serial.println(string_table[Steckdose]);

     }
  }

  delay(2000);
  
  //mySwitch.switchOff("11011","00100");
  //delay(1000); 
}

Lg Oli

Jetz weiß ich nicht welche Bibliothek Du benutzt aber hier

Ist einen Übergabe der Adressen nicht nur als String soondern auch als Zahl möglich.

   void switchOn(int nGroupNumber, int nSwitchNumber);
    void switchOff(int nGroupNumber, int nSwitchNumber);
    void switchOn(char* sGroup, int nSwitchNumber);
    void switchOff(char* sGroup, int nSwitchNumber);
    void switchOn(char sFamily, int nGroup, int nDevice);
    void switchOff(char sFamily, int nGroup, int nDevice);
        void switchOn(char* sGroup, char* sDevice);
        void switchOff(char* sGroup, char* sDevice);

Grüße Uwe

Da bräuchte ich aber genau so ein Array mit den Zahlen die zu den DIP Positionen passen. Und da ich mir eh die DIP Werte ausgeben lassen möchte is das ja jetzt genauso wie ich es haben wollte.

Auch eine Zahl kannst Du als Binärzahl ( Nullen und Einsen) ausgeben. Dazu brauchst Du keinen String.
Grüße Uwe

uwefed:
Auch eine Zahl kannst Du als Binärzahl ( Nullen und Einsen) ausgeben. Dazu brauchst Du keinen String.
Grüße Uwe

Ja das weiss ich aber was währe den jetzt mein Vorteil davon? Die Zahlen währen ja nicht aufeinander folgend wie ich ich sie im Ablauf brauche. So das ein einfacher Zähler weg fällt.

Lg Oli

Du verbrauchst weniger RAM. 192 Bytes sind das schon fürs Array. Ich weiß nicht wie Du die Ausgabe machst aber da kommen dann sicher auch noch etwas RAM zusammen.
Grüße Uwe

Hallo,

warum sollen die nicht aufeinanderfolgend sein? Eine Zahl bleibt immer die gleiche, nur in verschiedenen Zahlensystemem eben verschieden dargestellt.

dezimal 0 ist binär 0
dezimal 1 ist binär 1
dezimal 2 ist binär 10
dezimal 3 ist binär 11
...
dezimal 9 ist binär 1001
usw.

jeweils binär ohne führende Null(en) geschrieben.

Außerdem, fällt mir gerade auf, wie kommt man mit 5Bit auf 1024 mögliche Bitkombinationen? Ich denke, Du müßtest Dich mit Zahlensystemen und deren Umrechnung näher befassen.