Zufallsgenerator der Ausgänge steuert

Hallo,

ich bin ziemlich neu in der Arduinowelt, ich kann zwar ein wenig programmieren allerding ist mein C sehr eingerostet weswegen ich die Letzen Jahre mit KOP meine SPS Programmiert habe.

Jetzt zu meinem Problem. Ich möchte einen "Zufallsgenerator" der immer 2 Ausgänge meines Arduinos beschaltet.

Ich habe dafür PIN 6-13 zu Ausgängen gemacht welche Relais schalten sollen.

ich habe auch schon ein Programm allerdings schaltet es bis jetzt auch mehr als 2 Ausgänge gleichzeitig.

Am Anfang werden alle Relais nacheinander Bestromt und wieder Spannungslos geschaltet.

int Relais1 = 6;
int Relais2 = 7;
int Relais3 = 8;
int Relais4 = 9;
int Relais5 = 10;
int Relais6 = 11;
int Relais7 = 12;
int Relais8 = 13;

void setup() {                
 pinMode(Relais1 , OUTPUT);
 pinMode(Relais2 , OUTPUT);
 pinMode(Relais3 , OUTPUT);
 pinMode(Relais4, OUTPUT);
 pinMode(Relais5, OUTPUT);
 pinMode(Relais6, OUTPUT);
 pinMode(Relais7, OUTPUT);
 pinMode(Relais8, OUTPUT);
}
void loop() {
  digitalWrite (Relais1, HIGH);
   delay(100);
  digitalWrite (Relais2, HIGH);
   delay(100);
  digitalWrite (Relais3, HIGH);
   delay(100);
  digitalWrite (Relais4, HIGH);
   delay(100);
  digitalWrite (Relais5, HIGH);
   delay(100);
  digitalWrite (Relais6, HIGH);
   delay(100);
  digitalWrite (Relais7, HIGH);
   delay(100);
  digitalWrite (Relais8, HIGH);
   delay(100);
  digitalWrite (Relais1, LOW);
   delay(100);
  digitalWrite (Relais2, LOW);
   delay(100);
  digitalWrite (Relais3, LOW);
   delay(100);
  digitalWrite (Relais4, LOW);
   delay(100);
  digitalWrite (Relais5, LOW);
   delay(100);
  digitalWrite (Relais6, LOW);
   delay(100);
  digitalWrite (Relais7, LOW);
   delay(100);
  digitalWrite (Relais8, LOW);
   delay(100);



    digitalWrite (Relais1, HIGH);
   delay(100);
  digitalWrite (Relais2, HIGH);
   delay(100);
  digitalWrite (Relais3, HIGH);
   delay(100);
  digitalWrite (Relais4, HIGH);
   delay(100);
  digitalWrite (Relais5, HIGH);
   delay(100);
  digitalWrite (Relais6, HIGH);
   delay(100);
  digitalWrite (Relais7, HIGH);
   delay(100);
  digitalWrite (Relais8, HIGH);
   delay(100);
  digitalWrite (Relais1, LOW);
   delay(100);
  digitalWrite (Relais2, LOW);
   delay(100);
  digitalWrite (Relais3, LOW);
   delay(100);
  digitalWrite (Relais4, LOW);
   delay(100);
  digitalWrite (Relais5, LOW);
   delay(100);
  digitalWrite (Relais6, LOW);
   delay(100);
  digitalWrite (Relais7, LOW);
   delay(100);
  digitalWrite (Relais8, LOW);
   delay(1000);



 if (random(100) < 50)
   digitalWrite(Relais1, HIGH);
 else
   digitalWrite(Relais1, LOW);
 if (random(100) < 50)
   digitalWrite(Relais2, HIGH);
 else
   digitalWrite(Relais2, LOW);
 if (random(100) < 50)
   digitalWrite(Relais3, HIGH);
 else
   digitalWrite(Relais3, LOW);
 if (random(100) < 50)
   digitalWrite(Relais4, HIGH);
 else
   digitalWrite(Relais4, LOW);
 if (random(100) < 50)
   digitalWrite(Relais5, HIGH);
 else
   digitalWrite(Relais5, LOW);
 if (random(100) < 50)
   digitalWrite(Relais6, HIGH);
 else
   digitalWrite(Relais6, LOW);
 if (random(100) < 50)
   digitalWrite(Relais7, HIGH);
 else
   digitalWrite(Relais7, LOW);
 if (random(100) < 50)
   digitalWrite(Relais8, HIGH);
 else
   digitalWrite(Relais8, LOW);


 
 delay(1000);//15´000´000 = 4.std  


 
}

