# SCL: FB Aufruf unter SCL mit Variablen DB



## ThorstenK (4 März 2009)

Hallo zusammen, 

nachdem ich nun schon einige Zeit mitlese möchte ich doch mal meine erste Frage hier ins Forum stellen.
Meine Problemstellung:

Ich möchte einen FB unter SCL mit einem variablen DB aufrufen.
Unter AWL mache ich dies wie folgt:

IN_Variablen:
DB : Typ = Block_DB

Programm:
call FB.#DB

Der gleiche Aufruf unter SCL:
VAar_Input
DB : Block_DB ;
END_Var_Input

FB.DB(Parameter);

Wenn ich diese vorhgehensweise unter SCL benutze bekomme ich eine Fehlermeldung.

Was mache ich Falsch???

Gruß Thorsten


----------



## ThorstenK (5 März 2009)

Hat keiner eine Idee?

Schade


----------



## sps-concept (5 März 2009)

*Scl*

Hallo,

so gehts bei mir.


```
FB3.DB3(_DB :=DB100);
```
 
FB3 - aufgerufener FB
DB3 - IDB FB3
DB100 - variabler DB

wenn du nen variablen DB willst brauchste da extra nen IDB? Wie wärs mit nem FC?

André


----------



## sps-concept (5 März 2009)

*Scl*

übrigens wenn der Parameter *DB* heisst gibts bei allen Editoren ne Fehlermeldung weil DB ein Schlüsselwort ist!

André


----------



## vierlagig (5 März 2009)

ich find diese variable sache nich schön - wer erstellt denn die ganzen instanzen und aktualisiert sie bei ner änderung?

schöner hier meiner meinung nach: multiinstanz.

einfach mal drüber nachdenken...


----------



## ThorstenK (5 März 2009)

Danke schon mal für die antworten.



> übrigens wenn der Parameter *DB* heisst gibts bei allen Editoren ne Fehlermeldung weil DB ein Schlüsselwort ist!
> 
> André


 
Die Variable selber heißt nicht DB hier nur als Beispiel.



> ich find diese variable sache nich schön - wer erstellt denn die ganzen instanzen und aktualisiert sie bei ner änderung?
> 
> schöner hier meiner meinung nach: multiinstanz.
> 
> einfach mal drüber nachdenken...


 
Es geht mir nicht darum das ich in ein und demselben Projekt den DB ändern kann.
Grund für meine variable Übergabe der DB-Nummer ist, dass ich meinen FB in mehreren verschiedenen Projekten nutze und somit nicht den Quellcode des FBs ändern möchte sondern dieses einfach bei dem FB Aufruf als Parameter. So können auch andere Mitarbeiter ohne sich mit dem Quellcode auseinandersetzen zu müssen mit dem Baustein arbeiten.

Somit fallen leider auch die Möglichkeiten mit dem FC usw. raus.

Mein Problem wie im Eingangspost beschrieben:

```
IN_Variablen:
Datenbaustein : Typ = Block_DB
 
Programm:
call FB.#Datenbaustein
```
 
unter AWL funktioniert dieses und unter SCL nicht. Obwohl der Aufruf und der die Deklaration identisch sind. (ohne call)
Die Hilfe gibt die selbe vorgehensweise vor.

Ich hoffe es ist ein wenig klarer geworden was ich vorhabe und wo das Problem ist.

Vielen Dank im Vorraus.

Gruß Thorsten


----------



## vierlagig (5 März 2009)

das geht so nicht.

...und deine begründung ... naja ... eher mau


----------



## Larry Laffer (5 März 2009)

vierlagig schrieb:


> das geht so nicht.
> 
> ...und deine begründung ... naja ... eher mau


 
Na - Na ... 
Ich habe das auch mal getestet ... unter AWL geht es - unter SCL anscheinend nicht.

Ich glaube aber nicht, dass wir hier über Sinn und Unsinn einer Maßnehme diskutieren müssen - und m.E. schon gar nicht, warum jemand etwas so oder so machen möchte (außer vielleicht es ist völliger Quatsch).
Wenn Thorsten einen FB einmal mit I-DB100 und beim nächsten Mal mit I-DB200 versorgen möchte, dann ist das doch sein gutes Recht. Hier fehlt anscheinend wirklich etwas im SCL-Code ...

