Indirekte Adressierung FB mit Pointern

kliebisch.m

Level-1
Beiträge
120
Reaktionspunkte
5
Zuviel Werbung?
-> Hier kostenlos registrieren
Hallo,

ich habe ein Problem.
Der FB120 im Anhang dient zur Auswertung von Endlagen.
Diese werden je nach Nummer im IN in verschiedene statische Daten im Instanzdatenbaustein geschrieben/gelesen.
Im Moment geschieht dies über Sprünge.

Die Lösung ist aber zu Umständlich und Speicherintensiv.

Habe schon versucht, selber an eine Lösung mit Pointern und dann statische Adresszuweisung zu kommen. Jedoch ohne Erfolg.

Veilleicht hat jemand eine Lösung für mich für:
Statische Adressverwaltung des Programmteils (ab NW2, was sich in jedem weiteren NW wiederholt halt) je nachdem, welche Nummer im IN steht.

Danke für Hilfe
 

Anhänge

  • FB120.zip
    3,4 KB · Aufrufe: 23
und in SCL? ich meine, da würde die array-adressierung sehr viel besser gehen!

und ja, sicher kann man das auch indirekt adressieren, mußt dir halt nur die adressen richtig berechnen...
 
Zuviel Werbung?
-> Hier kostenlos registrieren
ohne zu testen, hab ichs mal versucht umzusetzen...

Code:
*
FUNCTION_BLOCK FB 120
TITLE =
VERSION : 0.1


VAR_INPUT
  NUMMER : INT ;	//Zylindernummer
  Auswertung : INT  := 1;	//1-beide Endlagen, 2-nur GS, 3-nur AS
  IN_AS : BOOL ;	//Sensor AS
  IN_GS : BOOL ;	//Sensor GS
  Sekundentakt : BOOL ;	//Sekundentakt von SPS M2.5
  Ueberwachungszeit : INT ;	//Ueberwachungszeit Endlagen in Sekunden
  Quittieren : BOOL ;	//Störung Quittieren
  OUT_Tipp : BOOL ;	//1 - Ausgang Hand Tippen 0 - Ausgänge setzen in Hand
  HAND : BOOL ;	//Handbetrieb
  Freigabe_GS : BOOL ;	//Freigabe, für GS anfahren
  Freigabe_AS : BOOL ;	//Freigabe, für AS anfahren
END_VAR
VAR_IN_OUT
  OUT_AS : BOOL ;	//Ausgang AS
  OUT_GS : BOOL ;	//Ausgang GS
END_VAR
VAR
  Fehlerbits : STRUCT 	
   Zylinder : ARRAY  [0 .. 99 ] OF STRUCT 	
    Fehler_GS : BOOL ;	//Endlage fehlt GS
    Fehler_AS : BOOL ;	//Endlage fehlt AS
    Fehler_GS_AS : BOOL ;	//Sensorfehler GS und AS
   END_STRUCT ;	
  END_STRUCT ;	
  Zylinder : ARRAY  [0 .. 99 ] OF STRUCT 	
   FL_Zahler_plus : BOOL ;	//Impuls für Sekundenzähler
   in_AS : BOOL ;	//Steuerung von MP
   in_GS : BOOL ;	//Steuerung von MP
   Zaehler_GS : INT ;	//Zähler in GS
   Zaehler_AS : INT ;	//Zähler in AS
  END_STRUCT ;	
  Fehlerbit : BOOL ;	//Bit zur Aktivierung Fehlermeldung
  Quittierung : BOOL ;	
  keine_Freigabe : BOOL ;	//Out für Ansteuerung BM keine Freigabe
END_VAR
VAR_TEMP
  TEMPAR1 : DWORD ;	
  TEMPAR2 : DWORD ;	
  ErrorAR1 : DWORD ;	
  ZylinderAR1 : DWORD ;	
END_VAR
BEGIN
NETWORK
TITLE =

      TAR1  #TEMPAR1; 
      TAR2  #TEMPAR2; 

      LAR1  P##Fehlerbits; 
      L     #TEMPAR2; 
      +AR1  ; 
      L     #NUMMER; 
      L     2; 
      *I    ; 
      SLD   3; 
      +AR1  ; 
      TAR1  #ErrorAR1; 


      LAR1  P##Zylinder; 
      L     #TEMPAR2; 
      +AR1  ; 
      L     #NUMMER; 
      L     6; 
      *I    ; 
      SLD   3; 
      +AR1  ; 
      TAR1  #ZylinderAR1; 
