PAD PAW PED PEW DB Variabel machen

C

chickmc

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

ich habe mir momentan die aufgabe gemacht folgenden Code Multiinstanzfähig zu machen.


Code: 
      L     0
      T     DB101.DBD    0
      T     DB101.DBD    4
      SET   
      UN     #reset
      S     DB101.DBX    4.0


      L     DB101.DBD    0
      T     PAD  272
      L     DB101.DBW    4
      T     PAW  276


      L     PED  272
      T     DB101.DBD    8
      L     PED  276
      T     DB101.DBD   12


Dabei soll sowol der DB, die Bytes des DB und die Adresse der Perepherie Variabel sein, je nach Übergabeparameter.

Ich habe schonmal angefangen aber komme nicht weiter.

Bisheriges "Ergebnis"

Code: 
      TAR1  
      T     #AdrReg1
      TAR2  
      T     #AdrReg2


      L     #StDB
      T     #TDbNr
      LAR1  
      AUF   DB [#TDbNr]



      L     0
      T     D [AR1,P#0.0]
      T     D [AR1,P#4.0]
      SET   
      UN    #Reset
      =      [AR1,P#4.0]


      L     #TDbNr
      LAR1  

       CALL  "DPWR_DAT"
       LADDR  :=???
       RECORD :=#StByte
       RET_VAL:=#tRetVal
...
 
Zuletzt bearbeitet:
Zuviel Werbung?
-> Hier kostenlos registrieren
Das da die 272 dran stehen muss ist im prinzip richtig aber ich möchte das ganze ja alz Multiinstanz haben, also der wert soll aus den übergabeparametern geholt werden.

Der aufruf soll dann so aussehen.

Code: 
    U     M      0.0
      =     L     22.0
      BLD   103
      CALL  "Ansteuerung Counter" , DB100
       StByte  :=272
       StDB    :=101
       StDBByte:=0
       Reset   :=L22.0
       Q       :=#Zaehlwert
      NOP   0

bzw. in KOP
Aufruf.JPG

Die StByte 272 Steht für den Anfang des Ein- und Ausgangsbereich des Counters in der Hardwarekonfig.
Die StDB 101 ist die DB Nummer in der bzw. von der die Daten vom Counter gelesen und geschrieben werden.
Die StDBByte 0 ist der Bereich wo die Daten des Counters im DB liegen sollen.

Das heißt das alles abhängig von den Übergabeparametern.
Die Lokalvariabeln nur Symbolisch.

Code: 
      L     0
      T     DB101.DBD    0    //#StDB.#StDBByte
      T     DB101.DBD    4    //#StDB.#StDBByte+4
      SET   
      U     M      0.0
      S     DB101.DBX    4.0 //StDB.StDBByte+4



      L     DB101.DBD    0     //#StDB.#StDBByte
      T     PAD  272            //#StByte
      L     DB101.DBW    4    //#StDB.#StDBByte+4
      T     PAW  276            //#StByte+4


      L     PED  272             //#StByte
      T     DB101.DBD    8    //#StDB.#StDBByte+8
      L     PED  276            //#StByte+4 Byte
      T     DB101.DBD   12    //#StDB.#StDBByte+12

Ich hoffe das sind bessere Informationen für euch.
 
Zuletzt bearbeitet:
Bis wie weit ist mein Code überhaupt brauchbar.


Bisher habe ich
Code: 
//--------------------
TAR1                  //Adressregister 1 und 2 sichern damit diese am Bausteinende wieder hergestellt werden können.
T     #AdrReg1   
TAR2         
T     #AdrReg2
//--------------------

L P#0.0               //Adressversatz 0.0
L #StByte             //Ziel einlesen als INT oder Word
SLD 3                 //Daraus einen Zeiger (Pointer) machen
+D 
T #TStByte            //Zeiger im temp/stat speichern


//--------------------
L     #StDB           //Die übergebene DB Nummer Laden (101)       
T     #TDbNr          //Transverieren in Temporäre variable       
LAR1
AUF   DB [#TDbNr]     //DB(101) öffnen
L     0               //0 Laden und anschließend      
T     D [AR1,P#0.0]   //Schreibe die 0 in den DB 4Byte lang wie bei //T     DB101.DBD    0
T     D [AR1,P#4.0]   //Schreibe die 0 in den DB 4Byte lang wie bei //T     DB101.DBD    4
SET          
UN    #Reset       
=      [AR1,P#4.0]    //Setze das Bit des DB's wenn Bedingung erfüllt wie bei//S     DB101.DBX    4.0
//--------------------

//Jetzt möchte ich folgendes

//L     DB101.DBD    0 
//T     PAD  272 
//L     DB101.DBW    4 
//T     PAW  276

//Lösungsvorschlag

L D [AR1,P#0.0]
T PED #TStByte
L D [AR1,P#4.0] 
T PED #TStByte    //Das selbe nur +4 Byte?

...
 
Zuletzt bearbeitet:
Zuviel Werbung?
-> Hier kostenlos registrieren
Code: 
//--------------------
TAR1                  //Adressregister 1 und 2 sichern damit diese am Bausteinende wieder hergestellt werden können.
T     #AdrReg1   
TAR2         
T     #AdrReg2
//--------------------

L P#0.0               //Adressversatz 0.0
L #StByte             //Ziel einlesen als INT oder Word
SLD 3                 //Daraus einen Zeiger (Pointer) machen
+D 
T #TStByte            //Zeiger im temp/stat speichern


//--------------------
L     #StDB           //Die übergebene DB Nummer Laden (101)       
T     #TDbNr          //Transverieren in Temporäre variable       
 LAR1                                                                       [COLOR=#0000ff]                                                        // warum steht hier kein kommentar? du lädst hier das, was im akku1 steht ins ar1. Also die DBNr interpretiert als pointer..   [/COLOR]                          
AUF   DB [#TDbNr]     //DB(101) öffnen
L     0               //0 Laden und anschließend      
 T     D [AR1,P#0.0]   //Schreibe die 0 in den DB 4Byte lang wie bei //T     DB101.DBD    0                  //[COLOR=#0000ff]Hier adresseierst du imo db101.dbd404 wenn ich das richtig gerechnet hast s.o. [/COLOR]   
T     D [AR1,P#4.0]   //Schreibe die 0 in den DB 4Byte lang wie bei //T     DB101.DBD    4
SET          
UN    #Reset       
 =      [AR1,P#4.0]    //Setze das Bit des DB's wenn Bedingung erfüllt wie bei//S     DB101.DBX    4.0   /[COLOR=#0000ff]/ DB101.dbx408.0  
[/COLOR]//--------------------

//Jetzt möchte ich folgendes

//L     DB101.DBD    0 
//T     PAD  272 
//L     DB101.DBW    4 
//T     PAW  276

//Lösungsvorschlag

L D [AR1,P#0.0]
 T PED #TStByte                                                                     [COLOR=#0000ff]        // PAD kannst du auch über PAD [ar1,p#...] adressieren... wäre mein vorschlag
[/COLOR]L D [AR1,P#4.0] 
T PED #TStByte    //Das selbe nur +4 Byte?

 ...
 
EyeQ schrieb:
Code: 
//--------------------
TAR1                  //Adressregister 1 und 2 sichern damit diese am Bausteinende wieder hergestellt werden können.
T     #AdrReg1   
TAR2         
T     #AdrReg2
//--------------------

L P#0.0               //Adressversatz 0.0
L #StByte             //Ziel einlesen als INT oder Word
SLD 3                 //Daraus einen Zeiger (Pointer) machen
+D 
T #TStByte            //Zeiger im temp/stat speichern


//--------------------
L     #StDB           //Die übergebene DB Nummer Laden (101)       
T     #TDbNr          //Transverieren in Temporäre variable       
LAR1                 [COLOR=#0000ff] //akku1 ins AR1. DBNr interpretiert als pointer[/COLOR]                
AUF   DB [#TDbNr]     //DB(101) öffnen
L     0               //0 Laden und anschließend      
T     D [AR1,P#0.0]   //Schreibe die 0 in den DB 4Byte lang wie bei //T     DB101.DBD    0      //[COLOR=#0000ff]Hier adresseierst du imo db101.dbd404 wenn ich das richtig gerechnet hast s.o.[/COLOR] [COLOR=#ff0000]Ich möchte aber wie im kommentar[/COLOR] [COLOR=#0000ff]db101.dbd0[/COLOR]
T     D [AR1,P#4.0]   //Schreibe die 0 in den DB 4Byte lang wie bei //T     DB101.DBD    4       //[COLOR=#ff0000]danach[/COLOR] [COLOR=#0000ff]db101.dbd4[/COLOR] [COLOR=#ff0000]mit null beschreiben. Woher kommen die 400?[/COLOR]
SET          
UN    #Reset       
 =      [AR1,P#4.0]    //Setze das Bit des DB's wenn Bedingung erfüllt wie bei//S     DB101.DBX    4.0   /[COLOR=#0000ff]/ DB101.dbx408.0  [/COLOR][COLOR=#ff0000]// Hier soll das Bit 4.0 des DB gesetzt werden.[/COLOR][COLOR=#0000ff]
[/COLOR]//--------------------

//Jetzt möchte ich folgendes

//L     DB101.DBD    0 
//T     PAD  272 
//L     DB101.DBW    4 
//T     PAW  276

//Lösungsvorschlag

L D [AR1,P#0.0]
T PED #TStByte                                                        [COLOR=#0000ff]// PAD kannst du auch über PAD [ar1,p#...] adressieren... wäre mein vorschlag
[/COLOR]L D [AR1,P#4.0] 
T PED #TStByte    //Das selbe nur +4 Byte?

 ...
Zum Vergrößern anklicken....

Die Größe des DB ist nur 16 Byte
Wie ist das mit dem [AR1,P#4.0] Wird da bei jedem mal die 4 Byte dazugezählt oder nur 4 Byte zum AR1(=DB101.DBX0.0)
 
Sorry da habe ich mich vertan.



Also du lädst 101 in den Ákku. Das ergibt in Binär: 1100101. Dann lädst du es in das ar1. Da beim Datentyp Pointer die ersten 3 bits des low-bytes die Bitadresse ersgeben, müsste es das gleiche sein als schriebst du:

Lar1 P#12.5

101 -> Bit 5 (1+4)
1100 -> 12 (4+8)

OK. Ich glaube sowas ist, was du suchst. Ich bin zwar müde, aber ich glaube das müsste laufen. Kann es grad leider nicht testen:

Code: 
Var_Def:

IN PAD_Adr     als pointer
IN Data_Adr    als any

TEMP Data_Block     als int (word?)
TEMP PAdresse    als dword

/Var_Def



//--------------------
lar1     p##Data_Adr            // ar1 auf Startadresse des anys in den Lokaldaten (inkl. Angabe des Speicherbereichs)

l     w[ar1,p#4.0]            // DBnr aus dem any kopieren (ich meine Byte 4 ist richtig, F1 zum Datentyp ANY wirds dir helfen falls nicht :)
t     #Data_Block            

l     d[ar1,p#6.0]            // Pointer auf Startadresse im DB aus any laden
t     #PAdresse            

//--------------------
auf     [#Data_Block]            // DB aufschlagen

l     0                
t    D[ar1,p#0.0]            // in den DB laden
t    D[ar1,p#4.0]            // Startadresse + 4 byte offset

set     //? wofür ist das?
un     #reset
=    [ar1,p#4.0]            // ich glaube bit zugriff muss so adressiert werden
//--------------------

lar2    #PAD_Adr            // ar2 auf adresse aus in parameter (hier steht nur 272.0 drin!)

l    D[ar1,p#0.0]            // DBD auslesen
t    PAD[ar1,p#0.0]            // auf dein PAD schreiben
l    D[ar1,p#4.0]            // DBD auslesen
t    PAD[ar1,p#4.0]            // auf dein 2. PAD schreiben Offset 4 byte

Am Aufruf übergibst du dann an:
Data_Adr: P#DB101.DBX0.0 Byte 16 // die Länge muss mit übergeben werden, kann aber auch kleiner sein als der Bereich auf den du zugreifen willst, da du die Länge nicht verwendest.
PAD_Adr: P#272.0 // hier als Pointer die erste Adresse wo du hinschreiben willst, ohne Übergabe des Speicherbereichs.

Das, was hinter [ar1, steht ist jeweils ein temporäres offset auf die geladene Adresse für diese Verwendung.


OT: Der Editor des neuen Forums funktioniert bei mir so ka**e. Ist das bei euch auch so? Habe auf meinem Android auch Probleme damit.
 
Zuletzt bearbeitet:
Zuviel Werbung?
-> Hier kostenlos registrieren
lar2 #PAD_Adr
Funktioniert nicht


wenn ich den Letzten Teil noch so umschreibe dann müsste es so aussehe.


Letzter Teil Original:
Code: 
      L     PED  272
      T     DB101.DBD    8
      L     PED  276
      T     DB101.DBD   12

Multiinstanzfähig:
Code: 
Var_Def:

IN PAD_Adr     als pointer
IN Data_Adr    als any

TEMP Data_Block     als int (word?)
TEMP PAdresse    als dword

/Var_Def



//--------------------
lar1     p##Data_Adr            // ar1 auf Startadresse des anys in den Lokaldaten (inkl. Angabe des Speicherbereichs)

l     w[ar1,p#4.0]            // DBnr aus dem any kopieren (ich meine Byte 4 ist richtig, F1 zum Datentyp ANY wirds dir helfen falls nicht :)
t     #Data_Block            

l     d[ar1,p#6.0]            // Pointer auf Startadresse im DB aus any laden
t     #PAdresse            

//--------------------
auf     [#Data_Block]            // DB aufschlagen

l     0                
t    D[ar1,p#0.0]            // in den DB laden
t    D[ar1,p#4.0]            // Startadresse + 4 byte offset

// Wird mit der variante mit #reset nicht mehr benötigt [COLOR=#d3d3d3]set[/COLOR]     //? wofür ist das?
un     #reset
=    [ar1,p#4.0]            // ich glaube bit zugriff muss so adressiert werden
//--------------------

[COLOR=#ff0000]lar2    #PAD_Adr            // ar2 auf adresse aus in parameter (hier steht nur 272.0 drin!)[/COLOR]

l    D[ar1,p#0.0]            // DBD auslesen
t    PAD[[COLOR=#ff0000]ar2[/COLOR],p#0.0]            // auf dein PAD schreiben
l    D[ar1,p#4.0]            // DBD auslesen
t    PA[COLOR=#ff0000]W[/COLOR][[COLOR=#ff0000]ar2[/COLOR],p#4.0]            // auf dein 2. PA[COLOR=#ff0000]W[/COLOR] schreiben Offset 4 byte

L     PED [[COLOR=#ff0000]AR2[/COLOR],P#8.0]             // PED lesen     Offset 8 byte
T     D [AR1,P#0.0]               // DBD schreiben
L     PED [[COLOR=#ff0000]AR2[/COLOR],P#12.0]            // zweiter teil PED lesen Offset 12 byte
T     D [AR1,P#4.0]               // DBD schreiben

Das W hab ich scheinbar von meinem Original übersehen.
Macht W oder D überhaupt einen unterschied?
 
Mal so nebenbei

Multiinstanz = In einem FB wird ein weiterer aufgerufen. Lokaldaten des aufgerufenen FB liegen im Instanzdatenbaustein des aufrufenden FB.
Da kommen dann die +AR1 Sachen hinzu.

Kann es sein, daß du einfach einen FB ohne absolute Adressen und Zugriffe meinst?


hier mal was NICHT MULTIINSTANZFÄHIGES !

Code: 
L     #iEA_Adresse                //Hardware E/A Adresse
      SLD   3                           //Bitbereich ausblenden
      T     #wEA_Temp                   //temporär speichern

      TAR1  #dTempAR1                   //Adressregister retten
      TAR2  #dTempAR2                   //Adressregister retten


      LAR1  #wEA_Temp                   //Startadrese der Quelle in AR1
      LAR2  P##PI                       //Startadresse des Ziels in AR2

      L     PED [AR1,P#0.0]             //1.PED-Word laden
      T     D [AR2,P#0.0]               //und in PI-Temp schreiben

      L     PED [AR1,P#4.0]             //2. PED-Word laden
      T     D [AR2,P#4.0]               //und in PI-Temp schreiben

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


Code: 
  TAR1  #dTempAR1                   //Adressregister retten
      TAR2  #dTempAR2                   //Adressregister retten

      LAR1  P##PO                       //Startadrese der Quelle in AR1
      LAR2  #wEA_Temp                   //Startadresse des Ziels in AR2

      L     D [AR1,P#0.0]               //PO-Temp 1.DW laden
      T     PAD [AR2,P#0.0]             //und in 1. PAD-word (byte 0/1/2/3) schreiben

      L     D [AR1,P#4.0]               //PO-Temp 2.DW laden
      T     PAD [AR2,P#4.0]             //und in 2. PAD-word (byte 4/5/6/7) schreiben

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

er.jpg



Danach stehen die PEW Daten im Temporären Bereich
Die AusgangsDaten werden temporär zugewiesen und zum Schluß des Bausteins zum PAW getrieben.
 
Zuletzt bearbeitet:

Similar threads

SCL
Step 7 Kommunikation mit Umrichter S7 Classic
Antworten
15
Aufrufe
877
Onkel Dagobert
Onkel Dagobert
P
Step 7 Pointer AWL Programmieren
Antworten
6
Aufrufe
3K
pramkies
P
S
TIA gebündelte und automatisierte Flankenauswertung in einem global DB
2
Antworten
24
Aufrufe
6K
StefanTSM
S
G
TIA Umsetzung code in SCL TIA V16
Antworten
10
Aufrufe
3K
guenni
G
T
Step 7 Step 7: in Array schreiben
Antworten
3
Aufrufe
2K
TinoToni
T
Zurück
Oben