DB in SCL übergeben

Felse

Level-1
Beiträge
221
Reaktionspunkte
10
Zuviel Werbung?
-> Hier kostenlos registrieren
Morgen zusammen,
ich hab ja gestern schonmal das Thema gehabt (danke nochmal an alle für die Hilfe) hat dann ja auch gefunzt. Dabei hab ich einzelne Variablen im SCL angelegt und die dann beim FC Aufruf im OB1 meinen Variablen aus dem DB zugewiesen. Das find ich bei ca 50 Variablen im DB aber ganz schön aufwändig, daher meine Frage, kann man auch einfach einen kompletten DB mit allen Variablen im SCL aufrufen und die dann direkt nutzen? Wenn ja, wie geht das?
 
Ja ich würde mal behaupten am besten symbolisch.

z.B.

myDBname.myVariablenname := 123;
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Hallo Felse,
wenn du so etwas vorhast, dann ist es sinnvoll, dass SCL den Aufbau des DB's kennt (es sei denn, du willst diesen wirklich nur als ARRAY [1..x] of WORD betreiben).
Hat dieser DB einen komplexen Aufbau (Mischmasch aus allen möglichen Variablentypen), dann könntest du hier so vorgehen, dass du einen UDT anlegst und diesen UDT in dem DB hinterlegst und gleichzeitig SCL auch den UDT bekannt gibst. Nun kannst du auf die Inhaölte des DB auch symbolisch zugreifen.

Vielleicht beschreibst du dein Vorhaben mal etwas konkreter ...

Gruß
LL
 
Es sind verschiedene Variablentypen im DB enthalten (bool, int, string). Ich hätte gern gewusst ob es im SCL die Möglichkeit gibt Variablen aus dem DB direkt in mein Programm einzufügen (sowie man das z.B. im FUP machen kann). ODER:
Bei meinem Themenstart hab ich ja erklärt das ich die Variablen im SCL angelegt hab (siehe Screenshot, schalter 1 und 2,) dann hab ich diesen Variablen aus dem DB zugewiesen (Login, Logout). Bei zwei Variablen ist das ja nicht schlimm aber bei ca 50 ganz schön nervig, deshalb hab ich gedacht, man könnte ähnlich wie die Variablen einen DB aufrufen und muss dann die in ihm enthaltenen Variablen nicht nochmal im OB1 wie im Bsp anlegen.
 

Anhänge

  • prog.bmp
    213,6 KB · Aufrufe: 90
Zuviel Werbung?
-> Hier kostenlos registrieren
... in dem Zusammenhang drängt sich mir ein bißchen auf, ob wir uns nicht besser über einen FB statt einer FC unterhalten.

Beschreib doch bitte mal genau, was passieren soll ...
Vielleicht läßt sich aus der Problemstellung dann etwas Schönes entwickeln. Ich glaube nicht, dass du mit den pauschalen Antworten von z.Zt. Zotos und mir wirklich weiterkommst ...
 
... in dem Zusammenhang drängt sich mir ein bißchen auf, ob wir uns nicht besser über einen FB statt einer FC unterhalten.
Das könnte schon sein... Aber ich denke/hoffe es müsste auch so gehen.

Zu meiner Aufgabe: Ich habe mehrere Eingabefelder (int) untereinander. daneben zu jedem Feld einen Schalter (bool). Wenn eine Zahl in das Feld eingegeben wurde, kann der dazugehörige Schalter erst betätigt werden. Aber: die Zahl im Feld muss immer größer sein als die vorige. Falls nicht wird das feld bei Schalterbetätigung wieder auf null gesetzt. Funzt ja auch, es geht mir eben nur um den Aufwand, da ich noch weitere, ähnliche Funktionen erstellen muss.
 
Ich denke mal "UDT" ist die Antwort. Ansonsten schließe ich mich meinen Vorrednern an!

ODER

schau dir mal den AT Befehl an - über nen Pointer könnte ich mir das ganze auch ganz gut Vorstellen.
 
Zuviel Werbung?
-> Hier kostenlos registrieren
... also ist die Funktion in etwa so :

Eingabe_Bit_1 darf TRUE sein, wenn Eingabe_Feld_1 >= 100
Eingabe_Bit_2 darf TRUE sein, wenn Eingabe_Feld_2 > Eingabe_Feld_1
usw.