Vielen Dank im vorraus.

Zufall_Relais_steuerung_V2.ino (2.75 KB)

Was du machen könntest:

  1. Schritt: zwei unterschiedliche Zufallszahlen finden.
  2. Schritt: Die zwei gewählten Relais einschalten
  3. Schritt: Warten
  4. Schritt: Die zwei Relais ausschalten

Wenn ich es falsch verstanden habe, korrige den Ablauf.
und ... suche nach Arrays ... das verkürzt deinen Code MASSIV.

Und poste mal einen Hyperlink von deinen Relais.
Die üblichen Relaismodule sind LOW-aktiv, was bedeutet, die schalten bei LOW auf dem Steuerpin.
Dann müsstest du deinen Sketch anpassen.

Dein Zufallsgenerator besteht nicht aus 2 Zufällen, die einen Ausgang schalten, sondern Du sagst jedem Ausgang er soll zufällig schalten.
Damit kann bei jedem Durchlauf zwischen 0 und 8 geschalteten Relais alles möglich werden.

Du hast 8 Relais.
Verwende für die Ansteuerung ein Array.
Generiere 2 Zusatzzahlen zwischen 0 und 7. Kontrolliere dabei ob die Zahlen nicht gleich sind. Wenn ja ändere eine durch eine neue Zusatzzahl.

Jetzt schaltest Du 2 Relais ein.

relais[8] = {6,7,8,9,10,11,12,13};

digitalWrite (relais[Zufallszahl1], HIGH);
digitalWrite (relais[Zufallszahl2], HIGH);
delay();

digitalWrite (relais[Zufallszahl1], LOW);
digitalWrite (relais[Zufallszahl2], LOW);

Grüße Uwe

Uwe, der Spielverderber.

Na dann.

/*
  by noiasca
*/


const byte outputPin[] {13, 12, 11, 10, 9, 8, 7, 6};     // https://www.arduino.cc/reference/en/language/variables/data-types/array/
const byte noOfOutputs = sizeof(outputPin);              // https://www.arduino.cc/reference/de/language/variables/utilities/sizeof/
byte relayA = 0, relayB = 1;

void setup() {
  Serial.begin(115200);
  Serial.print(F("\nSelect 2 from "));                   // https://www.arduino.cc/reference/de/language/variables/utilities/progmem/
  Serial.println(noOfOutputs);
  for (byte i = 0; i < noOfOutputs; i++)                 // https://www.arduino.cc/reference/en/language/structure/control-structure/for/
    pinMode(outputPin[i], OUTPUT);
  randomSeed(A0);                                        // https://www.arduino.cc/reference/en/language/functions/random-numbers/randomseed/
}

void loop() {
  // 1. Schritt: zwei unterschiedliche Zufallszahlen finden.
  relayA = random(noOfOutputs);                          // https://www.arduino.cc/reference/en/language/functions/random-numbers/random/
  do                                                     // https://www.arduino.cc/reference/en/language/structure/control-structure/dowhile/
  {
    relayB = random(noOfOutputs);
  }
  while (relayA == relayB);
  Serial.print (F("relayA=")); Serial.print(relayA); Serial.print (F(" pin=")); Serial.println(outputPin[relayA]);
  Serial.print (F("relayB=")); Serial.print(relayB); Serial.print (F(" pin=")); Serial.println(outputPin[relayB]);
  
  // 2. Schritt: Die zwei gewählten Relais einschalten
  digitalWrite(outputPin[relayA], HIGH);
  digitalWrite(outputPin[relayB], HIGH);
  
  // 3. Schritt: Warten
  delay(1000); // dirty delay

  // 4. Schritt: Die zwei Relais ausschalten
  digitalWrite(outputPin[relayA], LOW);
  digitalWrite(outputPin[relayB], LOW);
}