Gruß
LL


----------



## vierlagig (5 März 2009)

Larry Laffer schrieb:


> Na - Na ...
> Ich habe das auch mal getestet ... unter AWL geht es - unter SCL anscheinend nicht.


 
das meinte ich!

und vorerst unsinn weil: er verlangt vom anwender, dass er den IDB von hand erstellt.


----------



## Larry Laffer (5 März 2009)

vierlagig schrieb:


> das meinte ich!
> 
> und vorerst unsinn weil: er verlangt vom anwender, dass er den IDB von hand erstellt.


 
... was allerdings überhaupt kein Problem ist (sehe ich jedenfalls nicht als solches an) ...


----------



## ThorstenK (5 März 2009)

Ich denke über sinn und Unsinn sollten wir hier nicht diskutieren. Und unqualifizierte Antworten sollten einen sachlichen Thread nicht belasten!


vierlagig schrieb:


> das meinte ich!
> 
> und vorerst unsinn weil: er verlangt vom anwender, dass er den IDB von hand erstellt.


Man darf ruhig zugeben wenn man auf eine Frage keine Antwort weiß. 

"Ein hartnäckiger Begleiter der Erkenntnis ist die Unwissenheit über die eigene Unwissenheit." - Stanislaw_ Lem, Also sprach Golem_



Larry Laffer schrieb:


> [...]
> Ich habe das auch mal getestet ... unter AWL geht es - unter SCL anscheinend nicht. [...]
> 
> Gruß
> LL


 
Danke das Du es ausprobiert hast.

Ich denke dann, dass dies so noch keiner hier aus dem Forum genutzt hat.

Danke an alle und einen schönen Tag noch.

Gruß
Thorsten


----------



## vierlagig (5 März 2009)

ThorstenK schrieb:


> Man darf ruhig zugeben wenn man auf eine Frage keine Antwort weiß.


 
ich wußte die antwort, dass es in SCL so nicht geht ... sehe dein problem nicht


----------



## ThorstenK (5 März 2009)

Wenn du weißt das es so nicht geht, warum .... ???
Lassen wir das...

Ich denke ich warte einfach ab, was Siemens dazu sagt.
Bei einer Antwort werde ich die natürlich mitteilen.

Gruß


----------



## youfyouk (4 Februar 2011)

ThorstenK schrieb:


> Unter AWL mache ich dies wie folgt:
> 
> IN_Variablen:
> DB : Typ = Block_DB
> ...



Hallo,

ich bekomme das noch nicht mal mit AWL hin.
In meinem Fall handelt es sich um FC Aufrufe, Ich Werte vier Eingänge aus (BCD) und schreibe das Ergebnis in eine DB als INT (0-15), anhand der Zahl in der  DB soll nun das jeweilige FC(1-15) aufgerufen werden. Mit FUP geht es auch, aber nicht gerade Elegant, so muss 15 Netzwerke schreiben mit Vergleicher und einem CALL.
Kann mir das mit AWL jemand weiterhelfen bitte. Ich versuche auch schon seit zwei Tagen mit SCL, dann bin ich auf diesen Beitrag gestoßen.

MfG
youfyouk


----------



## Larry Laffer (4 Februar 2011)

Hallo,
es gibt auch keine Funktion "irgendwas_to_Block_FC".
In AWL könntest du so vorgehen :
	
	



```
myFC : BLOCK_FC
myIndex : INT
 
L p#myFC
LAR1
L myIndex
T W [AR1,p#0.0]
 
UC myFC
```
... ist aber nicht getestet - so etwas ist nicht unbedingt mein Ding.

Warum willst du etwas so machen ? Du hast doch somit einen Programm-Crash schon fast vorprogrammiert ...

Gruß
Larry


----------



## youfyouk (4 Februar 2011)

Hi,

danke für die schnelle Antwort.
Eigentlich möchte ich nur wissen wie man einzelne FC's elegant aufruft.
Ich stecke noch in der Entwicklung und bin für jeden TIP dankbar.

Folgendes habe ich vor.
Eine Maschine mit Wechselwerkzeugen soll die Werkzeuge Steuern. Auf den Werkzeugen befinden sich unterschiedlich viele Sensoren und pn. Ventile.
Die Werkzeuge codiere ich mit 4Bit (BCD - Identifikation) und Werte die in z.B. FC100 aus und schreibe in DB1 als INT, anhand des Intergerwertes möchte ich dann das entsprechende "Unterprogramm" aufrufen FC 1-15. Gibt es Erfahrungsgemäß bessere Ideen für so etwas? Wie gesagt, bin für jeden TIP dankbar.

MfG
youfyouk


----------



## Larry Laffer (4 Februar 2011)

... wenn du sicherstellen kannst, dass es alle die berechnet aufgerufenen FC's auch wirklich gibt dann wirst du auch keinen Stress bekommen - den gibt es nur wenn du auf diese Weise einen FC aufrufen willst den du nicht hast ...

Gruß
Larry


----------



## youfyouk (4 Februar 2011)

Ja die FC's gibt es. 


```
myFC : BLOCK_FC
myIndex : INT
 
L p#myFC
LAR1
L myIndex
T W [AR1,p#0.0]
 
UC myFC  // hier wird gemeckert...
```

Kenne mich in AWL leider nicht so gut aus. 

MfG
youfyouk


----------



## sps-concept (4 Februar 2011)

*Uc*

Hallo,

haben deine aufzurufenden FC's Parameter? Dann ist das das Problem.

André


----------



## Nordischerjung (4 Februar 2011)

youfyouk schrieb:


> Ja die FC's gibt es.
> 
> 
> ```
> ...



Sollte man es nicht so schreiben?


```
UC FC [myFC]
```

[Edit] 
NEIN, nicht so

Ist doch Block_FC, hab ich übersehen
[/Edit]


----------



## youfyouk (4 Februar 2011)

sps-concept schrieb:


> Hallo,
> 
> haben deine aufzurufenden FC's Parameter? Dann ist das das Problem.
> 
> André



Nein, die haben keine Parameter.
Was muss ich tun, damit es funktioniert?

Edit:

```
myFC : BLOCK_FC    //hatte an der Stelle BLOCK_DB stehen 
myIndex : INT
 
