Sonnenuntergang; Fertiger Baustein?

Zuviel Werbung?
-> Hier kostenlos registrieren
aha danke jetzt hab ichs verstanden

Dann brauche ich 16 Relais für 16 Rollos

Und kann man Relais in den Schaltschrank einbauen oder direkt bei Rollos (hab nur Platz im Schaltschrank)?
Bitte um eventuele Amazone Links zum Bestellen
 
Zuletzt bearbeitet:
Wenn Du 16 Rollos hast, brauchst Du 32 Relais.
Denn Du möchtest ja hoch und runter fahren, oder?

Die erste Richtung je Rollo sollte einen Wechsler enthalten, um die 2. gleichzeitig zu deaktivieren und somit Defekte bei Fehlansteuerungen (beide Richtungen gleichzeitig) zu vermeiden.
 
Zuviel Werbung?
-> Hier kostenlos registrieren
:
SoftMachine danke für deine Antwort jedoch verstehe ich nur Bahnhof was da erklehrt wird?
Und Oscat habe ich nicht Downgeloadet den wie ich weis nicht wie ich es einfügen kann?

OSCAT ist eine Library, aus der du einzelne Bausteine entnehmen
und in deinem Rolladen-Projekt kopieren und verwenden kannst.

Der genannte Baustein übergibt dir die berechneten Zeiten für den
Sonnenaufgang und -untergang im Format TOD.
Dieses Format (seinen Aufbau) kannst du dir im STEP7-Manager mit
Hilfe der <F1>-Taste anschauen und erklären lassen.

Wenn du in den vorangegangenen Beiträgen nachliest, findest du
noch einiges an Informationen.

Hast du denn nun jetzt mal die Forumssuche benutzt ?
 
Hucki da hast du recht ich will hoch wie auch runterfahren mit den Rollos, nur das Problem ist ich muss alles im Schaltschrank montieren.

SoftMachine Google wie auch durchsuche einige Monate schon die Foren und bis auf das was ich erstellt habe geht nichts mehr Kopf explodiert bald.
Würde euch danken wenn mir einer das in meine Programierung reinkopieren könnte ich seh wirklich nicht mehr durch.
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Für die Relais wurde im Forum schon mehrfach auf Koppelrelais von Finder, Phoenix und Co. verwiesen, die im Schaltschrank nur eine halbe TE belegen.
(Für die Suche - auch von mir z.B. ;))
Ist aber trotzdem natürlich einiges an Platzbedarf, was da zusammen kommt.
 
.
Wenn es man einzeln wäre. :p

Vor allem solche Berechnungen erfordern fast immer weitere
(meist sogar ein ganzes Rudel) OSCAT-Bibliotheksbausteine als Voraussetzung.;)


Nur 2 an der Zahl.

sun_time ruft folgende Bausteine auf, die auch in der library mitgeliefert werden:
hour_to_tod
day_of_year

und noch 2 s7-interne (so wie so schon vorhandene) Funktionen:
S7/Standard Library/IEC Function Blocks/D_TOD_DT
S7/Standard Library/IEC Function Blocks/DT_DATE
 
.
SoftMachine
Google wie auch durchsuche einige Monate schon die Foren und bis auf das was ich erstellt habe geht nichts mehr Kopf explodiert bald.
Würde euch danken wenn mir einer das in meine Programierung reinkopieren könnte ich seh wirklich nicht mehr durch.


Nachdem du jetzt auch "elektrische" Hilfen erhalten hast, hier noch eine fürs programmieren:

Einfügen von OCAT Modulen in Step7 Programm

und natürlich (wärmstens empfohlen): unsere Forums-Suche.
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Hallo
ich muss ganz ehrlich sagen dass ich Oscat auch nicht verwende da die ganze Sache mir viel zu verkettet ist. Will man den Baustein SUN_TIME, muss man erst jede Menge andere Bausteine Übertragen.
Wenn du meinen Baustein SUN_TIME in Beitrag #13 verwendest hast du schon mal den Sonnen auf und Untergang.

in SCL kannst du ganz leicht auf diese Zeit einen Offset Programmieren.
Jetzt musst du nur noch einen Vergleich zwischen Systemzeit und Sollzeit Programmieren.
 