noiasca:
Uwe, der Spielverderber.

Wieso siehst Du das so?
Der TO muß immernoc einiges an Arbeit investieren um einen Funktionierenden Sketch zu bekommen. Ich habe ihm nur die Richtung gezeigt. Verstehen muß er es noch um es Umzusetzen zu können.
Ich habe ihm ja keinen lauffähigen Sketch gegeben.
Grüße Uwe

Das sind meine Relais:

Vielen Dank für die ganzen tollen Tipps, ich habe mir mal das Skript von "noiasca" angeschaut und ich glaube ich habe das Prinzip verstanden.

Ich hatte die ganze Zeit den falschen Ansatz. Vom KOP programmieren war ich es gewohnt meine Skripte eher so zu schreiben:
digitalWrite(Relais1, HIGH && Relais2 == HIGH && Relais3 == LOW && Relais4 ==LOW ……);

Hätte mir dann einige der möglichen 88 Möglichkeiten aufgeschrieben und dann zufällig eine davon auswählen lassen….

Ich weiß es ist nicht die schönste Variante.

Auch noch vielen Dank für den Tipp mit den Arrays, ich werde mich damit beschäftigen sobald ich die Grundlagen von C wieder besser drauf haben…

Noch einmal vielen Dank das ihr euch die Zeit genommen habt mir mit meinem Problem zu helfen.

Mit freundlichen Grüßen

Dominik

johnt1tor:
Das sind meine Relais:

https://www.amazon.com/-/de/dp/B07GDK3X1Z/ref=sr_1_7?dchild=1&keywords=arduino+relays&link_code=qs&qid=1586782641&sourceid=Mozilla-search&sr=8-7

Wie bereits vermutet wurde schaltet dieses Relaisboard wenn der Eingang LOW ist.
Steht auch so in der Beschreibung :slight_smile: :slight_smile:

3.IN1-IN8: Trigger-Signal, aktiv niedrig

uxomm:
Wie bereits vermutet wurde schaltet dieses Relaisboard wenn der Eingang LOW ist.
Steht auch so in der Beschreibung :slight_smile: :slight_smile:
3.IN1-IN8: Trigger-Signal, aktiv niedrig

Das weißt Du auch nur, weil Du den englischen Text kennst
"LOW AKTIVE" :wink: :wink: :wink:
Schöne Grüße nach 1020.
Uwe

Grüße von 2020 :slight_smile: (also das Jahr ...)

sobald ich die Grundlagen von C wieder besser drauf haben…

Falls, dann machs dir in C++, denn das ist die Arduino Hauptsprache.

Entschuldigt meine erneute Störung,

Also jetzt habe ich ein anderes Problem.

Das Skript von noiasca verstehe ich zum größten Teil, also es ergibt für ich Sinn.

Jetzt wollte ich nur noch das die Relais am Anfang vom Skript 2x durchlaufen also alle nacheinander "ein- und ausgeschaltet" werden.

Nur habe ich jetzt das Probleme sein Skript in mein Kauderwelsch zu implementieren (soll heißen sein Skript umzuschreiben) oder Skriptkiddie zu spielen und die beiden Skripte zusammen zu laufen zu bringen.

Wenn ihr mir noch einmal helfen könntet wäre ich sehr dankbar, könnte aber auch verstehen wenn nicht.

Du hast doch die Initialisierung im Setup für alle Relais in einer Zeile.

Darauf baseirend kannst Du mehr als nur einen Einzeiler machen:

  // 0.1. Schritt - alle ein
  for (byte i = 0; i < noOfOutputs; i++)                 // https://www.arduino.cc/reference/en/language/structure/control-structure/for/
    {
      outputPin[i]=LOW);
      delay(100);
    }
  // 0.2 Schritt 
//Hier bitte selbst code schreiben

noiasca, ich gebe zu auch nur kopiert zu haben... :wink: