Zugriff auf Lokaldaten in einem FC/FB [AWL/KUP]

vierlagig

Level-1
Beiträge
9.882
Reaktionspunkte
2.021
Zuviel Werbung?
-> Hier kostenlos registrieren
Eins vorweg, um AWL kommen wir nicht drumrum!

Des Öfteren wird gefragt, wie man auf einzelne Bits oder größere Bereiche der Lokaldaten, also IN, OUT, INOUT, STAT (nur FB) und TEMP zugreifen kann, um sie zu beeinflußen bzw. die Schnittstelle beim Aufruf so übersichtlich wie möglich zu halten.

Praktische Anwendung findet sowas z.B. bei der Auswertung von Statuswörtern von Frequenzumrichtern, aber es gibt der Anwendungsfälle sehr sehr viele.

Die Grundlagen:

In einem FB können alle Bereiche mit den im folgenden erläuterten Vorgehensweisen angesprochen werden. In einem FC können nur TEMP-Bereiche so angesprochen werden, da nur diese eine Adresse zugeordnet bekommen.

Das heißt: in einem FC muß teilweise vorher in den TEMP-Bereich kopiert werden.

Es wird folgender Ablauf vorgeschlagen, ein zusammengesetzer Datentyp wird zusammenhängend übergeben bzw. ist bereits vorhanden. z.B. ein WORD. Der Zugriff auf die einzelnen Bits soll nun erreicht werden um diese einzeln zu beeinflußen und zum guten Schluß soll das so beeinflußte WORD an die Außenwelt gegeben werden.
Dafür bieten sich zwei(drei) vorgehensweisen an, die im wesentlichen aber die selbe Grundstruktur zu Grunde liegen haben. Das zu zerlegende WORD wird in eine Struktur kopiert, die dem Zielaufbau entspricht, also

1. ein ARRAY[0..15] of bool
2. ein STRUCT mit 16 bits (oder vielleicht auch 8bits und 1byte - also flexibler als ein array! die einzelnen Elemente können unterschiedlich benannt werden!)
3. eine UDT (ebenso flexibel wie ein struct, aber in mehreren Bausteinen verfügbar)

Diese wird im STAT oder TEMP Bereich angelegt und stellt später die Grundlage für jede weitere Bearbeitung der einzelnen Elemente dar.

Nun muß eigentlich nur noch das Eingangswort in die Struktur gepresst werden.

Wie Eingangs erwähnt: AWL und in FCs müßen wir in dem TEMP-Bereich kopieren.

Für einen FC mit einem STRUCT stTemp

Code:
  stTemp : STRUCT     
   xBit0_0 : BOOL ;    
   xBit0_1 : BOOL ;    
   xBit0_2 : BOOL ;    
   xBit0_3 : BOOL ;    
   xBit0_4 : BOOL ;    
   xBit0_5 : BOOL ;    
   xBit0_6 : BOOL ;    
   xBit0_7 : BOOL ;    
   xBit1_0 : BOOL ;    
   xBit1_1 : BOOL ;    
   xBit1_2 : BOOL ;    
   xBit1_3 : BOOL ;    
   xBit1_4 : BOOL ;    
   xBit1_5 : BOOL ;    
   xBit1_6 : BOOL ;    
   xBit1_7 : BOOL ;    
  END_STRUCT ;

z.B.:
Code:
*
      TAR1  #dTempAR1                   //Adressregister retten
      TAR2  #dTempAR2

      L     #wInput                     //das eingangswort
      T     #wTempInput                 //in den Temp-bereich kopieren, damit er indirekt adressiert werden kann

      LAR1  P##wTempInput               //startadrese der quelle in AR1
      LAR2  P##stTemp                   //startadresse des ziels in AR2

      L     W [AR1,P#0.0]               //wTempInput nach
      T     W [AR2,P#0.0]               //stTemp schreiben

      LAR1  #dTempAR1
      LAR2  #dTempAR2                   //Adressregister zurückschreiben
Für einen FB z.B.:
Code:
*
      TAR1  #dTempAR1                   //Adressregister retten
      TAR2  #dTempAR2

      
      LAR1  P##wInput                   //startadrese der quelle in AR1
      LAR2  P##stTemp                   //startadresse des ziels in AR2

      L     W [AR1,P#0.0]               //wTempInput nach
      T     W [AR2,P#0.0]               //stTemp schreiben

      LAR1  #dTempAR1
      LAR2  #dTempAR2                   //Adressregister zurückschreiben
Nun kann im folgenden auf die Structur-Elemente in den Sprachen KOP FUP und AWL zugegriffen werden ohne das eine absolute Adressierung benötigt wird.

also z.B.:

Code:
*
      U     #stTemp.xBit0_0
      U     #stTemp.xBit1_2
      =     #xOut
Sind alle Operationen ausgeführt, kopiert man das, um am Beispiel zu bleiben in den OUT-Bereich Typ WORD.

Für einen FC mit einem STRUCT stTemp z.B.:
Code:
*
      TAR1  #dTempAR1                   //Adressregister retten
      TAR2  #dTempAR2

      LAR1  P##stTemp                   //startadrese der quelle in AR1
      LAR2  P##wTempOutput              //startadresse des ziels in AR2

      L     W [AR1,P#0.0]               //stTemp nach
      T     W [AR2,P#0.0]               //wTempOutput schreiben

      LAR1  #dTempAR1
      LAR2  #dTempAR2                   //Adressregister zurückschreiben

      L     #wTempOutput                //aus dem Temp-Bereich
      T     #wOutput                    //auf den Ausgang kopieren
Für einen FB z.B.:
Code:
*
      TAR1  #dTempAR1                   //Adressregister retten
      TAR2  #dTempAR2

      LAR1  P##stTemp                   //startadrese der quelle in AR1
      LAR2  P##wOutput                  //startadresse des ziels in AR2

      L     W [AR1,P#0.0]               //stTemp nach
      T     W [AR2,P#0.0]               //wTempOutput schreiben

      LAR1  #dTempAR1
      LAR2  #dTempAR2                   //Adressregister zurückschreiben
Natürlich funktioniert das ganze auch für Byte und DWord und entsprechenden Zusammensetzungen und man muß auch nicht vorn rein und hinten wieder raus ;)

Viel Spaß und gutes gelingen!
 
Zuletzt bearbeitet:
Zurück
Oben