NETWORK
TITLE =Zähler GS/AS
//00
      LAR1  #ZylinderAR1; 
      U     #Sekundentakt; // Flanke erzeugen für Zähler
      FP    DIX [AR1,P#0.0]; 

      U     DIX [AR1,P#0.0]; 
      SPBN  GS00; 

      U     #OUT_AS; // Zähler vorwärts AS
      SPBN  AS00; 
      L     DIW [AR1,P#4.0]; 
      L     1; 
      +I    ; 
      T     DIW [AR1,P#4.0]; 

AS00: U     #OUT_GS; // Zähler vorwärts GS
      SPBN  GS00; 
      L     DIW [AR1,P#2.0]; 
      L     1; 
      +I    ; 
      T     DIW [AR1,P#2.0]; 
GS00: U     #IN_AS; // Zähler zurücksetzen AS
      U     #OUT_AS; 
      UN    #IN_GS; 
      ON    #OUT_AS; 
      SPBN  AP00; 
      L     0; 
      T     DIW [AR1,P#4.0]; 
AP00: U     #IN_GS; // Zähler zurücksetzen GS
      U     #OUT_GS; 
      UN    #IN_AS; 
      ON    #OUT_GS; 
      SPBN  GP00; 
      L     0; 
      T     DIW [AR1,P#2.0]; 

GP00: L     #Auswertung; // AS und GS Überwachung? Sprung
      L     1; 
      ==I   ; 
      SPB   S200; 
      L     #Auswertung; // Wenn nur GS überwacht wird, Sprung
      L     2; 
      ==I   ; 
      SPB   S200; 
      L     #Auswertung; // Wenn nur AS überwacht wird, Sprung
      L     3; 
      ==I   ; 
      SPB   S300; 
      SPA   S400; 

S200: U(    ; 
      L     DIW [AR1,P#2.0]; // Zuweisung Fehlermeldung GS
      L     #Ueberwachungszeit; 
      >I    ; 
      UN    #IN_GS; 
      UN    #IN_AS; 
      )     ; 
      O(    ; 
      L     DIW [AR1,P#4.0]; 
      L     #Ueberwachungszeit; 
      >I    ; 
      U     #IN_GS; 
      )     ; 
      LAR1  #ErrorAR1; 
      S     DIX [AR1,P#0.0]; 
      S     #Fehlerbit; 

      L     #Auswertung; // AS und GS Überwachung? Sprung
      L     1; 
      ==I   ; 
      SPB   S300; 
      SPA   S400; 

      LAR1  #ZylinderAR1; 
S300: U(    ; 
      L     DIW [AR1,P#4.0]; // Zuweisung Fehlermeldung AS
      L     #Ueberwachungszeit; 
      >I    ; 
      UN    #IN_AS; 
      UN    #IN_GS; 
      )     ; 
      O(    ; 
      L     DIW [AR1,P#2.0]; 
      L     #Ueberwachungszeit; 
      >I    ; 
      U     #IN_AS; 
      )     ; 
      LAR1  #ErrorAR1; 
      S     DIX [AR1,P#0.1]; 
      S     #Fehlerbit; 

S400: U     #IN_GS; 
      U     #IN_AS; 
      S     DIX [AR1,P#0.2]; 
      S     #Fehlerbit; 
      U     #Quittieren; // Reset Quittierung
      SPBN  G000; 
      R     DIX [AR1,P#0.0]; 
      R     DIX [AR1,P#0.1]; 
      R     DIX [AR1,P#0.2]; 
      R     #Fehlerbit; 
      LAR1  #ZylinderAR1; 
      L     0; 
      T     DIW [AR1,P#2.0]; 
      T     DIW [AR1,P#4.0]; 

G000: U     DIX [AR1,P#0.2]; 
      U     #HAND; 
      U     #Freigabe_GS; 
      S     #OUT_GS; 
      R     #OUT_AS; 

      U     DIX [AR1,P#0.1]; 
      U     #HAND; 
      U     #Freigabe_AS; 
      S     #OUT_AS; 
      R     #OUT_GS; 

      U     #OUT_Tipp; 
      UN    DIX [AR1,P#0.2]; 
      UN    DIX [AR1,P#0.1]; 
      U     #HAND; 
      R     #OUT_GS; 
      R     #OUT_AS; 

      U(    ; 
      U     DIX [AR1,P#0.2]; 
      U     #HAND; 
      U     #Freigabe_GS; 
      )     ; 
      O(    ; 
      U     DIX [AR1,P#0.1]; 
      U     #HAND; 
      U     #Freigabe_AS; 
      )     ; 
      S     #keine_Freigabe; 

      UN    DIX [AR1,P#0.1]; 
      UN    DIX [AR1,P#0.2]; 
      R     #keine_Freigabe; 

      SPA   ENDE; 
NETWORK
TITLE =Ende

ENDE: LAR1  #TEMPAR1;
      LAR2  #TEMPAR2; 

END_FUNCTION_BLOCK
 
Zurück
Oben