L p##myFC
LAR1
L #myIndex
T W [AR1,p#0.0]
 
UC #myFC
```
Jetzt hab ich im OB1, wenn ich FC100 aufrufe die zwei Eingänge, myIndex ist klar (DB1.DBWx) was muss an myFC (erwartet : BLOCK_FC)?


----------



## Larry Laffer (4 Februar 2011)

myFC mußt du als Variable (vom Typ Block_FC) irgendwo deklarieren (z.B. im TEMP-Bereich des aufrufenden Bausteins).


----------



## Nordischerjung (4 Februar 2011)

Larry Laffer schrieb:


> myFC mußt du als Variable (vom Typ Block_FC) irgendwo deklarieren (z.B. im TEMP-Bereich des aufrufenden Bausteins).


Das geht aber nicht im OB Tempbereich,

schreib da doch irgend eine FC dran die du nicht benötigst


----------



## youfyouk (4 Februar 2011)

Larry Laffer schrieb:


> myFC mußt du als Variable (vom Typ Block_FC) irgendwo deklarieren (z.B. im TEMP-Bereich des aufrufenden Bausteins).



BLOCK_FC kann nur als IN Variable deklariert werden.


@Nordischerjung


> schreib da doch irgend eine FC dran die du nicht benötigst



Die CPU geht in STOP


----------



## Nordischerjung (4 Februar 2011)

youfyouk schrieb:


> Die CPU geht in STOP



Die FCs müssen schon in der CPU sein


----------



## Larry Laffer (4 Februar 2011)

youfyouk schrieb:


> BLOCK_FC kann nur als IN Variable deklariert werden.


Sorry ...  ... ich hatte das nicht kontrolliert und wie schon geschrieben würde ich selbst so nicht arbeiten.


----------



## youfyouk (4 Februar 2011)

> ...wie schon geschrieben würde ich selbst so nicht arbeiten.



Wie würdest su das denn machen? Kannst du mir ein TIP geben?

MfG
youfyouk


----------



## Larry Laffer (4 Februar 2011)

... schau dir doch mal unter AWL den Befehl SPL an. Hier kannst du entsprechend eines vorher geladenen Zahlenwertes Sprungmarken anspringen. An jeder Sprungmarke kannst du dann nun entsprechende Aktionen ausführen - z.B. einen FC aufrufen (aber auch Anderes) ...

Gruß
Larry


----------



## youfyouk (4 Februar 2011)

Hallo nochmal,

danke Larry für den TIP, nun sieht es so aus scheint auch zu funktionieren.


```
L     "DB1".Programmwahl         // 4 Bit Eingang (0-15)
      SPL   lstx                              
      SPA   null
      SPA   fc_1
      SPA   fc_2
      SPA   fc_3
      SPA   fc_4
      SPA   fc_5
      SPA   fc_6
      SPA   fc_7
      SPA   fc_8
      SPA   fc_9
      SPA   fc_a
      SPA   fc_b
      SPA   fc_c
      SPA   fc_d
      SPA   fc_e
      SPA   fc_f
lstx: SPA   ende
null: SPA   ende
fc_1: CALL  FC     1
fc_2: CALL  FC     2
fc_3: CALL  FC     3
fc_4: CALL  FC     4
fc_5: CALL  FC     5
fc_6: CALL  FC     6
fc_7: CALL  FC     7
fc_8: CALL  FC     8
fc_9: CALL  FC     9
fc_a: CALL  FC    10
fc_b: CALL  FC    11
fc_c: CALL  FC    12
fc_d: CALL  FC    13
fc_e: CALL  FC    14
fc_f: CALL  FC    15
ende: NOP   0
```
Immernoch besser als in FUP mit 15 NW. Ich würde trotzdem lieber eine Variante mit einer Variable vorziehen (so in etwa: CALL FC[DB1."Programmwahl"]), dann wären es nur einpaar Zeilen.
Falls jemand so etwas hat kann sich ja mal melden, danke.

MfG
youfyouk


----------



## Jochen Kühner (4 Februar 2011)

```
L DB.Programmwahl
T #blabla // wort in temp
UC FC [#blabla]
```

sollte doch gehen, du hast halt dann nichts in der querverweisliste...


----------



## Larry Laffer (5 Februar 2011)

Die Variante von Jochen kannte ich noch gar nicht ... Interessant ...

@TE:
Das mit der Sprungleiste ist so aber noch nicht ganz richtig da ab dem angesprungenen auch alle weiteren FC-Aufrufe abgearbeitet werden. Du müßtest da also hinter jedem Aufruf um das zu verhindern noch ein "SPA Ende" mit dranhängen ...

Gruß
Larry


----------



## youfyouk (6 Februar 2011)

> Jochen Kühner 	 		 		 	Code:
> L DB.Programmwahl
> T #blabla // wort in temp
> UC FC [#blabla]
> sollte doch gehen, du hast halt dann nichts in der querverweisliste...



so einfach? 
Vielen Dank


----------



## Zefix (10 Februar 2011)

Jochen Kühner schrieb:


> ```
> L DB.Programmwahl
> T #blabla // wort in temp
> UC FC [#blabla]
> ...



Ja so einfach 
Wir hatten mal ne kleine alte Anlage, dürfte kurz drauf gebaut worden sein, als die S7 rauskam.
Da hat der Programmierer so die Schrittkette gemacht.
In einer FC den Aufruf und in den, ich glaub so um die 20 FCs warens, dann die Transitionen und mit nächster Schrittnummer in MW [#blabla]laden.
Wär ja gegangen wenns nacheinander abgearbeitet worden wäre, aber das war ein gehopse, der reinste Wahnsinn 
Wir hams gehasst wenn da was zum ändern war, bzw. Störung war.


----------

