FC calling FC. L-Stack issues??

To save some time and programming effort, I created a function (FC100 below) to simply toggle a bit when a button is pushed. When testing the code on the sim and on a bench PLC everything worked fine (push button, output on, push again, output off).
Ive now placed it in another function (FC240) being called directly from OB1. In this particular function FC100 is being called three times in a row from FC240 to provide a toggle function to 3 "buttons" (in another function its called 54 times in a row for 54 buttons). Problem is that now FC100 doesnt work (all kinds of "flakey" behaviour).
If I extract the code from FC100 and use it directly in FC240 (replacing the one TEMP variable "#TriggerPulse" for an M bit) it works beautifully. Because of this, Im assuming that somehow #TriggerPulse is being carried through to subsequent calls.
Could somebody please explain what is happening here and why FC100 works well on its own but not with multiple sequential calls? Is there some way to correct this situation in FC100 or will I have to rewrite everyplace that uses FC100?

Thanks in advance!!!
Cheers,
Todd

Code follows:

FC240
Network 42
A I 0.1
A DB6.DBX 773.1
= L 7.0
BLD 103
A M 0.0
JNB _001
CALL FC 100
Trigger :=L7.0 //Input
Output :=DB6.DBX837.1 //Output
TriggerPulse:=#NULL//Output
OneShot :=M242.2//Input
_001: NOP 0

Network 43

A I 0.1
A DB6.DBX 773.2
= L 7.0
BLD 103
A M 0.0
JNB _002
CALL FC 100
Trigger :=L7.0
Output :=DB6.DBX837.2
TriggerPulse:=#NULL
OneShot :=M242.3
_002: NOP 0

FC100
Network 1
A #Trigger
BLD 100
FP #OneShot
= #TriggerPulse //Temp
Network 2
A #TriggerPulse //Temp
AN #Output
O
AN #TriggerPulse //Temp
A #Output
= #Output

Hi Hubeig,

I couldn't see variable declaration of your function.
I will assume that you put OneShot in IN_OUT parameters not in IN parameters because I see it comes after IN and OUT parameters when you call FC100.

I think I understand why this happens and I hope I will say the correct explanation.

This happens because you depend on temp variables to determine a status of something.

If you have
FC1 needs 2 bytes of temp variables,
FC2 needs2 bytes of temp variables

You call them in OB 1 this way,
FC1
FC2

This never means that the temp variables will be uniquely assigned to each function.
Let's say that FC1finished execution andthe temp variables were like this,
Byte 0 has 11111111
Byte 1 has 00001111

Then when it's time to execute FC2 which comes directly next to FC1,
CPUwill notallocate new locations in local data for temp variables of FC2 butwill use the same local data which has been allocated for the last FC (which is FC1).

This means that the initial values of temp variables of FC2 will be

Byte 0 has 11111111
Byte 1 has 00001111

OK, now if you say in FC2.

IfI0.0 is ON set L0.0
If L0.0 is ON set Q0.0

You didn't write what if I0.0 is not ON.
what will happen?
Q0.0 will be set because it depends on L0.0 which is ON either I0.0 is ON or NOT.

If the next execution of FC1 left the temp variables like this,

Byte 0 has 00000000
Byte 1 has 00001111

Now, when FC2 is called, it will have initial values in temp variables,

Byte 0 has 00000000
Byte 1 has 00001111

The execution of FC2 will be correct whether I0.0 is ON or OFF because L0.0 is already OFF and will not beON until I0.0 is ON.

I tried to keep it simple but I don't know if it is clear or not.
To sum up,
The allocation of local data (Temp variables) depends on where and when the FC is called.
So, you get randomvalues in Temp variables every time your function is executed.
This means that you are right as #TriggerPulse is carried out through to subsequent calls.

To come over this, you should initialize temp variables before doing anything.
Try to reset the temp variable (#TriggerPulse) in a separate network before the other 2 networks.

Best regards.

Hello Hubieg

I have a bad feeling that the Parameter "Output" of your FC100 is in fact of type "OUT".
Your variable type declaration is unfortunately not quite clear, you wrote that your FC100 call looks like this:
CALL FC 100
Trigger :=L7.0 //Input
Output :=DB6.DBX837.1 //Output
TriggerPulse:=#NULL//Output
OneShot :=M242.2//Input

Can you please verify which Parametr is what type, my assumption is this:
CALL FC 100
Trigger :=L7.0 // Type: IN
Output :=DB6.DBX837.1 // Type: OUT
TriggerPulse:=#NULL// Type: IN_OUT
OneShot :=M242.2// Type: IN_OUT (it would not be located at the bottom of the
call it it is an "input" as you stated)

Anyway,assuming the Parameter "Output" isof type "OUT", then this is what causes your problem for the following reason:

Some background info first:
In principle S7 does parameter passingon the so called "pass byvalue" principle (S5 in contrast did "pass by address").
This means that you must always assume that only values (rather than addresses, even though S7cando "pass by address" for 4 byte longaddressesbut that is subject for another day) are passed on the FC or FB and that the FC or FB internally works with the value rather than the address of the parameter.
This in turnleads to the followingrules for parameter access (espaciallyinan FC) which you should adhere too:
IN: READ ONLY access
OUT: WRITE ONLY access (and MUST be written to when an FC is called)!
IN_OUT: READ OR WRITE access

You are violating this rule by doing a Read access to an OUT variable, change Paramter "Output" from type "OUT" to type "IN_OUT" and your problems will go away!

Also, consider removingParamter "TriggerPulse" from FC100 and make it a TEMP variable inside FC100 instead (otherwise it too MUST be of Type "IN_OUT").

My proposal for your FC100 would look like this:

FUNCTION FC 100 : VOID
TITLE =
VERSION : 0.1

VAR_INPUT
Trigger : BOOL ;
END_VAR
VAR_IN_OUT
Oneshot : BOOL ;
Output : BOOL ;
END_VAR
VAR_TEMP
Trigger_Pulse : BOOL ;
END_VAR
BEGIN
NETWORK
TITLE =

A #Trigger;
BLD 100;
FP #Oneshot;
= #Trigger_Pulse; //Temp
NETWORK
TITLE =

A #Trigger_Pulse; //Temp
AN #Output;
O ;
AN #Trigger_Pulse; //Temp
A #Output;
= #Output;

END_FUNCTION

I trustthis helps and good luck with your project.