Step 7 TAW, Schiebefunktion und Bit-Wertigkeiten

winRARE

Level-1
Beiträge
9
Reaktionspunkte
0
Zuviel Werbung?
-> Hier kostenlos registrieren
Hallo liebe Gemeinde,

dieses ist mein erster Beitrag in diesem Forum, soll aber nicht so bleiben :rolleyes:.
Kurzer Überblick: Arbeite mit S7 seit knapp 1 Jahren erst, vorwiegend mit FC-Bausteinen und in FUP. Nun habe ich den Sprung in die FB-Bausteine gewagt und ebenfalls die Programmiersprache auf AWL umgestellt. Gibt da einfach zu viele Vorteile drin.

Zur Problematik: Ich habe seit Freitag den Einstieg in den Dateityp "Word" gemacht und soll nun ein kleines Programm schreiben, welches für unsere Maschine als Test fungiert, soll heißen, dass wir jeden Ausgang per Tastendruck anwählen können und so jenen beobachten können.
Es gibt 2 Taster (E125.0, E125.1) mit denen ich jeweils "Vor- bzw Zurückspringen" kann.
Das "Springen" erfolgt danach per Schiebefunktion (Ebenfalls Neuland).

Das Problem ist nun folgendes: Das Programm funktioniert soweit so gut wie es auch soll, heute habe ich den TAW Befehl eingefügt, da sonst mein Bit mit der Wertigkeit 1 der A125.0 ist, ich jedoch am Anfang gerne A124.0 ansteuern möchte. Alternativ hätte ich auch L 256 machen können.

Wenn das Programm den A124.0 schaltet und ich zurückspringe, lande ich auf A125.7 bis hin zu A125.0, danach aber auf 124.0 und nicht auf 124.7, so wie ich es vermute. Wenn ich ab 124.0 vorspringe, springt er bei A124.7 den darauffolgenden Schritt wieder auf A124.0. Mit anderen Worten: Ungenügend irgendwie. A124.0 hat die Wertigkeit 256, A124.7 die Wertigkeit -32786 (höchstwertigstes Bit) und A125.0 hat die Wertigkeit 1. Was muss ich ändern, damit ich ganz normal durchklicken kann das Programm, ohne das auf A124.0 zurückgesprungen wird(außer natürlich es wird gewollt :ROFLMAO:)

Hier mein Programm:
OB1:


U E 126.6
= L 20.0
BLD 103
U E 125.1
= L 20.1
BLD 103
U E 125.0
= L 20.2
BLD 103
CALL FB 1 , DB1
Not_Aus :=L20.0
Taster_Start:=L20.1
Taster_EV :=L20.2
EINGANG :=AW124
Ausgang :=AW124
NOP 0

FB1


L #EINGANG
L 0
==I // Einmaliger Vergleich bei SPS-Start
SPBN nw3 // Bei Routineablauf in NW3 springen
L 1 // lade Wertigkeit 1 ins Word
TAW // Tauschen des Bytes; start bei A124.0
T #Ausgang // Ergebniss ins AW transferieren
nw3: L #EINGANG
U #Taster_Start //"Vorspringen"
FP #Flp // Flanke
SPB nw5 //Fortsetzung NW5
U #Taster_EV //"Zurückspringen"
FP #Flp2 //Flanke
SPB nw7 //Fortsetzung NW7
BE // Ansonsten BE

nw5: SRW 1 // Schiebebefehl rechts
SPB tra

nw7: SLW 1 //Schiebebefehl links

tra: NOP 0
T #Ausgang

BE

Bin über jeden Tip dankbar

Ps: Gibt es die Möglichkeit, dass das Programm besser hochgeladen werden kann?

Gruß

winRARE
 
Anmerkung: Es handelt sich um eine CPU 314C-2 DP. Als Software verwende ich Step 7 V5.5 +SP2

Code:
OB1: 


U E 126.6
 = L 20.0
 BLD 103
 U E 125.1
 = L 20.1
 BLD 103
 U E 125.0
 = L 20.2
 BLD 103
 CALL FB 1 , DB1
 Not_Aus :=L20.0
 Taster_Start:=L20.1
 Taster_EV :=L20.2
 EINGANG :=AW124
 Ausgang :=AW124
 NOP 0
 
FB1
 