1. ist das so korrekt ?
2. Wieviele könnene es maximal werden ?
3. Welcher weitere Sinn steckt dahinter ?

Gruß
LL
 
Hallo,

natürlich kannst Du in SCL auf beliebige Daten in DBs zugreifen. Symbolisch geht das im Format DBName.Variablenname. Direkt geht auch, einfach die "" weglassen.
 
... um die so salopp hingestellte Aussage von ahaenle mal etwas zu relativieren :
Du kannst mit SCL auf alles zugreifen, was dem Compiler zum Zeitpunkt des compilierens bekannt war. Letztlich wird aus allem wieder eine absolute Adresse erstellt. Also wird aus z.B. DB10.meineVariable_1 dann wieder DB10.DBW2. Damit SCL das so benutzen kann muss es feststehen.
Will man auf etwas variabel zugreifen, dann sieht das dann schon etwas anders aus ...
[/CODE]
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Ist klar. Ich hab Felse so verstanden, dass er sich das Anlegen der Variablen am Baustein sparen will. Sauberer Programmierstiel ist das IHO nicht. Ich benutze es eigentlich nur für "quick and dirty" Funktionen die ich sonst nirgends mehr verwenden will.
 
... um die so salopp hingestellte Aussage von ahaenle mal etwas zu relativieren...

Diese "saloppe" Aussage habe ich schon zweimal in diesem Thread geäußert und vermute das Du lieber Kollege Larry über das aktuelle Lernziel vom Kollegen Felse hinausschießt.

Step by Step nicht gleich sieben schritte auf einmal (nur weil es sich Step7 schimpft) ;o)
 
Zuviel Werbung?
-> Hier kostenlos registrieren
.. Also wird aus z.B. DB10.meineVariable_1 dann wieder DB10.DBW2. Damit SCL das so benutzen kann muss es feststehen.
Will man auf etwas variabel zugreifen, dann sieht das dann schon etwas anders aus ...
[/code]

FUNCTION FC10 : VOID
VAR_INPUT

Planscheibe.PPI_PS_SPEED_LIMIT_HAND: INT; //E-Feld 1
Planscheibe.PPI_PS_SPEED_LIMIT_AUTO: INT; //E-Feld 2

END_VAR

VAR_OUTPUT

Planscheibe.PPI_GU_STUFE: BOOL;
END_VAR
Planscheibe.PPI_GU_STUFE:= (Planscheibe.PPI_PS_SPEED_LIMIT_HAND > Planscheibe.PPI_PS_SPEED_LIMIT_AUTO);
END_FUNCTION

Das ist ja jetzt ein konkretes ähnliches Bsp. Wenn ich das richtig verstanden habe, müsste das ja dann so funzen. Planscheibe ist mein DB und der Text ist mein Variablenname. Oder kann mir jemand zeigen wie es mit dieser symbolischen Schreibweise funzen soll.
 
Erstmal muss ich meinem Freund Zotos schwer Abbitte leisten - Zotos du hattest Recht.

Mein lieber Felse ...
das geht so nicht !!!
Die INPUT-, OUTPUT- und IN_OUT-Variablen einer Funktion oder eines FB's sind nur Platzhalter für von aussen dranzusetzende Daten. Du kannst den Platzhalter NICHT mit einer Indexierung vermischen. Das hatten wir aber schonmal ...
Wenn du mit den INPUT-Parametern arbeitest, dann arbeitest du mit diesen - du kannst diese nicht mit absoluten Adressen vermischen.

Das was du im Grunde anstrebst ist eine indirekte Adressierung. Hier arbeitest du auf die eine oder andere Weise mit Pointern (Zeigern). Diese Zeiger übergeben dann auch nicht die Ziel- oder Quell-Variable sondern sie sagen nur, wo die steht.

Wir sind jetzt aber immer noch bei Grundsatz-Dingen. Um dir (eventuell mit konkreten Tipps) helfen zu können, bräuchte man (wir) viel mehr. Ich wiederhole also noch einmal meine Frage :
"Was willst du genau machen und was soll das bewirken". Denke bei deiner Beschreibung bitte daran, dass zumindestens ich vielleicht von dem Sinn deines Tuns überhaupt keine Ahnung habe und dass du deswegen vielleicht auch etwas weiter ausholen mußt ...