So jetzt hab ich die Koppelrelais gefunden und habe mich mit dem berechnen der Ampere beschäftigt.
Habe Alu-Rollo großen Fenster 5m² komme auf 0,64 Ampere.
Wichtig ist das bei 220-230V die Relais 0,64 Ampere bringen und AC 3 Motoren -------->>>> http://www.ebay.de/itm/10-Stuck-FIN...romechanische_Bauelemente&hash=item4174189982
Die gehen nicht, oder habe ich jetzt was falsch gemacht.
Emmilio das Problemm ist das ich das nicht kann und von dem Programmieren keine Ahnung habe!!!
 
Ok
Hier mein Programm

Mit diesem Baustein kannst du die Rollo Steuerun

Code:
FUNCTION_BLOCK ROLLO_CONTROL
CONST
     TAKT_ZEIT:=0.1;           // ZEIT Taktmerker für Berechnung 
     POS_ROLLO_LANGSAM:=90;    // Position ab der Lamellen eintauchen
END_CONST

VAR_INPUT
    E_ROLLO_AUF           :BOOL;
    E_ROLLO_ZU            :BOOL;
    E_FENSTER_TUERE_ZU    :BOOL;
    POS_EIN               :BOOL;
    POS                   :INT;   // POSITION von 0-100
    TAKT                  :BOOL; // Taktmerker 0.1
    E_SCHALTUHR: STRUCT   
                    ROLLO_ZU : BOOL;
                    ROLLO_AUF: BOOL;
                    ROLLO_POS: BOOL;
                    POS      : INT;
         END_STRUCT;
        
END_VAR
   
VAR_OUTPUT
    A_ROLLO_AUF           :BOOL;
    A_ROLLO_ZU            :BOOL;    
END_VAR
    
VAR_TEMP
    // temporäre Variablen

END_VAR
VAR
  HMI :STRUCT  
    BUTTON_ROLL_ZU    :BOOL;   // Rollo Zu Button HMI
    BUTTON_ROLL_AUF   :BOOL;   // Rollo Auf Button HMI
    BUTTON_ROLL_POS   :BOOL;   // Position vom HMI anfahren
    ROLL_POS          :INT;    // Position vom HMI
    EINRICHTEN        :BOOL;   // Einrichten
    
  END_STRUCT;  
    IST_POS_ROLLO         :INT;    // Ist  Position Rollo %
    IST_POS_ROLLO_REAL    :REAL;
    SOLL_POS_ROLLO        :INT;    // Soll Position Rollo %
    POS_ROLLO_AUF         :INT:=0  ;//Position Rollo Auf Anfangswert 0
    POS_ROLLO_ZU          :INT:=100;//Position Rollo Zu Anfangswert 100
    NACHLAUFZEIT          :TP;     // Nachlaufzeit bei Pos 0 und 100
    T_NACHLAUFZEIT        :TIME:=t#5s;
    SPERZEIT_ROLLO        :TOF;    // Sperzeit zwischen wechsel AUF / AB
    M_ROLLO_ZU            :BOOL;
    M_ROLLO_AUF           :BOOL;
    LAUFZEIT_ROLLO_AUF    :REAL:=20.0;// sec
    LAUFZEIT_ROLLO_ZU     :REAL:=20.0;// sec
       
    P_E_ROLL_ZU           :BOOL;
    P_E_ROLL_AUF          :BOOL;
    P_HMI_BUTTON_ROLL_ZU  :BOOL;
    P_HMI_BUTTON_ROLL_AUF :BOOL;
    P_TAKT                :BOOL;
    Edge_flag_pos1        :BOOL;
    Edge_flag_pos2        :BOOL;
    Edge_flag_pos3        :BOOL;
    Edge_flag_pos4        :BOOL;
    Edge_flag_pos5        :BOOL;

    
    
END_VAR

    BEGIN
 //*******************************************************************************************************************************************//   
  
    
    
    
    
    
    // Flankenmerker   
    //Bildung der positiven Flanke  //get the positive pulse
     P_E_ROLL_ZU  := E_ROLLO_ZU AND NOT Edge_flag_pos1;
     Edge_flag_pos1   := E_ROLLO_ZU;
     
     P_E_ROLL_AUF  := E_ROLLO_AUF AND NOT Edge_flag_pos2;
     Edge_flag_pos2   := E_ROLLO_AUF;
     
     P_HMI_BUTTON_ROLL_ZU := HMI.BUTTON_ROLL_ZU  AND NOT Edge_flag_pos3;
     Edge_flag_pos3   := HMI.BUTTON_ROLL_ZU ;

     P_HMI_BUTTON_ROLL_AUF  := HMI.BUTTON_ROLL_AUF  AND NOT Edge_flag_pos4;
     Edge_flag_pos4   := HMI.BUTTON_ROLL_AUF ;
     
     P_TAKT  := TAKT  AND NOT Edge_flag_pos5;
     Edge_flag_pos5   := TAKT ;

     