L #EINGANG
 L 0
 ==I                                  // Einmaliger Vergleich bei SPS-Start
 SPBN nw3                         // Bei Routineablauf in NW3 springen
 L 1                                   // lade Wertigkeit 1 ins Word
 TAW                                 // Tauschen des Bytes; start bei A124.0
 T #Ausgang                      // Ergebniss ins AW transferieren
 nw3: L #EINGANG
 U #Taster_Start                //"Vorspringen"
 FP #Flp                            // Flanke
 SPB nw5                          //Fortsetzung NW5
 U #Taster_EV                  //"Zurückspringen"
 FP #Flp2                         //Flanke
 SPB nw7                         //Fortsetzung NW7
 BE                                  // Ansonsten BE
 
nw5: SRW 1                     // Schiebebefehl rechts
 SPB tra
 
nw7: SLW 1                     //Schiebebefehl links
 
tra: NOP 0
 T #Ausgang
 
BE


So ist das evtl übersichtlicher?
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Als Nachtrag eventuell: Wenn ich das Programm ohne TAW durchlaufen lassen, wenn also der Ausgang 125.0 bei Programmstart angesteuert wird, dann kann ich ganz normal durchschalten, nur kann ich mit "zurückspringen" nicht mehr von A125.0 auf A124.7 springen.

Evtl. hilft das ein wenig weiter
 
Ps: Gibt es die Möglichkeit, dass das Programm besser hochgeladen werden kann?

Ja. # anklicken (Code).

wieso eigentlich?

EINGANG :=AW124
Ausgang :=AW124

da TAW'st du dich im Kreis rum.

Nimm doch ein Wort im Stat-Bereich (deklarieren) und arbeite mit diesem weiter.
Am Ende transferierst das auf das AW124 (Out)
 
Was mir noch auffällt:
Bei "Vorspringen" nutzt Du SRW und bei "Zurückspringen" SLW. Lies Dir mal Die Hilfe dazu durch. Wenn Du zurückspringst, wird das Wort nach links verschoben, das heißt, Dein Merker wird auf die nächstHÖHERE Adresse verschoben und umgekehrt. Du solltest vielleicht mal beide Bytes separat in einer Variablentabelle beobachten, wielleicht klärt sich dann alles auf.
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Nachtrag: Es wird nicht auf die Nächsthöhere Adresse verschoben, sondern auf das nächsthöhere Bit.
Die Bytereihenfolge ist - wie immer bei STEP7 - so, dass das niedrigstadressierte Byte das höherwertigste ist.
 
Zuletzt bearbeitet:
Ich hab mal "quick + dirty" was geschrieben mit indirekter Adressierung über das Adressregister:

Code:
FUNCTION_BLOCK "BITPOS"
TITLE =
VERSION : 0.1


VAR_INPUT
  iAusgangswort : WORD ;    
  iBitPos_plus : BOOL ;    
  iBitPos_minus : BOOL ;    
END_VAR
VAR_OUTPUT
  oAusgangsbit : BOOL ;    
END_VAR
VAR
  Bitposition : INT ;    
  FP_Plus : BOOL ;    
  FP_Minus : BOOL ;    
END_VAR
VAR_TEMP
  tmpAR1 : DWORD ;    
  tmpWort : WORD ;    
END_VAR
BEGIN
NETWORK
TITLE =AR1 sichern

      TAR1  #tmpAR1; 

NETWORK
TITLE =Eingangswort rangieren
//1. Kopieren des Eingangswortes auf "tmpWort"
//2. AR1 mit der Adresse von tmpWort laden
      L     #iAusgangswort; 
      T     #tmpWort; 
      LAR1  P##tmpWort; 
NETWORK
TITLE =Bitposition erhöhen

      U     #iBitPos_plus; 
      FP    #FP_Plus; 
      SPBN  inc; 

      L     #Bitposition; 
      L     1; 
      +I    ; 
      T     #Bitposition; 

inc:  NOP   0; 

NETWORK
TITLE =Bitposition verringern

      U     #iBitPos_minus; 
      FP    #FP_Minus; 
      SPBN  dec; 

      L     #Bitposition; 
      L     1; 
      -I    ; 
      T     #Bitposition; 

dec:  NOP   0; 

NETWORK
TITLE =Grenzen prüfen


      L     #Bitposition; 
      L     0; 
      <I    ; 
      SPBN  min; 

      L     0; 
      T     #Bitposition; 

min:  L     #Bitposition; 
      L     15; 
      >I    ; 
      SPBN  max; 

      L     15; 
      T     #Bitposition; 

max:  NOP   0; 
NETWORK
TITLE =

      L     #Bitposition; 
      +AR1  ; 

      U     L [AR1,P#0.0]; 
      =     #oAusgangsbit; 
NETWORK
TITLE =AR1 zurückschreiben

      LAR1  #tmpAR1; 

END_FUNCTION_BLOCK

Sollte so gehen. Fragen dürfen gern gestellt werden. Korrekturen sind auch erlaubt. :D

Vielleicht noch eine kurze Erklärung der Schnittstelle:

An "iAusgangswort" kommt das zu prüfende Ausgangswort.
An "oAusgangsbit" ein Ausgang der nicht in dem Bereich des zu prüfenden Worts liegt. Ggf. auch ein Merker.
 
Zuletzt bearbeitet:
Danke für die Ratschläge, ich versuche mich mal an den Zahlreichen Vorschlägen. Könnte unter Umständen ein wenig dauern :rolleyes:
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Also ich würde die AR1 ; AR2 (Adressregister) nur dann benützen wenn ich mich auf die Adresse eines gegebenen Formalparameter beziehen würde ! ... sonst immer die Speicherindirekten Pointer benutzen (die mit den rechteckigen Klammer).

Geschmacksache und Bequemlichkeit ;)

(viele Wege nach Rom ...usw)
 
Wie würde Schieben auf zB. 134 Bits funktionieren ?
Schieben geht nur bis DWORD Länge , oder ?
Das andere löst man mit Pointer , nicht ?

:confused:
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Code:
      U     E      0.0                  //Mehrmals tasten und beobachten
      FP    M      100.0
      SPBN  o1
      R     A [MD 0]
      L     MD     0
      +      1   
      T     MD     0
      S     A [MD 0]

o1:   U     E      0.1                  //Initialisieren
      FP    M      100.1
      SPBN  o2
      L     L#0
      T     MD     0

o2:   BE

Kannst damit spielen und (vieleicht) ein Prinzip daraus leiten :)
 
Ich hab mal "quick + dirty" was geschrieben mit indirekter Adressierung über das Adressregister:

An "iAusgangswort" kommt das zu prüfende Ausgangswort.
An "oAusgangsbit" ein Ausgang der nicht in dem Bereich des zu prüfenden Worts liegt. Ggf. auch ein Merker.

Das Programm funktioniert so nicht, evtl liegt der Fehler auch bei mir. An "oAusgangsbit" habe ich mit Merker 130.0 versehen, an iAusgangswort das AW124. In der Schnittstelle des FB habe ich ja
VAR_INPUT
iAusgangswort : WORD ;
als Eingang deklariert und den "oAusgangsbit" als Ausgang. Müsste ich das zu prüfende Ausgangswort AW124 nicht als Ausgang deklarieren??
 
Zuviel Werbung?
-> Hier kostenlos registrieren
@00alex:
Du verbreitest Unsinn.

Es gibt keine Anweisung "- 1", zudem muss bei negativen Zahlen zwuschen INT und DINT unterschieden werden. Die Anweisung zum Rückwärtszählen muss korrekt "+ L#-1" heißen.
 
@00alex:
Du verbreitest Unsinn.

Es gibt keine Anweisung "- 1", zudem muss bei negativen Zahlen zwuschen INT und DINT unterschieden werden. Die Anweisung zum Rückwärtszählen muss korrekt "+ L#-1" heißen.


+i16 vs +i32 ?

+i16 ist INTEGER addiern mit nur einem Akku ;)

Hier kann man ruhig +i16 benutzen ...nachdem man das "DWord" die Variable mit +i32 initialisiert hat !

Warum hier +i16 reicht ? ... weil niemand 32000 mal ein Bit verschiebt ;) ...ist nur eine Idee das Programmchen ... unfertig !

MEA CULPA ! Hab S7 nicht zur Hand !

Geht...vieleicht "+ -1" ?
 
Zuletzt bearbeitet:
@00alex
Wenn man keine Ahnung hat, einfach mal den Mund halten! Du hast in einem einzigen Post gleich zwei unwahre Behauptungen aufgestellt und hast dann noch darauf beharrt, nachdem Du korrigiert wurdest. Du wurdest schon dafür gesperrt, dass Du mehrfach Fragesteller mit unwahren Behauptungen verwirrt hast. Bist Du eigentlich komplett beratungsresistent?

Zudem ist es schlechter Stil, die falschen Behauptungen in einem EDIT in sehr, sehr kleiner Schrift zu korrigieren.

Ich bin kurz davor, Deinen Beitrag zu melden, offensichtlich bist Du ja nicht zur Einsicht fähig.
 
Zurück
Oben