Mehrere Aktoren gleichzeitig ansteuern (+PWM)

Schönen guten Tag an alle User hier,

bin noch neu hier in dem Forum und hab von der Seite häufiger hier gute Tipps finden können. Jetzt steh ich aber an dem Punkt, wo ich selbst verzweifel mit dem Sketch.

Ich bin gerade dabei mir ein automatisiertes Gewächshaus zu bauen, dabei nutze ich 3 Sensoren, sowie insgesamt 4(bzw. später 6 - 3LED Matrix) Aktoren.
In der Hochphase sind davon 3(5) gleichzeititg anzusteuern. Momentan ist es so, dass ich nur einen Aktor ansteuer und sobald der andere aufgerufen wird, dieser Aktor auch wieder ausgeht und der andere erst garnicht an, was ich sehr merkwürdig finde.
Überprüft habe ich bereits: Meine Schaltung läuft einwandfrei (durch Wechsel der Pins),ein bisschen den Sketch umgestellt - alles in eine Schleife gepackt.

Im Anhang findet ihr meinen Sketch, vielleicht habt ihr eine Idee, wie ich das ganze Lösen kann.
Oder ist es möglich, dass der Arduino sobald mehrere Signale gesendet werden, er weniger Strom pro Pin ausgibt? dann hab ich meinen Vorwiderstand zu verändern.

der Rest des Sketches ist in den Kommentaren (neuer User)

Bitte lies die Topics am Anfang des Forums, wie Code richtig gepostet wird (mit </>).

Bitte eine genaue Beschreibung (und Schaltbild) oder Link zum Datenblatt. Was sollen wir uns unter "ansteuern", "aufrufen" und "ausgehen" vorstellen? Digital ein/aus oder Multiplex oder PWM duty cycle ändern?

 /*Kompletter Sketch für den Betrieb der Super_Aero_WaterKultur --> Kurz SAW */
//Temp.-/Feuchtigkeitssensor
#include "DHT.h"                
//Libary LED´s
#include <Adafruit_NeoPixel.h>


#define DHTPIN 2                      // Hier die Pin Nummer eintragen wo der Sensor angeschlossen ist
#define DHTTYPE DHT22                // Hier wird definiert was für ein Sensor ausgelesen wird. In 

//Wohlfühl_PINs
#define     ventilator_PIN  11      // Ventilator PWM pin                  
#define     peltier_PIN     5     // Peltier    PWM pin                

//Fütterungs_PINs
#define NUMPIXELS 64            // Eine Matrix;LED Anzahl
#define PIN        6           // LED
#define PINs       9          // LED2 
#define PIN_pumpe  3x        //Wasserpumpe       


//Einstellungen der Bibliothek-> LED Anzahl, Spektrum und Datenrate
Adafruit_NeoPixel pixels(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);
Adafruit_NeoPixel pixel(NUMPIXELS, PINs, NEO_GRB + NEO_KHZ800);
// Magenta-Farbe für Pflanzenbeleuchtung
uint32_t  magenta  =  pixels.Color(12, 0, 12);
uint32_t  magentas  =  pixel.Color(12, 0, 12); 

//Verzögerung und Intervalle
#define oh 500
unsigned long intervals[] = {576000,864000,72000}; //jede Periode in ms ([0]=ms Beleuchtungsrythmus(16h), [1]=ms Tagrythmus(24h), [2]=ms pumprythmus(2h)) 
static unsigned long last[] = {0,0};                  //für die Timerroutinen

//Sensorberechnung - Licht
int Sensordaten; 
int Sensordaten1;
int mittel = 0;                                     //Variable für Sensordaten/Mittelwert
/********************************( Temperaturprofile )********************************/                          
DHT dht(DHTPIN, DHTTYPE); 

