eingangsbyte variable in pointer aufrufen bzw verarbeiten

Dementis

Level-1
Beiträge
37
Reaktionspunkte
0
Zuviel Werbung?
-> Hier kostenlos registrieren
Hallo zusammen,

so wie der titel sagt will ich mittels einer eingangsvariable "in" in format byte einen pointer generieren und die einzelnen bits von eingangsbyte verarbeiten.

Ich hab bereits einen Baustein geschrieben jedoch nicht als multiinstanz sondern einmal und ich will jetzt die funktion die der Baustein mach als multiinstan machen.

Hier mal der inhalt des normalen Bausteins:


L 8
next: T #zaehler

// Schleife

//berechnen des eingangbits
L #zaehler
L 1
-I
LAR1


U E [AR1,P#0.0]
UN E [AR1,P#1.0]
= M [AR1,P#1.0]
R M [AR1,P#3.0]
SPB ende


UN E [AR1,P#0.0]
U E [AR1,P#1.0]
= M [AR1,P#2.0]
R M [AR1,P#3.0]
SPB ende


UN M [AR1,P#1.0]
UN M [AR1,P#2.0]
= M [AR1,P#3.0]
ende: NOP 0

// Ende Schleife

L #zaehler
LOOP next

NOP 0



und diese Funktion will ich nun multiinstanz machen.

evtl kann mir da jemand helfen :)

eingangvariblen will ich haben

2 variablen mit type byte die halt die eingangsaufruf ersetzten sollen

ausgangsvariablen:

3x out mit type byte anstat der merker die ich hier nehme
und 1 von typ bool


danke schonmal in voraus
 
Hallo,
ich habe dein Vorhaben nciht verstanden.
Beschreib doch noch mal die Schnittstelle des Bausteins (die IN's und die OUT's) und das, was du damit machen willst ...

Gruß
LL
 
Zuletzt bearbeitet:
Zuviel Werbung?
-> Hier kostenlos registrieren
Ok wie man oben sieht.

frage ich durch die schleife die eingangsbyte 0 und 1 ab in den beispiel

ich will anstat

U E [AR1,P#0.0]
UN E [AR1,P#1.0]

einen eingansvariable einsetzten

für "U E [AR1,P#0.0]" die IN variable "in_zu" datentype byte
für "UN E [AR1,P#1.0]" die IN variable "in_auf" datentype byte

out variblen hab ich:
out_zu (type: byte)
out_auf (type: byte)
out_stoer (type:byte)

diese out variablen will ich durch folgen teil meines bausteines ersetzten:

UN M [AR1,P#1.0] ersetzten durch "out_zu"
UN M [AR1,P#2.0] ersetzten durch "out_auf"
= M [AR1,P#3.0] ersetzten durch "out_stoer"

hoffe jetzt ist es besser erklärt
 
... ich frage jetzt mal nicht, warum deine IN- und die OUT-Variablen Bytes sind ... jedenfalls, wenn du auf diese Variablen einen Pointer bilden willst, so geht das so :
Code:
L p##in_zu   // Pointer auf Variable laden
LAR1           // Pointer ins AR1-Register
... den Rest kennst du ja schon ...
Das geht mit den OUT's entsprechend ...

Gruß
LL
 
joa so wie du es geschrieben hast hab ich es auch probiert nur funktioniert das nicht so wie ich mir das vorstelle

Evtl hab ich die funktion des bausteins nicht richtig erklärt

nun ja er macht folgendes:

ich frage jeweils das gleiche bit von 2 byts ab (z.b e0.2 und e1.2) und frag ihren zustand ab, wenn dann e0.2 "1" ist und e1.2 "0" will merker setzten wie bei meinen aktuellen baustein m1.2 (der soll mir sagen das der zustand ZU ist).
Umgekehrt e1.2 "1" und e0.2 "0" soll dann merker 2.2 gesetzt werden für AUF
sollten beide "0" oder "1" soll dann m3.2 gesetzt werden für Störung.

Und das mach ich bei jeden bit von *.0-.7


Type byte weil ich je nur 8 eingänge also größe von bytes habe.
Wenn es so nicht möglich ist wie ich es mir vorstelle muss ich es halt so lassen.

hoffe das jetzt bischen klarer wird was ich vorhabe


Ich schätze das ich einen "U" oder "UN" abruf von ein pointer bit nicht machen kann...
 
und wie soll das gehen wenn ich den pointer von einer eingangsvariable erstelle??

L p##in_zu
LAR1

U E [AR1,P#0.0]
UN E [AR1,P#1.0]

wenn ich das so mache fragt er ja die eingangsbit von eingängen direkt ab oder? und nicht die von mir definierten eingansbyte
 
Code:
L p##in_zu 
LAR1 
 
U [COLOR=red]in_zu[/COLOR][AR1,P#0.0]   //oder wie auch immer deine [COLOR=red]IN [/COLOR]Variable auch heißt
UN [COLOR=red]i[/COLOR][COLOR=red]n_zu[/COLOR][AR1,P#1.0] //die IN deines Bausteines

in einem FB sollte man nie merker, oder ein-ausgänge verwenden.
wegen der mehrfachen Verwendbarkeit eines FB.

für die multiinstanzfähigkeit musst du auch noch den offset des AR2 dazuzählen!!!!!
 
Zuletzt bearbeitet:
Zuviel Werbung?
-> Hier kostenlos registrieren
Eben genau deswegen will ich ja wissen wie man eine eingangsvariable das einzelne bit abfragt.

hm hab das so gemacht wie du geschrieben hast, aber er nimmt mir das net

L P##zustand_zu
LAR1

u zustand_zu [AR1,P#0.0] wird rot

zustand_zu ist meine eingansvariable auch wenn ich den typ ändere bleibt es rot
 
sorry ich bin heute schon ein wenig verrückt im kopf
Code:
L p##in_zu 
LAR1 
 
U DIX[AR1,P#0.0] 
UN DIX[AR1,P#1.0]
so sollte es funken,habe es aber nicht getestet.Du hast einen FB,oder??
 
AHHH jo so gehts!

jetzt hab ich noch das problem wie ich das bei den merkern und out mache :)

= M [AR1,P#1.0]
R M [AR1,P#3.0]

will ich auch ersetzten durch eine in_out variable, hm oder ist eine nur out besser...

Ja ich verwende einen FB
 
Also wenn ich das Richtig verstehe will du in deinem Multiinstanz-FB basierend auf 2 Bytes, welche die Bitposition deiner gesuchten Bits innerhalb von 2 Eingangsbytes repräsentieren.

Warum plagst du dich da überhaupt mit Pointern? Wie wäre es mit einem neuem Denkanstoß basierend auf Bitmaskierung.

Als erstes würde ich die zwei Eingangsbyte mittels In-Paramter an den FB übergeben. Wie oben schon erwähnt sollte man in Multiinstanzen nicht direkt mit den Eingangsytes arbeiten

Wie wäre es mit

Code:
IN:
EB1 Byte
EB2 Byte
Bitpos1 Byte
Bitpos2 Byte

//Status Bit x aus Eingangsbyte 1 lesen
      L     #Bitpos1         //Bitposition zwischen 0 und 7
      L     1
      SLW                     //Zahl 1 um Bitposition nach links verschieben Ergibt Zahlen 1,2,4,8,16,32,64,128
      L     EB1
      UW                      //UND-WORT mit der entsprechenden Zahl mit dem Eingangsbyte
      L     0  
      >I                      //Wenn die Enstehende Zahl größer null dann Bit = 1
      =     #Status_Bitaus_EB1

so müsste da auch ohne Pointer klappen. Hab ich jetzt nur mal schnell getippt und nicht getestet. Braucht zwar ein paar Befehle mehr ist aber sehr einfach. Soll wie gesagt nur ein Denkanstoß sein

Aber Gerhard war eh schon schneller :ROFLMAO:ROFLMAO:ROFLMAO:
 
Zuletzt bearbeitet:
danke jungs für die hilfe,aber irgendwie passt das mit den bitmuster vergleich nicht so ganz ..

also ich will den fb bei einer überwachung von schiebern verweden (kugelhähn ,...), d.h. bei mir ist das eb0 die posi für schieber offen sensoren und eb1 für zu. ich will halt überprüfen welcher schieber offen bzw zu ist.

schieber 1 : e0.0 zu; e1.0 offen
schieber 2: e0.1 zu; e1.1 offen
.
.
.

wenn weder zu noch offen ist soll halt durch ein merker byte bei mir mb3 (in der normalen version) das dazugehörige bit gesetzt werden, und ich will halt auch durch die zustandsüberprüfung wissen ob die schieber offen oder geschlossen sind
 
Zuviel Werbung?
-> Hier kostenlos registrieren
wenn weder zu noch offen ist soll halt durch ein merker byte bei mir mb3 (in der normalen version) das dazugehörige bit gesetzt werden

Ich weiß ich bin lästig und da hast auch schon gesagt des es nicht ganz passt. Aber ich steh halt auf Bitspiele :rolleyes:

Die Funktion geht mit 5 Zeilen

Code:
L EB0
L EB1
OW
INVI
T MB3 //Schon steht in MB3 welches Ventil weder offen noch zu ist
 
Zuletzt bearbeitet:
Oh mein gott!!!
unglaublich! tjo da sieht man wieder manchmal denkt man zu komplziert :)

danke das mit den mb3 funktioniert! danke

aber die status anzeige für den Zustand des schiebers.

hier mal aktueler baustein:


achja mit u dix ... hab ich auch probiert geht auch net




L P##zustand_zu
LAR1



L 8
next: T #zaehler

// Schleife

L #zaehler
L 1
-I
LAR1


//Überprüfen ob der Sperrhahn offen ist

L P##zustand_zu
LAR1

U [AR1,P#0.0]
UN [AR1,P#1.0]
T #merker_auf (wenn die bedingung erfüllt ist will das dazugehörige bit von einen merkerbyte ansprechen)
SPB ende



//Überprüfung ob Sperrhahn zu ist
UN [AR1,P#0.0] //Selbe vorgehensweise wie bei Offen
U [AR1,P#1.0]
T #merker_zu (hier das selbe wie oben)
SPB ende



ende: NOP 0



L #zustand_zu
L #zustand_auf
OW
INVI
T #Stoer_merker

// Ende Schleife

L #zaehler
LOOP next



NOP 0
 
Zuletzt bearbeitet:
Ganz vestehe ich deinen Code nicht

Code:
        L     P##zustand_zu
        LAR1  //*1 Jetzt hast du die Adresse von zustand_zu im AR1

        L     8
next: T     #zaehler

// Schleife

      L     #zaehler //Hier schreibst du den Zählerstand in AR1
      L     1
      -I    
      LAR1  

//Überprüfen ob der Sperrhahn offen ist

      L     P##zustand_zu //Hier überschreibst du den Inhalt von AR1 wieder mit der Adresse von zustand zu
      LAR1  

      U      [AR1,P#0.0]     //Bitoperation
      UN     [AR1,P#1.0]   //Bitoperation
      T     #merker_auf    //Wortoperation (kann nicht hinhauen oder)
      SPB   ende

usw....

Das Problem ist hier denke ich, das du versucht über einen Zahlenwert von 0..7 deinen Pointer auf das jeweilige Bit zu richten. Über eine Variable kann man aber so weit ich weiß nur die Byteadresse im Pointer vorgeben.
Man kann zwar mit +AR1 P#0.1 den Bitoffset des Pointers erhöhen. Aber diesen Bitoffset über eine Variable zu beinflussen geht glaube ich nicht.
 
Ich bin aber nicht so gut mit Pointern also habe noch einen einfachen Vorschlag für dich

Code:
IN: zustand_auf  Type:  Byte
IN: zustand_zu  Type:   Byte

OUT: merker_auf Type:  Byte
        merker_zu   Type: Byte
        merker stoe Type: Byte

Temp: zust_auf_temp Type:  Byte
Temp: zust_zu_temp Type:  Byte
Temp: merk_auf_temp Type:  Byte
Temp: merk_zu_temp Type:  Byte

L zustand_auf
T zust_auf_temp
L zustand_zu
zust_zu_temp

U L0.0
UN L1.0
= L3.0

U L0.1
UN L1.1
= L3.1

usw...


L merk_auf_temp
T merker_auf
L merk_zu_temp
T merker_zu

Wenn du Variablen im Temp-Bereich hast kannst du auch ohne Pointer direkt mit ihnen arbeiten. Ich weiß die Lösung ist nicht so schon wie mit Pointern und Schleifen aber ich weiß nicht wie man das anstellen sollte.
 
Hallo,

probiers mal so:

Code:
FUNCTION_BLOCK FB 1
TITLE =
AUTHOR : Micha
VERSION : 0.1
 
VAR_INPUT
  ZUSTAND_AUF : BYTE ; 
  ZUSTAND_ZU : BYTE ; 
END_VAR
VAR_OUTPUT
  QOFFEN : BYTE ; 
  QZU : BYTE ; 
  QSTO : BYTE ; 
END_VAR
VAR_TEMP
  tiLC : INT ; 
END_VAR
BEGIN
NETWORK
TITLE =
      LAR1  AR2; 
      L     P##ZUSTAND_AUF; 
      +AR1  ; 
      L     8; 
L1:   U     DIX [AR1,P#0.0]; 
      UN    DIX [AR1,P#1.0]; 
      =     DIX [AR1,P#2.0]; //RM Auf
      UN    DIX [AR1,P#0.0]; 
      U     DIX [AR1,P#1.0]; 
      =     DIX [AR1,P#3.0]; //RM Zu
      UN    DIX [AR1,P#0.0]; 
      UN    DIX [AR1,P#1.0]; 
      =     DIX [AR1,P#4.0]; //Störung
      +AR1  P#0.1; 
      LOOP  L1; 
END_FUNCTION_BLOCK

Gruß Micha

Ergänzung: Die Lokalvariable kann gelöscht werden...
 
Zurück
Oben