Zuviel Werbung? - > Hier kostenlos beim SPS-Forum registrieren

Seite 4 von 4 ErsteErste ... 234
Ergebnis 31 bis 31 von 31

Thema: Sonnenuntergang; Fertiger Baustein?

  1. #31
    Registriert seit
    10.08.2010
    Beiträge
    770
    Danke
    1
    Erhielt 14 Danke für 13 Beiträge

    Standard


    Zuviel Werbung?
    -> Hier kostenlos registrieren
    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
    Angehängte Grafiken Angehängte Grafiken
    Geändert von emilio20 (15.09.2014 um 20:25 Uhr)

  2. Folgender Benutzer sagt Danke zu emilio20 für den nützlichen Beitrag:

    guzo007 (16.09.2014)

Ähnliche Themen

  1. fertiger Datenbaustein Lenze 8400
    Von Dominique Wiemann im Forum Antriebstechnik
    Antworten: 11
    Letzter Beitrag: 11.09.2011, 20:57
  2. RTC-Baustein
    Von Bambam im Forum CODESYS und IEC61131
    Antworten: 0
    Letzter Beitrag: 15.09.2010, 14:52
  3. fertiger Sinusgenerator Baustein?
    Von Geisti im Forum Simatic
    Antworten: 7
    Letzter Beitrag: 18.06.2010, 09:08
  4. Ist ein fertiger Regelbaustein überhaupt nötig?
    Von stephan282 im Forum Simatic
    Antworten: 32
    Letzter Beitrag: 05.11.2007, 20:06
  5. hilfe bei fast fertiger sps aufgabe
    Von renshy im Forum Simatic
    Antworten: 9
    Letzter Beitrag: 07.02.2007, 12:11

Lesezeichen

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •