Pointer auf Bits im Datenbaustein

Omit78 · 22 Juni 2012

Guten Morgen zusammen!

Ich möchte gerne mit einer Schleife bestimmte Bits in einem Datenbaustein abfragen. Leider ist mir das trotz der vielfachen Beiträge über Pointer nicht gelungen. Den Pointer auf ein ganzes Wort zu richten ist mir mit http://www.sps-forum.de/showthread.php/8887-Pointer-Zeiger-FIFO-LIFO gelungen. Mein Datenbaustein besteht übrigens aus zwei Ints.

Wie muss dann der Zeiger aussehen.

Gruß Timo

M-Ott · 22 Juni 2012

Wenn Du in einer Schleife abfragen möchtest, dann darfst Du keine Schiebeoperation ausführen, sondern musst Deinen Pointer direkt im Format P#Byteadresse.Bitadresse angeben.

Ralle · 22 Juni 2012

Das geht folgendermaßen:

Code:

      L     P#0.0
      L     #Adr     //als Input INT
      SLD   3
      +D    
      L     #Bit_Nr  //als Input INT
      +D    
      T     #pointer_1   //als Temp DWord

      L     #DB_Nr    //als Input INT
      T     #DB_Nr_temp //als Temp Word
      AUF   DB [#DB_Nr_temp]

      U     DBX [#pointer_1]
      =     #Bitwert  //als Output Bool

Wenn du das in einer Schleife abfragen willst, mußt du mit Bit-Nr 0 den Pointer erstellen, also

L P#0.0
L #Adr
SPD 3
+D
T #pointer_1

und dann in der Schleife je Bit pointer_1 um 1 erhöhen.

Also einfach in der Schleife

L #pointer_1
L 1
+D
T Pointer_1

und dann die indirekte Abfrage wie oben.

Der Pointer enthält im Prinzip immer die direkte Adresse des Bits.
Will man auf Word oder Dword zugreifen, muß man im Pointer immer die Adresse für Bit 0 stehen haben. Siemens nennt das die Byte- bzw. Wortgrenze.

S7_Programmer · 22 Juni 2012

Hallo,

versuchs mal hiermit:

Code:

      NOP   0                           //Im DB10 ab dbx2.0 suchen

      L     P#DBX 2.0
      LAR1  
      AUF   DB    10

      L     8                           //Abfrage 8 Bits 
Loop: T     #Schleife
      SET   
      U      [AR1,P#0.0]                //Abfrage Bit auf TRUE
      SPB   Gef

      L     P#0.1                       //Adressregister + 1Bit increment
      +AR1  

      L     #Schleife
      LOOP  Loop

      SPA   NGef

//Gefunden
Gef:  L     8
      L     #Schleife
      -I    
      T     #BitNr                      //Bit 0 wird mitgezählt
      BEA   

//Nicht gefunden
NGef: NOP   0
      BEA

Gruß
S7_Programmer

martin1988 · 22 Juni 2012

Was macht ihr das alle so kompliziert?

@Omit78
Das geht einfach mit ein paar zeilen.

Code:

// Schleife erstellen
L #Schleife //Schleife als DWORD im Stat/Merkerbereich ablegen
L 31 //Maximalwert da du nur 2 INT im DB hast = 0-31Bits
==D
SPBN N1S1 // Wenn kleiner als 31 Zähler erhöhen
L 0 // ansonsten Zähler zurücksetzen
SPA N1S2
TAK // den Wert der Schleife wieder aus AKKU2 in AKKU1 holen
L 1 // Schrittweite laden
+D // auf die Schleife addieren
N1S2: T #Schleife // und den Zähler wegschreiben


// Zeiger erstellen
L #Schleife // Schleifenzähler laden
L P#0.1 // Konstate für BIT-Zeiger laden
*D // In BIT-Zeiger wandeln
T #Zeiger // und abspeichern (als TEMP-Variable anlegen reicht hier aus!)
AUF DB[schlagmichtot] // Datenbaustein in dem du abfragen willst öffnen
U P#[#Zeiger] // Und das Bitchen abfragen was du willst
= [hier Aktion einfügen] // Hier kannst du dann das Bit wegschreiben wohin auch immer du willst!

Hoffe das ist soweit verständlich!

Ralle · 22 Juni 2012

martin1988 schrieb:

Was macht ihr das alle so kompliziert?
Braucht doch alles kein Arsch!

@Omit78
Das geht einfach mit ein paar zeilen.

Code:

// Schleife erstellen
L #Schleife //Schleife als DWORD im Stat/Merkerbereich ablegen
L 31 //Maximalwert da du nur 2 INT im DB hast = 0-31Bits
==D
SPBN N1S1 // Wenn kleiner als 31 Zähler erhöhen
L 0 // ansonsten Zähler zurücksetzen
SPA N1S2
TAK // den Wert der Schleife wieder aus AKKU2 in AKKU1 holen
L 1 // Schrittweite laden
+D // auf die Schleife addieren
N1S2: T #Schleife // und den Zähler wegschreiben


// Zeiger erstellen
L #Schleife // Schleifenzähler laden
L P#0.0 // Konstate für BIT-Zeiger laden
*D // In BIT-Zeiger wandeln
T #Zeiger // und abspeichern (als TEMP-Variable anlegen reicht hier aus!)
AUF DB[schlagmichtot] // Datenbaustein in dem du abfragen willst öffnen
U P#[#Zeiger] // Und das Bitchen abfragen was du willst
= [hier Aktion einfügen] // Hier kannst du dann das Bit wegschreiben wohin auch immer du willst!

Hoffe das ist soweit verständlich!

Was genau braucht kein A...?
Ich kann in deinem Code keine höherfliegende Genialität erkennen.

Oh ich sehe, den Befehl U P#[#Zeiger] kenne ich gar nicht.
Ups..., mein Step7 kennt den auch nicht, womit programmierst du, Geniestreich V10.0?

martin1988 · 22 Juni 2012

Ralle schrieb:
Was genau braucht kein A...?
Ich kann in deinem Code keine höherfliegende Genialität erkennen.

Oh ich sehe, den Befehl U P#[#Zeiger] kenne ich gar nicht.
Ups..., mein Step7 kennt den auch nicht, womit programmierst du, Geniestreich V10.0?

Ich mein damit das ganze Adressregistergeschubse und SLD und was weiß ich nicht alles ... Find das einfach nur unnötig kompliziert.

Und ja stimmt, die vorletzte Zeiler war fehlerhaft.

Code:

U DBX[#Zeiger] // Und das Bitchen abfragen was du willst 
= [hier Aktion einfügen] // Hier kannst du dann das Bit wegschreiben wohin auch immer du willst!

So sollte das ohne Probleme klappen.

Thomas_v2.1 · 22 Juni 2012

Dafür dass in deinem Code so viele Fehler waren/sind (P#0.0 hast du ja nochmal schnell korrigiert), lehnst du dich aber ganz schön weit aus dem Fenster.

M-Ott · 22 Juni 2012

@Ralle
Da hat Martin aber Recht. Es gibt keine Notwendigkeit, Bit und Byte in separate Schleifen zu legen. Einfach bis 31 hochzählen reicht.

@Martin
Mit unnötigem Code bist Du aber auch nicht sparsam:

Code:

L #Schleife // Schleifenzähler laden
L P#0.1 // Konstate für BIT-Zeiger laden
*D // In BIT-Zeiger wandeln

martin1988 · 22 Juni 2012

Tut mir leid wenn ich da ein wenig forsch war und auch gerne zwischen durch bin aber ich reagier auf dieses ganze, in meinen augen, any-pointer-zusammen-gebastel-für-jeden-scheiss den ich hier zwischendurch lese allergisch weil ich halt auch so ein Programm hier zu pflegen habe wo sich der Programmierer es meinte sich "einfach" machen zu wollen und alles über pointer über 185123 stellen durchs programmkopiert nur damit nach 30min suche irgendwo ein "=a0.0" steht ...

Bitte lasst das unter jugendlichem leichtsinn durchgehen.

Und nen 2. Fehler hab ich noch gefunden, so sollte es nun komplett richtig sein und funktionieren:

Code:

// Schleife erstellen 
L #Schleife //Schleife als DWORD im Stat/Merkerbereich ablegen
L 31 //Maximalwert da du nur 2 INT im DB hast = 0-31Bits 
==D 
SPBN N1S1 // Wenn kleiner als 31 Zähler erhöhen 
L 0 // ansonsten Zähler zurücksetzen 
SPA N1S2 
N1S1: TAK // den Wert der Schleife wieder aus AKKU2 in AKKU1 holen 
L 1 // Schrittweite laden 
+D // auf die Schleife addieren 
N1S2: T #Schleife // und den Zähler wegschreiben   

// Zeiger erstellen 
L #Schleife // Schleifenzähler laden 
L P#0.1 // Konstate für BIT-Zeiger laden 
*D // In BIT-Zeiger wandeln 
T #Zeiger // und abspeichern (als TEMP-Variable anlegen reicht hier aus!) 
AUF DB[schlagmichtot] // Datenbaustein in dem du abfragen willst öffnen 
U DBX[#Zeiger] // Und das Bitchen abfragen was du willst 
= [hier Aktion einfügen] // Hier kannst du dann das Bit wegschreiben wohin auch immer du willst!

Wenn ich sonst noch fehler übersehen habe könnt ihr mich gerne korrigieren, ist ja niemand unfehlbar.

@M-Ott
Was meinst du an der stelle mit unnötigem code?
Bräuchte ich die Zeilen nicht?

M-Ott · 22 Juni 2012

P#0.1 entspricht L#1 Du multiplizierst also Deinen Wert mit 1.

Ralle · 22 Juni 2012

M-Ott schrieb:
@Ralle
Da hat Martin aber Recht. Es gibt keine Notwendigkeit, Bit und Byte in separate Schleifen zu legen. Einfach bis 31 hochzählen reicht.

@Martin
Mit unnötigem Code bist Du aber auch nicht sparsam:

Code:

L #Schleife // Schleifenzähler laden L P#0.1 // Konstate für BIT-Zeiger laden *D // In BIT-Zeiger wandeln

Ich weiß, das das nicht nötig ist, aber erstens war das nur ein Codebeispiel, das ursprünglich einer einfachen Bitabfrage diente und zweitens ist das so u.U. leichter zu verstehen.

@martin

kein Problem

martin1988 · 22 Juni 2012

M-Ott schrieb:
P#0.1 entspricht L#1 Du multiplizierst also Deinen Wert mit 1.

Ah okay, das war mir so nicht bekannt, danke!
Aber dann erfüllt es wenigstens noch dem Zweck der übersichtlichkeit für Leute die damit nicht so oft arbeiten ^^"

Pointer auf Bits im Datenbaustein

Omit78

Level-1

M-Ott

Level-3

Ralle

Super-Moderator , User des Jahres 2006-2007

S7_Programmer

Level-1

martin1988

Level-1

Ralle

Super-Moderator , User des Jahres 2006-2007

martin1988

Level-1

Thomas_v2.1

Level-1

M-Ott

Level-3

martin1988

Level-1

M-Ott

Level-3

Ralle

Super-Moderator , User des Jahres 2006-2007

martin1988

Level-1

Similar threads

Wir schützen deine Privatsphäre