//***********************************************************   
//*                      SPERZEIT                           *
//*********************************************************** 
     SPERZEIT_ROLLO(IN :=A_ROLLO_AUF OR A_ROLLO_ZU,PT := T#2s); 
     
//***********************************************************   
//*      // Soll Position Rollo setzen                      *
//*********************************************************** 
    IF HMI.EINRICHTEN THEN
       SOLL_POS_ROLLO := REAL_TO_INT (IST_POS_ROLLO_REAL);  
    ELSIF P_HMI_BUTTON_ROLL_ZU OR P_E_ROLL_ZU OR (E_SCHALTUHR.ROLLO_ZU  AND E_FENSTER_TUERE_ZU) AND NOT A_ROLLO_AUF  THEN
        SOLL_POS_ROLLO := POS_ROLLO_ZU;
    ELSIF P_HMI_BUTTON_ROLL_AUF OR P_E_ROLL_AUF OR E_SCHALTUHR.ROLLO_AUF AND NOT A_ROLLO_ZU  THEN
       SOLL_POS_ROLLO := POS_ROLLO_AUF;
    ELSIF HMI.BUTTON_ROLL_POS THEN
       SOLL_POS_ROLLO := HMI.ROLL_POS;
    ELSIF POS_EIN OR (E_SCHALTUHR.ROLLO_POS AND E_FENSTER_TUERE_ZU) THEN 
       SOLL_POS_ROLLO := E_SCHALTUHR.POS;
    END_IF;
//***********************************************************   
//*          Überprüfung ob SOLL_POS logisch                *
//*********************************************************** 
        
    IF SOLL_POS_ROLLO >100 THEN
       SOLL_POS_ROLLO := 100;
    ELSIF SOLL_POS_ROLLO <0 THEN
       SOLL_POS_ROLLO := 0;
    END_IF; 
    
//***********************************************************   
//*          ROLLO Stoppen wärend fahrt                     *
//*********************************************************** 

    IF A_ROLLO_AUF AND (P_HMI_BUTTON_ROLL_ZU OR  P_E_ROLL_ZU)  THEN        
       SOLL_POS_ROLLO := IST_POS_ROLLO;
    END_IF;
    IF A_ROLLO_ZU AND (P_HMI_BUTTON_ROLL_AUF OR  P_E_ROLL_AUF)  THEN        
       SOLL_POS_ROLLO := IST_POS_ROLLO;
    END_IF;

//***********************************************************   
//*         // Rollo in Position Fahren
//***********************************************************    
    
     M_ROLLO_AUF:=IST_POS_ROLLO > SOLL_POS_ROLLO;
     M_ROLLO_ZU :=IST_POS_ROLLO < SOLL_POS_ROLLO;
     
//***********************************************************   
//*       Nachlaufzeit Rollo bei Pos 0 oder 100 
//***********************************************************            
     NACHLAUFZEIT(IN :=IST_POS_ROLLO = 0 OR IST_POS_ROLLO = 100,PT := T_NACHLAUFZEIT); 
     
 //***********************************************************   
//*                   Ausgänge setzen 
//***********************************************************       
  // Ausgänge EIN setzen
    IF    M_ROLLO_AUF=TRUE AND SPERZEIT_ROLLO.Q=FALSE THEN
           A_ROLLO_AUF:=TRUE; 
    END_IF;                            
    IF M_ROLLO_ZU =TRUE AND SPERZEIT_ROLLO.Q=FALSE THEN
           A_ROLLO_ZU:=TRUE;
    END_IF;
    
    
 // Ausgänge AUS setzen
    IF    M_ROLLO_AUF=FALSE AND NACHLAUFZEIT.Q=FALSE THEN
           A_ROLLO_AUF:=FALSE;
    END_IF;       
    IF M_ROLLO_ZU =FALSE AND NACHLAUFZEIT.Q=FALSE THEN
           A_ROLLO_ZU :=FALSE;
    END_IF;
    
 //***********************************************************   
//*  Position errechnen: Rollo bis 80% der Laufzeit schnell 
//                  fahren dann langsam
//************************************************************   
    
  // ROLLO AUF
    IF A_ROLLO_AUF AND P_TAKT   THEN
      IF IST_POS_ROLLO < POS_ROLLO_LANGSAM THEN
            IST_POS_ROLLO_REAL:=IST_POS_ROLLO_REAL - (INT_TO_REAL (POS_ROLLO_LANGSAM)/(LAUFZEIT_ROLLO_AUF*0.8))*TAKT_ZEIT;
      ELSE
           IST_POS_ROLLO_REAL:=IST_POS_ROLLO_REAL - (INT_TO_REAL (100 - POS_ROLLO_LANGSAM)/(LAUFZEIT_ROLLO_AUF*0.2))*TAKT_ZEIT;
      END_IF;
      IST_POS_ROLLO := REAL_TO_INT (IST_POS_ROLLO_REAL);
    
      IF IST_POS_ROLLO <= 0  THEN
          IST_POS_ROLLO:=0;
          IST_POS_ROLLO_REAL:=0.0;
      END_IF;
    END_IF; 
    
          
    // ROLLO ZU    
    IF A_ROLLO_ZU AND P_TAKT   THEN
       IF IST_POS_ROLLO < POS_ROLLO_LANGSAM THEN
            IST_POS_ROLLO_REAL:=IST_POS_ROLLO_REAL + (INT_TO_REAL (POS_ROLLO_LANGSAM)/(LAUFZEIT_ROLLO_ZU*0.8))*TAKT_ZEIT;
       ELSE
           IST_POS_ROLLO_REAL:=IST_POS_ROLLO_REAL + (INT_TO_REAL (100 - POS_ROLLO_LANGSAM)/(LAUFZEIT_ROLLO_ZU*0.2))*TAKT_ZEIT;
       END_IF;
       IST_POS_ROLLO := REAL_TO_INT (IST_POS_ROLLO_REAL);

       IF IST_POS_ROLLO >= 100   THEN
          IST_POS_ROLLO:=100;
          IST_POS_ROLLO_REAL:=100.0;
       END_IF;
    END_IF; 
    
        
        ;
END_FUNCTION_BLOCK

Dies ist die Zeitschaltuhr. Hir musst du nur die Anzahl der Rollosgruppen eingeben. Du hast 4 Schaltzeiten . Du kannst z.b in Schaltzeit 1 von Montag bis Freitag den Rollo um 6:00 Uhr auf 80% Öffnen lassen, um 8:00 Uhr Auf gehen lassen und um 22:00 Uhr zu gehen lassen. Von diesen Schaltzeiten hast du je Rollo 4 Stück.

Code:
//*************************ZEITSCHALTUHR******************************
FUNCTION_BLOCK "ROLLO_SCHALTUHR"
//TITLE = 'ROLLO_SCHALTUHR'
//VERSION : '2.0'
//AUTHOR  : ZEHE
//NAME    : 
//FAMILY  : TIMEER

CONST
    Anzahl_Rollos:=5; // Anzahl der zu Schaltenten Rollogruppen
    Anzahl_Sp:=4;     // Anzahl der Speicherplätze je Rollo
END_CONST

VAR_INPUT
    
    SONNEN_AUFGANG        :TOD;
    SONNEN_UNTERGANG      :TOD;
    E_HOLIDAY             :BOOL; 
     
END_VAR

VAR_OUTPUT
   A_ROLLOS: ARRAY[1..Anzahl_Rollos] OF STRUCT   
             ROLLO_ZU : BOOL;
             ROLLO_AUF: BOOL;
             ROLLO_POS: BOOL;
             POS      : INT;
         END_STRUCT;
                         
END_VAR
VAR 
    
    ZEITSCHALTUHR_EIN      :BOOL:=TRUE; // Schaltuhr für alle Rollos EIN
    ZeitFunktion           :INT;// 
    ROLLOS: ARRAY[1..Anzahl_Rollos] OF STRUCT
               SPEICHERPLATZ: ARRAY [0..Anzahl_Sp] OF STRUCT
                    TAG : ARRAY [0..7] OF BOOL; 
                    ZEIT_ROLLO_AUF: TOD ; // 0
                    ZEIT_ROLLO_ZU: TOD ; // 1
                    ZEIT_ROLLO_POS: TOD ; //2
                    ZEIT_ROLL_AUF_EIN:BOOL;
                    ZEIT_ROLL_ZU_EIN :BOOL;
                    ZEIT_ROLL_POS_EIN:BOOL;
                    POS:   INT;
                    SONNEN_AUFGANG   :BOOL;
                    SONNEN_UNTERGANG :BOOL;
               END_STRUCT;
            END_STRUCT;    
            
    OFFSET_SON_AUFGANG     :TIME;
    OFFSET_SON_UNTERGANG   :TIME;
    SONNEN_AUFGANG_ROLLO   :TOD;
    SONNEN_UNTERGANG_ROLLO :TOD;
    HOLIDAY_PROG_AKTIV     :BOOL:=TRUE;
    LRoNr                  :INT;
    LSpNr                  :INT;
    VarLaden               :BOOL;    
    HMI:STRUCT
        RoNr           :INT;
        SpNr           :INT;
        Speichern      :BOOL;
        TAG : ARRAY [0..7] OF BOOL;
        ZEIT_ROLLO_AUF: TOD ; 
        ZEIT_ROLLO_ZU:  TOD ; 
        ZEIT_ROLLO_POS: TOD ;
        POS            :INT;
        ZEIT_ROLL_AUF_EIN:BOOL;
        ZEIT_ROLL_ZU_EIN :BOOL;
        ZEIT_ROLL_POS_EIN:BOOL;
        SONNEN_AUFGANG   :BOOL;
        SONNEN_UNTERGANG :BOOL;

 
        
   END_STRUCT;
  
END_VAR

VAR_TEMP
    
    TEMP_INT : INT ;
    DATUM_ZEIT_DT  : DT;
    SPS_TIME : TOD; 
    SPS_TIME_I:DINT;
    Wochentag : INT;
    i:INT;
    i2:INT; 
        
 //____________________________________________________________________________________________________________  
BEGIN
//*******************************************HMI MUX Funktionen ***********************************************
// Anzahl Rollos MUX auf Logisch überprüfen 
    IF HMI.RoNr >Anzahl_Rollos OR HMI.RoNr < 1 THEN
       HMI.RoNr:=1;
    END_IF; 
    //Speicherplatz Rücksetzen wenn Rollowechsel
    IF  HMI.RoNr<>LRoNr THEN
        HMI.SpNr:=0;
     END_IF;     

// SPEICHERPLATZ für HMI MUX überprüfen
    IF HMI.SpNr > Anzahl_Sp OR HMI.SpNr < 0 THEN
      HMI.SpNr:= 0 ;
    END_IF; 
    
 IF HMI.RoNr<>LRoNr OR HMI.SpNr<>LSpNr OR VarLaden THEN   
 // Variablen MUX in HMI lesen
   // Wochentage
    HMI.TAG:=ROLLOS[HMI.RoNr].SPEICHERPLATZ[HMI.SpNr].TAG; 
   // Zeiten + POS 
    HMI.ZEIT_ROLLO_AUF:=ROLLOS[HMI.RoNr].SPEICHERPLATZ[HMI.SpNr].ZEIT_ROLLO_AUF;  
    HMI.ZEIT_ROLLO_ZU :=ROLLOS[HMI.RoNr].SPEICHERPLATZ[HMI.SpNr].ZEIT_ROLLO_ZU;
    HMI.ZEIT_ROLLO_POS:=ROLLOS[HMI.RoNr].SPEICHERPLATZ[HMI.SpNr].ZEIT_ROLLO_POS;
    HMI.POS:=ROLLOS[HMI.RoNr].SPEICHERPLATZ[HMI.SpNr].POS;
   // Bool Zeiten
    HMI.ZEIT_ROLL_AUF_EIN:=ROLLOS[HMI.RoNr].SPEICHERPLATZ[HMI.SpNr].ZEIT_ROLL_AUF_EIN;  
    HMI.ZEIT_ROLL_ZU_EIN :=ROLLOS[HMI.RoNr].SPEICHERPLATZ[HMI.SpNr].ZEIT_ROLL_ZU_EIN;
    HMI.ZEIT_ROLL_POS_EIN:=ROLLOS[HMI.RoNr].SPEICHERPLATZ[HMI.SpNr].ZEIT_ROLL_POS_EIN;
    HMI.SONNEN_AUFGANG   :=ROLLOS[HMI.RoNr].SPEICHERPLATZ[HMI.SpNr].SONNEN_AUFGANG;
    HMI.SONNEN_UNTERGANG :=ROLLOS[HMI.RoNr].SPEICHERPLATZ[HMI.SpNr].SONNEN_UNTERGANG;
    
    LRoNr:=HMI.RoNr; LSpNr:=HMI.SpNr; VarLaden:=FALSE;
 END_IF;   
 IF HMI.Speichern THEN   
  // Vatiablen MUX in Steuerung Speichern 
    ROLLOS[HMI.RoNr].SPEICHERPLATZ[HMI.SpNr].TAG:=HMI.TAG; 
   // Zeiten + POS 
    ROLLOS[HMI.RoNr].SPEICHERPLATZ[HMI.SpNr].ZEIT_ROLLO_AUF:=HMI.ZEIT_ROLLO_AUF;  
    ROLLOS[HMI.RoNr].SPEICHERPLATZ[HMI.SpNr].ZEIT_ROLLO_ZU :=HMI.ZEIT_ROLLO_ZU;
    ROLLOS[HMI.RoNr].SPEICHERPLATZ[HMI.SpNr].ZEIT_ROLLO_POS:=HMI.ZEIT_ROLLO_POS;
    ROLLOS[HMI.RoNr].SPEICHERPLATZ[HMI.SpNr].POS:=HMI.POS;
   // Bool Zeiten
    ROLLOS[HMI.RoNr].SPEICHERPLATZ[HMI.SpNr].ZEIT_ROLL_AUF_EIN:=HMI.ZEIT_ROLL_AUF_EIN;  
    ROLLOS[HMI.RoNr].SPEICHERPLATZ[HMI.SpNr].ZEIT_ROLL_ZU_EIN :=HMI.ZEIT_ROLL_ZU_EIN;
    ROLLOS[HMI.RoNr].SPEICHERPLATZ[HMI.SpNr].ZEIT_ROLL_POS_EIN:=HMI.ZEIT_ROLL_POS_EIN;
    ROLLOS[HMI.RoNr].SPEICHERPLATZ[HMI.SpNr].SONNEN_AUFGANG   :=HMI.SONNEN_AUFGANG;
    ROLLOS[HMI.RoNr].SPEICHERPLATZ[HMI.SpNr].SONNEN_UNTERGANG :=HMI.SONNEN_UNTERGANG ;
    
    HMI.Speichern:=False;
    VarLaden:=TRUE;
 END_IF;
    
    //**********************************END HMI Mux Funktionen **************************************************** 
    
    
    //**************** Funktion: Vergleich der Zeiten je Rollo in Speicherplatz mit AkuallZeit********************  
// Zeiten aus SPS Extrahieren  
  
       TEMP_INT:=READ_CLK(CDT :=DATUM_ZEIT_DT);                 // Datum und Zeit aus SPS Lesen
       SPS_TIME:=DT_TOD(IN :=DATUM_ZEIT_DT);                    // Zeit aus Datum und Zeit Extrahieren
       SPS_TIME_I:=TOD_TO_DINT (SPS_TIME)/1000 ;                // ZEIT ind DINT umwandeln und durch 1000 Teile um sec zu erhalten
       Wochentag:= DT_DAY(IN :=DATUM_ZEIT_DT);                  // Wochentag aus SPS Zeit Extrahieren
 
 // Feiertag Porgramm    
    IF E_HOLIDAY AND HOLIDAY_PROG_AKTIV THEN
        Wochentag := 1;                                           // an Feiertagen wird Wochenprogramm Sonntag bearbeitet
    END_IF;  
    
 // Programm nur berarbeiten wenn Zeitschaltuhr EIN     
 IF ZEITSCHALTUHR_EIN THEN
    
 // Sonnenzeiten + Offset Berechnen in Speicherplatz schreiben wenn Sonnen aufgan oder Sonnenuntergang TRUE    
    SONNEN_AUFGANG_ROLLO   := SONNEN_AUFGANG + OFFSET_SON_AUFGANG;
    SONNEN_UNTERGANG_ROLLO := SONNEN_UNTERGANG + OFFSET_SON_UNTERGANG;
 // Rollo   
  FOR i :=1 TO Anzahl_Rollos BY 1 DO
    // Speicherplatz
    FOR i2 := 0 TO Anzahl_Sp BY 1 DO
         IF ROLLOS[i].SPEICHERPLATZ[i2].SONNEN_AUFGANG THEN
          ROLLOS[i].SPEICHERPLATZ[i2].ZEIT_ROLLO_AUF:=SONNEN_AUFGANG_ROLLO;
         END_IF;
         
         IF ROLLOS[i].SPEICHERPLATZ[i2].SONNEN_UNTERGANG THEN
          ROLLOS[i].SPEICHERPLATZ[i2].ZEIT_ROLLO_ZU:=SONNEN_UNTERGANG_ROLLO;
         END_IF;
     END_FOR;
  END_FOR; 
   
  
 //Rollo Zeiten speicherplatz auswerten und Bits Schalten je Rollo 
 // Rollos 
  FOR i :=1 TO Anzahl_Rollos BY 1 DO
          
  // Speicherplatz
    FOR i2 := 0 TO Anzahl_Sp BY 1 DO
   // Tag      
         IF ROLLOS[i].SPEICHERPLATZ[i2].TAG[WOCHENTAG] THEN
            A_ROLLOS[i].ROLLO_ZU :=SPS_TIME_I = TOD_TO_DINT (ROLLOS[i].SPEICHERPLATZ[i2].ZEIT_ROLLO_ZU)/1000 AND 
                                                TOD_TO_DINT (ROLLOS[i].SPEICHERPLATZ[i2].ZEIT_ROLLO_ZU)/1000>0 AND 
                                                             ROLLOS[i].SPEICHERPLATZ[i2].ZEIT_ROLL_ZU_EIN = TRUE; 
            A_ROLLOS[i].ROLLO_AUF:=SPS_TIME_I = TOD_TO_DINT (ROLLOS[i].SPEICHERPLATZ[i2].ZEIT_ROLLO_AUF)/1000 AND 
                                                TOD_TO_DINT (ROLLOS[i].SPEICHERPLATZ[i2].ZEIT_ROLLO_AUF)/1000>0 AND 
                                                             ROLLOS[i].SPEICHERPLATZ[i2].ZEIT_ROLL_AUF_EIN = TRUE;
            A_ROLLOS[i].ROLLO_POS:=SPS_TIME_I = TOD_TO_DINT (ROLLOS[i].SPEICHERPLATZ[i2].ZEIT_ROLLO_POS)/1000 AND 
                                                TOD_TO_DINT (ROLLOS[i].SPEICHERPLATZ[i2].ZEIT_ROLLO_POS)/1000>0 AND 
                                                             ROLLOS[i].SPEICHERPLATZ[i2].ZEIT_ROLL_POS_EIN = TRUE;
            IF A_ROLLOS[i].ROLLO_POS THEN 
                A_ROLLOS[i].POS:=  ROLLOS[i].SPEICHERPLATZ[i2].POS; 
            END_IF;                                   
            
            IF A_ROLLOS[i].ROLLO_ZU OR A_ROLLOS[i].ROLLO_AUF OR A_ROLLOS[i].ROLLO_POS THEN
                EXIT;                                                 
            END_IF;
          END_IF;                                                   
      END_FOR;
   END_FOR;                                                       
  
  END_IF;                                                           
            
   //**************** ENDE Funktion: Vergleich der Zeiten je Rollo in Speicherplatz mit AkuallZeit*****************         
            
        
            
 ;
     
   END_FUNCTION_BLOCK
 

Anhänge

  • Zeitschaltuhr Rollo.JPG
    Zeitschaltuhr Rollo.JPG
    79,2 KB · Aufrufe: 50
  • Sonnenzeit.JPG
    Sonnenzeit.JPG
    71,3 KB · Aufrufe: 48
  • bildRollo.JPG
    bildRollo.JPG
    82,1 KB · Aufrufe: 50
  • Bild_Rollo2.JPG
    Bild_Rollo2.JPG
    96 KB · Aufrufe: 48
Zuletzt bearbeitet:
Zurück
Oben