void temp_regeln(){
  delay(2000);                     // Hier definieren wir die Verweilzeit die gewartet wird  
                                   // bis der Sensor wieder ausgelesen wird. Da der DHT11  
                                   // auch ca. 2 Sekunden hat um seine Werte zuaktualisieren
                                   // macht es keinen sinn ihn schneller auszulesen!
  Serial.println("temp_regeln:");                          
  float h = dht.readHumidity();    // Lesen der Luftfeuchtigkeit und speichern in die Variable h
  float t = dht.readTemperature(); // Lesen der Temperatur in °C und speichern in die Variable t
  
  if (isnan(h) || isnan(t)) {       
    Serial.println("Fehler beim auslesen des Sensors!");
    return;
  }

  // Nun senden wir die gemessenen Werte an den PC dise werden wir im Seriellem Monitor sehen
  Serial.print("Luftfeuchtigkeit: ");
  Serial.print(h);                  // Ausgeben der Luftfeuchtigkeit
  Serial.print("%\t");              // Tabulator
  Serial.print("Temperatur: ");
  Serial.print(t);                  // Ausgeben der Temperatur -- Genauigkeit erfolgt 0.1°C Schritte
  Serial.write("°");                // Schreiben des ° Zeichen
  Serial.println("C");

  delay(2000);
  //Belüftung anschalten
  if (t >= 23){
  Serial.println("Ventilator");
  analogWrite(ventilator_PIN, 250);
  delay(oh);
  }
  //Heizung anschalten
  else if (t <= 17) {
  Serial.println("Heizung");
  analogWrite(peltier_PIN, 200);
  delay(oh);
  }
  //In Ruhezustand schalten
  else
  {
  delay(oh);
  Serial.println("ruhe");
  analogWrite(peltier_PIN, 0);
  analogWrite(ventilator_PIN, 0);
  delay(oh);
  }
}
/********************************( Wasserzuschuss )********************************/

void waterflow()                         
{
//      LED als Signalgeber(pumpe nicht angeschlossen)
//      digitalWrite(led, HIGH);            
      
//      delay(1000);
      
//      digitalWrite(led,LOW);

        if ((peltier_PIN || ventilator_PIN) >= 200)
        {   
          analogWrite(ventilator_PIN, 0);
          analogWrite(ventilator_PIN, 0);
          delay(oh);
        }
        
        Serial.println("Wasserflow");
         delay(oh);
        //"Pumpkraft" (max.2^8-1)
        analogWrite(PIN_pumpe, 250);         
        //einschaltdauer=20sekunden
        delay(20000); 
        //Pumpe aus
        analogWrite(PIN_pumpe, 0);
        //Delay, da sonst Pumpe an bleibt
        delay(oh);
        last[1]=millis();                 
        //Beginn der neuen Zeit für die Pumpe
}
/****************************( Lichtprofile )***************************************/
  void tageslauf()
  {
  Serial.print("Tageslauf:");
  Serial.print("Fotosensor-A0 = ");                   //Sensordaten zur Justierung

  Serial.println(Sensordaten);

  Serial.print("Fotosensor-A1 = ");                   //Sensordaten zur Justierung

  Serial.println(Sensordaten1);
  
  Serial.print("Fotosensor-mittelwert = ");                   //Sensordaten zur Justierung

  Serial.println(mittel); 

   //Spannung von fotosensor an a0 auslesen und unter „Sensordaten“ speichern.
   Sensordaten = analogRead(A0);
  
   //Spannung von fotosensor an a1 auslesen und unter „Sensordaten1“ speichern.
   Sensordaten1 = analogRead(A1);
  
   //Mittelwert berechnen.. für Anweisungsauswahl mittel = 2^10= 1024 (max.)
   mittel = (Sensordaten1 + Sensordaten)/2;   
  
     if (mittel <= 200)
{
  pixels.clear();                           //Leds ausschalten
  pixel.clear();
  Serial.println("schwache Helligkeit");
  pixels.setBrightness(10);                //LED Helligkeit festlegen
  pixel.setBrightness(10);
  
  pixels.fill(magenta , 0, NUMPIXELS);    //farbe setzen alle pixel 
  pixel.fill(magentas, 0, NUMPIXELS);

  pixels.show();                           // update der Pixel(LEDs)
  pixel.show();
}
    else if (mittel >= 500)
{
  pixels.clear();                           //Leds ausschalten
  pixel.clear();
  Serial.println("maximum Helligkeit");
  pixels.setBrightness(250);               //LED Helligkeit festlegen (max =255)
  pixel.setBrightness(250);
  
  pixels.fill(magenta , 0, NUMPIXELS);    //Farbe setzen alle pixel  
  pixel.fill(magentas, 0, NUMPIXELS);
  
  pixels.show();                         // update der Pixel(LEDs)
  pixel.show();
}
   else
{
  pixels.clear();                         //Leds ausschalten
  pixel.clear();
  Serial.println("mittlere Helligkeit");
  pixels.setBrightness(100);              //LED Helligkeit festlegen
  pixels.setBrightness(100);
  
  pixels.fill(magenta , 0, NUMPIXELS);    //Farbe setzen alle pixel  
  pixel.fill(magentas, 0, NUMPIXELS);
  
  pixels.show();                          // update der Pixels (LEDs)
  pixel.show();
} 

}



