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

Seite 1 von 2 12 LetzteLetzte
Ergebnis 1 bis 10 von 12

Thema: Verzögerungsfunktion für ein EW gesucht

  1. #1
    Registriert seit
    18.09.2004
    Beiträge
    69
    Danke
    2
    Erhielt 1 Danke für 1 Beitrag

    Standard


    Zuviel Werbung?
    -> Hier kostenlos registrieren
    Hallo Leute,

    suche gerade einen Ansatz für eine Verzögerungsfunktion.

    1.So allso es sollte jedes Bit des EW als Eingangsverzögerung unabhängig voneinander verzögern.

    2. Wenn jetzt die Zeit erreicht ist dann sollte das Ausgangsbit solange auf true sein bis eine das Eingangsbit eine bestimmte Zeit aus ist.


    Wer hat eine gute Idee?

    danke schon mal
    Zitieren Zitieren Verzögerungsfunktion für ein EW gesucht  

  2. #2
    Registriert seit
    28.01.2009
    Ort
    Hamburg
    Beiträge
    199
    Danke
    52
    Erhielt 54 Danke für 34 Beiträge

    Standard

    Habe im Anhang ein kurzes FUP Programm hinterlegt.
    Im Programm wird dann mit #Altwert_EW0 Gearbeitet.

    Viele Grüße Bernard
    Angehängte Grafiken Angehängte Grafiken
    Zitieren Zitieren Verzögerungsfunktion für ein EW gesucht  

  3. #3
    eloboy ist offline Benutzer
    Themenstarter
    Registriert seit
    18.09.2004
    Beiträge
    69
    Danke
    2
    Erhielt 1 Danke für 1 Beitrag

    Standard

    Danke Bernard,

    aber ich will es auf jedes Bit und nicht auf dem ganzen Word.
    -ich will einzelne Signale verzögern.

  4. #4
    Registriert seit
    28.01.2009
    Ort
    Hamburg
    Beiträge
    199
    Danke
    52
    Erhielt 54 Danke für 34 Beiträge

    Standard

    So Fehler ist behoben, du mußt den Code in eine Quelle hinein kopieren und danach übersetzen.Der Baustein verbraucht allerdings 32 S5 Timer intern. Beschaltungsmuster liegt bei.

    Code:
    FUNCTION FC 3 : VOID
    TITLE =
    VERSION : 0.1
    
    
    VAR_INPUT
      Einwort : WORD ;    
      Anf_s5_Timer_X_32 : INT ;    //Belegt ab der Anfangsnummer 32 s5 Timer
      Zeit_S5 : S5TIME ;    
    END_VAR
    VAR_OUTPUT
      Verzoegertes_Wort : INT ;    
    END_VAR
    VAR_TEMP
      AR1_Speicher : DWORD ;    
      AR2_Speicher : DWORD ;    
      schleife : INT ;    
      schleife_2 : INT ;    
      Timer_S5_T : INT ;    
      Pointer_Ausgang_Intern : DWORD ;    
      Ausgang_Intern : INT ;    
    END_VAR
    BEGIN
    NETWORK
    TITLE =
    
    //Rettung der AR Register
          TAR1  #AR1_Speicher; 
          TAR2  #AR2_Speicher; 
    
    //*******************************************************************************
          L     P##Einwort; //Vorbelegung AR1 mit EW
          LAR1  ; 
          L     P##Verzoegertes_Wort; //Vorbelegung AR2 mit Verzoegertes Wort
          LAR2  ; 
          L     #Anf_s5_Timer_X_32; //Übergabe Anfangstimer
          T     #Timer_S5_T; 
          L     P#18.0; //Zustand Zwischenablage
          T     #Pointer_Ausgang_Intern; 
    //*******************************************************************************
          L     16; 
    next: T     #schleife; 
          U      [AR1,P#0.0]; //Indirektes  Einschlatverzoegerte Timer
          L     #Zeit_S5; 
          SE    T [#Timer_S5_T]; 
          U     T [#Timer_S5_T]; 
          =     L [#Pointer_Ausgang_Intern]; 
    //++++++++++++++++++++++++++++++++++++++++++++++++++
          L     P#0.1; //Pointererhöhung um ein Bit
          +AR1  ; 
          +AR2  ; 
          L     1; // Timernummererhöhung um 1
          L     #Timer_S5_T; 
          +I    ; 
          T     #Timer_S5_T; 
    //++++++++++++++++++++++++++++++++++++++++++++++++++
          L     #Pointer_Ausgang_Intern; //Erhöhung Pointer zwischenablage
          L     P#0.1; 
          +D    ; 
          T     #Pointer_Ausgang_Intern; 
    //++++++++++++++++++++++++++++++++++++++++++++++++++
          L     #schleife; 
          LOOP  next; 
    //*******************************************************************************
          L     P##Einwort; //Vorbelegung AR1 mit EW
          LAR1  ; 
          L     P##Verzoegertes_Wort; //Vorbelegung AR2 mit Verzoegertes Wort
          LAR2  ; 
          L     P#18.0; //Zustand Zwischenablage
          T     #Pointer_Ausgang_Intern; 
          L     16; 
    nex2: T     #schleife; 
          UN     [AR1,P#0.0]; //Indirektes  Impuls Timer
          L     #Zeit_S5; 
          SI    T [#Timer_S5_T]; 
          U     T [#Timer_S5_T]; 
          O     L [#Pointer_Ausgang_Intern]; 
          =      [AR2,P#0.0]; 
          L     P#0.1; //Pointererhöhung um ein Bit
          +AR1  ; 
          +AR2  ; 
          L     #Pointer_Ausgang_Intern; //Erhöhung Pointer zwischenablage
          L     P#0.1; 
          +D    ; 
          T     #Pointer_Ausgang_Intern; 
          L     #Timer_S5_T; 
          L     1; // Timernummererhöhung um 1
          +I    ; 
          T     #Timer_S5_T; 
          L     #schleife; 
          LOOP  nex2; 
    //*******************************************************************************
    //Rückspielung der AR Register
          LAR1  #AR1_Speicher; 
          LAR2  #AR2_Speicher; 
    END_FUNCTION
    Viele Grüße Bernard
    Angehängte Grafiken Angehängte Grafiken
    Geändert von Bernard (15.11.2009 um 10:46 Uhr) Grund: Fehlerbeseitigung
    Zitieren Zitieren aber ich will es auf jedes Bit und nicht auf dem ganzen Word.  

  5. #5
    Registriert seit
    16.06.2003
    Ort
    88356 Ostrach
    Beiträge
    4.811
    Danke
    1.231
    Erhielt 1.101 Danke für 527 Beiträge

    Standard

    generiere dir einen impuls der ausreichend genau für deine zeitauflösung ist. zb. 1s takt aus dem taktmerkerbyte der cpu...

    wenn du dann jeden eingang 4s verzögern willst, dann mache ein array mit 4 worten. diese nutzt du als schiebregister.

    mit eine flanke des sekundentaktes triggerst du nun dein schieberegister.

    in etwa so:

    u m100.4 /taktmerker 1s
    fp m1.0
    spbn move

    l puffer[3]
    t puffer [4]

    l puffer[2]
    t puffer[3]

    l puffer[1]
    t puffer [2]

    l ew
    t puffer[1]
    move: nop 0


    auswertung

    l puffer[1]
    l puffer[2]
    ow
    l puffer[3]
    ow
    l puffer[4]
    ow
    t aw

    ..und lass den scheiss mit den timern...
    "Es ist weit besser, große Dinge zu wagen, ruhmreiche Triumphe zu erringen, auch wenn es manchmal bedeutet, Niederlagen einzustecken, als sich zu den Krämerseelen zu gesellen, die weder große Freude noch großen Schmerz empfinden, weil sie im grauen Zwielicht leben, das weder Sieg noch Niederlage kennt." Theodore Roosevelt - President of the United States (1901-1909)

  6. #6
    Registriert seit
    28.01.2009
    Ort
    Hamburg
    Beiträge
    199
    Danke
    52
    Erhielt 54 Danke für 34 Beiträge

    Standard

    Hallo Markus,

    deine Idee mit dem Schieberegister ist schön und überschaubar.
    Aber wenn nun die Einschaltzeit ungleich der Ausschaltverzögerung sein soll,was dann? Bei den "Scheiß Timern" muß man lediglich einen Parameter
    hinzufügen und an einer Stelle im Programm einbinden.Wenn man will könnte man sogar für jedes einzelne Bit verschiedene Ein-Ausschaltzeiten definieren (Array[0..15] of s5time).

    Viele Grüße Bernard
    Zitieren Zitieren Schieberegister  

  7. #7
    Registriert seit
    16.06.2003
    Ort
    88356 Ostrach
    Beiträge
    4.811
    Danke
    1.231
    Erhielt 1.101 Danke für 527 Beiträge

    Standard

    Zitat Zitat von Bernard Beitrag anzeigen
    Hallo Markus,

    deine Idee mit dem Schieberegister ist schön und überschaubar.
    Aber wenn nun die Einschaltzeit ungleich der Ausschaltverzögerung sein soll,was dann?
    wie meinst du das?

    Bei den "Scheiß Timern" muß man lediglich einen Parameter
    hinzufügen und an einer Stelle im Programm einbinden.Wenn man will könnte man sogar für jedes einzelne Bit verschiedene Ein-Ausschaltzeiten definieren (Array[0..15] of s5time).

    Viele Grüße Bernard
    dann mache das wengisten mit nem fb und nimm iec timer (sfb4)
    "Es ist weit besser, große Dinge zu wagen, ruhmreiche Triumphe zu erringen, auch wenn es manchmal bedeutet, Niederlagen einzustecken, als sich zu den Krämerseelen zu gesellen, die weder große Freude noch großen Schmerz empfinden, weil sie im grauen Zwielicht leben, das weder Sieg noch Niederlage kennt." Theodore Roosevelt - President of the United States (1901-1909)

  8. #8
    Registriert seit
    23.04.2009
    Ort
    Allgäu
    Beiträge
    3.042
    Danke
    241
    Erhielt 863 Danke für 617 Beiträge

    Standard

    Hallo Bernard,

    da muss ich schon mal sagen "Respekt".
    Ich hoffe doch Eloboy lässt sich mal zu einem Danke herab.

    Das mit den 32 Zeiten gefällt mir auch nicht so, und es sollten dann schon variable Zeiten sein.
    Mein erster Gedanke war auch wie Markus schreibt mit den IEC-Timern oder einfach Sekunden zählen.
    Zitat Zitat von Markus Beitrag anzeigen
    dann mache das wengisten mit nem fb und nimm iec timer (sfb4)
    Aber natürlich geht das nur mit einem FB, doch nun kommt der Adressenversatz ins spiel.
    Vielleicht könnte der Baustein als FB mit variablen Zeitenwerten und Zeitgliedern dann doch ausarten und jeher unübersichtlich werden.
    Gruß
    Paule
    ----------------------------------------------------------------------------
    > manchmal verliert man und manchmal gewinnen die anderen <

  9. #9
    Registriert seit
    28.01.2009
    Ort
    Hamburg
    Beiträge
    199
    Danke
    52
    Erhielt 54 Danke für 34 Beiträge

    Standard

    Ich habe den Baustein nochmal überarbeitet.
    Jedes Bit ist bzgl. seines zeitlichen Ein-Ausschalten einzeln einstellbar.
    Für die Ein-Auszeiten wuden zwei Zeitarray`s als Eingangsgrössen definiert.Bei den Timern bin ich bei den S5Timern geblieben,weil sie sich besonders für die indirekte Adressierung eignen.Ein Ausgangsparameter benennt den letzten benutzten Timer.
    Projekt und Beschaltungscode liegen bei.

    Code:
    FUNCTION "EW_ein_aus_Zeitversatz" : VOID
    TITLE =
    VERSION : 0.1
     
    VAR_INPUT
      Einwort : WORD ; 
      Anf_s5_Timer_X_32 : INT ; //Belegt ab der Anfangsnummer 32 s5 Timer
      Zeitfeld_S5_Ein : ARRAY  [1 .. 16 ] OF S5TIME ; 
      Zeitfeld_S5_Aus : ARRAY  [1 .. 16 ] OF S5TIME ; 
    END_VAR
    VAR_OUTPUT
      Verzoegertes_Wort : WORD ; 
      Letzte_Timer_NR : INT ; 
    END_VAR
    VAR_TEMP
      AR1_Speicher : DWORD ; 
      AR2_Speicher : DWORD ; 
      schleife : INT ; 
      Timer_S5_T : INT ; 
      Pointer_Aus_Intern_ein : DWORD ; 
      Ausgang_Intern_ein : WORD ; 
      Pointer_Zeitfeld_Intern : DWORD ; 
      DBNR : INT ; 
      PointerAus_Intern_aus : DWORD ; 
      Ausgang_Intern_allgemein : WORD ; 
    END_VAR
    BEGIN
    NETWORK
    TITLE =
    //Rettung der AR Register
          TAR1  #AR1_Speicher; 
          TAR2  #AR2_Speicher; 
    //*******************************************************************************
    //*******************************************************************************
          L     P##Einwort; //Vorbelegung AR1 mit EW
          LAR1  ; 
          L     P##Zeitfeld_S5_Ein; //Vorbelegung AR2 Anfang Zeitfeld ein
          LAR2  ; 
          L     #Anf_s5_Timer_X_32; //Übergabe Anfangstimer
          T     #Timer_S5_T; 
          L     P#16.0; //Zustand Zwischenablage Ausgang intern
          T     #Pointer_Aus_Intern_ein; 
    //+++++++++++++++++++++++++++++++++++++++++++++++++++
          L     W [AR2,P#0.0]; //indirektes Adressieren Datenbaustein Zeitfeld EIN
          T     #DBNR; 
          L     D [AR2,P#2.0]; //Adressanfang der Zeiten
          T     #Pointer_Zeitfeld_Intern; 
    //*******************************************************************************
          L     16; 
    next: T     #schleife; 
    //--------------------------------
          AUF   DB [#DBNR]; //indirektes öffnen des Datenbausteiens
          U      [AR1,P#0.0]; //Einzelnes Bir des Eingangswortes
          L     DBW [#Pointer_Zeitfeld_Intern]; //indirektes laden der verschiedenen Zeiten
          SE    T [#Timer_S5_T]; 
          U     T [#Timer_S5_T]; 
          =     L [#Pointer_Aus_Intern_ein]; //Zuweisung einzelnes Bit im Ausgangswort intern
    //--------------------------------
          L     P#0.1; //Pointererhöhung ar1 um ein Bit
          +AR1  ; 
    //--------------------------------
          L     P#2.0; 
          L     #Pointer_Zeitfeld_Intern; //Pointererhöhung Adresse Zeitfeld
          +D    ; 
          T     #Pointer_Zeitfeld_Intern; 
    //--------------------------------
          L     1; // Timernummererhöhung um 1
          L     #Timer_S5_T; 
          +I    ; 
          T     #Timer_S5_T; 
    //--------------------------------
          L     #Pointer_Aus_Intern_ein; //Erhöhung PointerAusgang_inter
          L     P#0.1; 
          +D    ; 
          T     #Pointer_Aus_Intern_ein; 
    //--------------------------------
          L     #schleife; 
          LOOP  next; 
    //*******************************************************************************
    //*******************************************************************************
          L     P##Einwort; //Vorbelegung AR1 mit EW
          LAR1  ; 
          L     P##Zeitfeld_S5_Aus; //Vorbelegung AR2 Anfang Zeitfeld ein
          LAR2  ; 
          L     P#16.0; //Zustand Zwischenablage Ausgang intern ein
          T     #Pointer_Aus_Intern_ein; 
          L     P#28.0; 
          T     #PointerAus_Intern_aus; //Zustand Zwischenablage Ausgang intern aus
    //+++++++++++++++++++++++++++++++++++++++++++++++++++
          L     W [AR2,P#0.0]; //indirektes Adressieren Datenbaustein Zeitfeld aus
          T     #DBNR; 
          L     D [AR2,P#2.0]; //Adressanfang der Zeiten
          T     #Pointer_Zeitfeld_Intern; 
    //+++++++++++++++++++++++++++++++++++++++++++++++++++
          L     16; 
    nex2: T     #schleife; 
    //--------------------------------
          AUF   DB [#DBNR]; //indirektes öffnen des Datenbausteiens
          UN     [AR1,P#0.0]; //Einzelnes Bir des Eingangswortes
          L     DBW [#Pointer_Zeitfeld_Intern]; //indirektes laden der verschiedenen Zeiten
          SI    T [#Timer_S5_T]; 
          U     T [#Timer_S5_T]; 
          O     L [#Pointer_Aus_Intern_ein]; 
          =     L [#PointerAus_Intern_aus]; 
    //--------------------------------
          L     P#0.1; //Pointererhöhung ar1 um ein Bit
          +AR1  ; 
    //--------------------------------
          L     P#2.0; 
          L     #Pointer_Zeitfeld_Intern; //Pointererhöhung Adresse Zeitfeld
          +D    ; 
          T     #Pointer_Zeitfeld_Intern; 
    //--------------------------------
          L     1; // Timernummererhöhung um 1
          L     #Timer_S5_T; 
          +I    ; 
          T     #Timer_S5_T; 
    //--------------------------------
          L     #Pointer_Aus_Intern_ein; //Erhöhung PointerAusgang_inter ein
          L     P#0.1; 
          +D    ; 
          T     #Pointer_Aus_Intern_ein; 
          L     #PointerAus_Intern_aus; //Erhöhung PointerAusgang_inter aus
          L     P#0.1; 
          +D    ; 
          T     #PointerAus_Intern_aus; 
    //--------------------------------
          L     #schleife; 
          LOOP  nex2; 
    //Befehlsausgabe
          L     #Ausgang_Intern_allgemein; 
          T     #Verzoegertes_Wort; 
          L     #Timer_S5_T; 
          L     1; 
          -I    ; 
          T     #Letzte_Timer_NR; 
    //*******************************************************************************
    //Rückspielung der AR Register
          LAR1  #AR1_Speicher; 
          LAR2  #AR2_Speicher; 
          SET   ; 
          SAVE  ; 
     
    END_FUNCTION
    Viele Grüße Bernard
    Angehängte Grafiken Angehängte Grafiken
    Angehängte Dateien Angehängte Dateien
    Zitieren Zitieren Vielleicht könnte der Baustein als FB mit variablen Zeitenwerten und Zeitgliedern  

  10. #10
    Registriert seit
    29.03.2004
    Beiträge
    5.739
    Danke
    143
    Erhielt 1.686 Danke für 1.225 Beiträge

    Standard


    Zuviel Werbung?
    -> Hier kostenlos registrieren
    Da Markus ja was von "nimmste mal eben TON/TOF" schrieb, dachte ich mir, testest du mal gerade einen Baustein mit einem "ARRAY [0..15] OF TON".

    Pustekuchen. Das scheint so nicht zu gehen. Nichtmal in SCL bekommt man das hin.
    Jetzt habe ich mir gerade tierisch einen abgebrochen um das mittels UC und Parameterversorgung zu Fuß zu lösen, aber das kanns eigentlich auch nicht sein.

    Ich gucke morgen mal ob das bei Codesys mit einem Array of TON auch nicht geht, oder ob das nur Siemens-Spezial ist.

    Oder sollte das doch irgendwie anders gehen?

    Dieser Code funktioniert zumindest:
    Code:
    FUNCTION_BLOCK "WORDVerzoegerung"
    TITLE =Variable Ein/Ausschaltverzögerung mit TON/TOF
    //Sollzeiten in Array: [0] = Bit 1.0, [8] = Bit 0.0
    AUTHOR : TWI
    VERSION : 0.1
    
    
    VAR_INPUT
      wEinWord : WORD ;    //zu verzögerndes Wort
      tEinverz : ARRAY  [0 .. 15 ] OF //Keine Zeit T#0s einstellen!
      TIME  := T#3S;    
      tAusverz : ARRAY  [0 .. 15 ] OF //Keine Zeit T#0s einstellen!
      TIME  := T#4S;    
    END_VAR
    VAR_OUTPUT
      wVerzwort : WORD ;    //verzögertes Wort
    END_VAR
    VAR
      TONs : ARRAY  [0 .. 15 ] OF STRUCT     
       IN : BOOL ;    
       PT : TIME ;    
       Q : BOOL ;    
       ET : TIME ;    
       STATE : BYTE ;    
       STIME : TIME ;    
       ATIME : TIME ;    
      END_STRUCT ;    
      TOFs : ARRAY  [0 .. 15 ] OF STRUCT     
       IN : BOOL ;    
       PT : TIME ;    
       Q : BOOL ;    
       ET : TIME ;    
       STATE : BYTE ;    
       STIME : TIME ;    
       ATIME : TIME ;    
      END_STRUCT ;    
    END_VAR
    VAR_TEMP
      i : INT ;    
      dwAR2_save : DWORD ;    
      dwTONArrayOffset : DWORD ;    
      dwTIMEArrayOffset : DWORD ;    
      wEW_IN_temp : WORD ;    
      wEW_OUT_temp : WORD ;    
      wBitmask : WORD ;    
      xTON_IN : BOOL ;    
      xTON_Q : BOOL ;    
      tTON : TIME ;    
      tTOF : TIME ;    
    END_VAR
    BEGIN
    NETWORK
    TITLE =Timer bearbeiten
    
    // Auf Temp Bereich kopieren, damit AR2 Offset hier nicht einbezogen werden muss
          L     #wEinWord; 
          T     #wEW_IN_temp; 
    
          L     W#16#0; 
          T     #wEW_OUT_temp; 
    
    // Bitmaske initialisieren
          L     W#16#1; // wBitmask = (1 << 0);
          T     #wBitmask; 
    
          L     0; 
          T     #i; // i = 0;
    
          TAR2  #dwAR2_save; // AR2 sichern 
    //--------------------------------------     
    // Schleife
    lop:  NOP   0; // do {  
    // Array Offset nur einmal pro Schleifendurchlauf berechnen
          L     #i; 
          L     22; // sizeof(TON) und sizeof(TOF) = 22 Bytes
          *I    ; 
          SLD   3; 
          T     #dwTONArrayOffset; 
    
          L     #i; 
          L     4; // sizeof(TIME) = 4 Bytes
          *I    ; 
          SLD   3; 
          T     #dwTIMEArrayOffset; 
    // Sollzeiten einlesen
          L     P##tEinverz; 
          +AR2  ; 
          L     #dwTIMEArrayOffset; 
          +AR2  ; 
          L     DID [AR2,P#0.0]; 
          T     #tTON; 
    
          LAR2  #dwAR2_save; // AR2 wiederherstellen
    
          L     P##tAusverz; 
          +AR2  ; 
          L     #dwTIMEArrayOffset; 
          +AR2  ; 
          L     DID [AR2,P#0.0]; 
          T     #tTOF; 
    
          LAR2  #dwAR2_save; // AR2 wiederherstellen
    // Bit ausmaskieren
          L     #wEW_IN_temp; 
          L     #wBitmask; 
          UW    ; 
          SPP   bOn; // "Und" Verknüpfung war positiv (A1-Bit Statusregister)
          CLR   ; 
          =     #xTON_IN; 
          SPA   bEx; 
    bOn:  SET   ; 
          =     #xTON_IN; 
    
    //--------------------------------------
    // Einschaltverzögerung  TON
    
    // Offset auf TON Struktur bauen
    bEx:  L     P##TONs; // Pointer auf TON Array
          +AR2  ; // AR2 Offset addieren
          L     #dwTONArrayOffset; 
          +AR2  ; // Offset in Array
    // TON beschalten
          L     #tTON; 
    // DID[AR2,P#2.0] wird automatisch in falsches Symbol umgewandelt!
          T     #tEinverz[0]; // Position "PT"
    
          U     #xTON_IN; 
          =     DIX [AR2,P#0.0]; // Position "IN"
    
          UC    "TON"; // Bausteinaufruf
    
    // TON Ausgang lesen
          U     DIX [AR2,P#6.0]; // Position "Q"
          =     #xTON_Q; 
    
          LAR2  #dwAR2_save; // AR2 wiederherstellen
    
    //--------------------------------------
    // Ausschaltverzögerung TOF
          L     P##TOFs; // Pointer auf TOF Array
          +AR2  ; // AR2 Offset addieren
          L     #dwTONArrayOffset; 
          +AR2  ; // Offset in Array
    // TOF beschalten
          L     #tTOF; 
    // DID[AR2,P#2.0] wird automatisch in falsches Symbol umgewandelt!
          T     #tEinverz[0]; // Position "PT" ( 
    
          U     #xTON_Q; 
          =     DIX [AR2,P#0.0]; // Position "IN"
    
          UC    "TOF"; // Bausteinaufruf  
    
    // TOF Ausgang lesen
          U     DIX [AR2,P#6.0]; // Position "Q"
          SPBN  of; 
    // Ausgang von TOF ist gesetzt, bit in Word setzen
          L     #wBitmask; 
          L     #wEW_OUT_temp; 
          OW    ; 
          T     #wEW_OUT_temp; 
    
    of:   LAR2  #dwAR2_save; // AR2 wiederherstellen
    //--------------------------------------
    // Bitmaske weiterschieben
          L     #wBitmask; // wBitmask <<= 1;
          SLW   1; 
          T     #wBitmask; 
    
          L     #i; 
          L     1; 
          +I    ; 
          T     #i; // i++;
          L     15; // } while (i <= 15);
          <=I   ; 
          SPB   lop; 
    //--------------------------------------
    // Temp Wort ausgeben
          L     #wEW_OUT_temp; 
          T     #wVerzwort; 
    
          LAR2  #dwAR2_save; // AR2 wiederherstellen
          SET   ; 
          SAVE  ; 
    END_FUNCTION_BLOCK

Ähnliche Themen

  1. AKF 13 gesucht
    Von dben im Forum PC- und Netzwerktechnik
    Antworten: 1
    Letzter Beitrag: 16.07.2012, 08:03
  2. Antworten: 3
    Letzter Beitrag: 17.09.2011, 16:11
  3. S7 - 212 gesucht ...
    Von smartie im Forum Suche - Biete
    Antworten: 2
    Letzter Beitrag: 31.03.2006, 14:29
  4. FB 42 & FB 51 gesucht.
    Von Köbes11 im Forum HMI
    Antworten: 0
    Letzter Beitrag: 20.01.2005, 07:53
  5. Gesucht: S5-CPU 928
    Von PeterEF im Forum Suche - Biete
    Antworten: 2
    Letzter Beitrag: 03.01.2005, 07:30

Lesezeichen

Berechtigungen

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