Ich bin mal gespannt.

Gruß
LL
 
Zuviel Werbung?
-> Hier kostenlos registrieren
allo Felse,

ich ich glaube Du hast da einen Denkfehler!:rolleyes:

FUNCTION FC10 : VOID
VAR_INPUT

Planscheibe.PPI_PS_SPEED_LIMIT_HAND: INT; //E-Feld 1
Planscheibe.PPI_PS_SPEED_LIMIT_AUTO: INT; //E-Feld 2

END_VAR

VAR_OUTPUT

Planscheibe.PPI_GU_STUFE: BOOL;
END_VAR
Planscheibe.PPI_GU_STUFE:= (Planscheibe.PPI_PS_SPEED_LIMIT_HAND > Planscheibe.PPI_PS_SPEED_LIMIT_AUTO);
END_FUNCTION

Du versuchst externe Daten auf die Du direkt zugreifen willst als Variablen der Funktion zu definieren?!:confused:

Das geht so nicht! Es ist eigentlich viel einfacher!!!

So funzt dein FC:

FUNCTION FC10 : VOID

Planscheibe.PPI_GU_STUFE:= (Planscheibe.PPI_PS_SPEED_LIMIT_HAND > Planscheibe.PPI_PS_SPEED_LIMIT_AUTO);
END_FUNCTION

Du musst garnichts definieren wenn Du nur direkt mit externen Daten arbeitest!

Wenn Du jetzt aber z.B. mehrere solcher Planscheiben in deinem Prog bearbeiten musst ist das keine gute Lösung. Dann solltest Du das besser so machen:

FUNCTION GU_STUFE: BOOL
VAR_INPUT

SPEED_LIMIT_HAND: INT; //E-Feld 1
SPEED_LIMIT_AUTO: INT; //E-Feld 2

END_VAR

GU_STUFE:= (SPEED_LIMIT_HAND > SPEED_LIMIT_AUTO);
END_FUNCTION

In der Symbolik GU_STUFE als FC10 definieren. Diesen FC kannst du dann beliebig oft in deinem Prog verwenden. Die beiden "SPEED_LIMIT" werden als Eingänge am Aufruf angelegt und der Rückgabewert ist das gewünschte "GU_STUFE".:ROFLMAO:
 
Hallo Felse,
wenn du so etwas vorhast, dann ist es sinnvoll, dass SCL den Aufbau des DB's kennt (es sei denn, du willst diesen wirklich nur als ARRAY [1..x] of WORD betreiben).
Hat dieser DB einen komplexen Aufbau (Mischmasch aus allen möglichen Variablentypen), dann könntest du hier so vorgehen, dass du einen UDT anlegst und diesen UDT in dem DB hinterlegst und gleichzeitig SCL auch den UDT bekannt gibst. Nun kannst du auf die Inhaölte des DB auch symbolisch zugreifen.

Vielleicht beschreibst du dein Vorhaben mal etwas konkreter ...

Gruß
LL
Passt zu meinem Vorhaben . Ich habe einen DB6 der aus einem von mir gemachten UDT "besteht".
ich kann jederzeit darauf zugreifen in SCL mit DB_Auto.Fahren.blabla (DB6= DB_Auto, Fahren heißt das "Struct", dann kommen paar Bools und Words).
Ich kann aber nicht z.B. in SCL Meine_Daten:Block_DB; dann später Meine_Daten.Fahren.blabla nutzen.
Gibt es eine Möglichkeit den symbolischen zugriff zu "ändern"? also Sprich das ich aus DB_Auto..... in SCL z.B.: Mein_DB. . . . (symbolik des Structs) mache?
Ich hoffe das irgendwer versteht was ich meine ;-)
 
Wenn Du Deinen DB als Block_DB übergibst, dann kann der SCL-Compiler nicht ahnen, welchen DB Du zur Laufzeit übergeben wirst und welche Struktur dieser DB dann haben wird. Deshalb kann der Quelltext nicht symbolisch auf diesen DB zugreifen.

Anders sieht das aus, wenn Du Deinen UDT übergibst. Dann kennt der Compiler die Struktur und Du kannst symbolisch zugreifen. Allerdings bläht sowas den erzeugten Programmcode unheimlich auf, wegen den dann nötigen Adressberechnungen zur Laufzeit.

Harald
 
Zurück
Oben