void nachtlauf(){
  Serial.println("Good Night my little ♦");
  pixels.clear();
  pixel.clear();
//  pixels.setBrightness(0);
  pixels.show();
  pixel.show();
}


void futter_regeln()
{
  /* die Pflanzen erhalten eine 16h Wachphase, in denen die Beleuchtung aktiv ist und eine 8h Schlafphase, in denen sie keinerlei Licht zugeführt bekommen sollen.
     Währenddessen erhalten Sie in einem regelmäßigen Takt Ihre Nährstoffe durch die Pumpfunktion. Die Intensität der LEDs wird durch die Sensoren angepasst an 
     jeweilige Helligkeitsextremas angepasst - Sinn dabei ist eine Stromeinsparung */
   
while ( millis() - last[0] <= intervals[0]  )      
// 16h-routine(tag)
{
  if (millis() - last[1] >= intervals [2])          
// 2h pumproutine -> Wasser hat hier höhere Priorität, da kleinerer Zeitintervall 
{
waterflow();
break;
}
 else {
 tageslauf();                                      
//Aufruf subroutine - Tageslauf (messung der Helligkeit + Anpassung)
 delay(oh);
 break;
}//ende der 16h-While-Schleife
}

//8h-Routine(Nacht)
while (millis() - last[0] >= intervals[0])          
{                

//2h pumproutine
if (millis() - last[1] >= intervals [2])            
{
waterflow();
}
//Nachtphase
else { 
nachtlauf();
break;
}//ende der Nachtphase


}
}

void setup() 
{
  dht.begin();        //Initialisiere Temperatur und Feuchtigkeitssensor

  Serial.begin(9600); //zum watchen im Monitor
  
  pixels.begin(); // Initialisiere erste Matrix 
  pixel.begin();  // Initialisiere zweite Matrix
}

void loop() 
{

temp_regeln();
delay (oh);
futter_regeln();
delay (oh);
if ( millis() - last[0] >= intervals[1])
{
//tag erneuern
last[0] = millis();
                                
delay(oh);
}
}

ich habe hier mal den kompletten Sketch gepostet, wenn es geht bitte ohne Fachbegriffe oder wenn überhaupt erklären :smiley: ich weiß zwar was ein Multiplexer ist oder ein PWM duty cycle aber wie das im code bzw visuell aussieht ist für mich ziemlich unklar..

hieran ist glaube ich einiges falsch. ich versuche es mal zu splitten auf zwei prozessoren und schaue wie es dann läuft.

Dein Sketch ist nicht lesbar und enthält viele Formatierungsfehler da du keine Code-Tags verwendest, obwohl es dir beschrieben wurde.
Lies bitte auch den ersten Beitrag "Wie man dieses Forum verwendet", hier im Forum.
Da steht alles drin wie du es richtig machen solltest.

Das kommt drauf an ob Du verständlich erklären kannst, um was für "Aktoren" es sich handelt, wie die angeschlossen sind und was damit geschehen soll.

Wir haben zuwenig Informationen um Dir antworten zu können.
Grüße Uwe

Ich habe bis jetzt noch keinen blassen Schimmer, was das Programm machen soll. Mal abgesehen von dem Schlagwort "Gewächshaus". Es sollte doch möglich sein, mal die Funktionen zusammenzufassen, was die Steuerung wie und wann machen soll?