In your example the rung would evaluate true once every 1.196 sec
I think you have a typo there; it's actually 1.6384s (twice 2^13 = 8192 cycles of the 10Khz free-running clock(FRC) => 8192clock-cycle/bit-transition * 2bit-transition/bit-13-cycle * 1e-4s/clock-cycle).
While I would expect the full scan time of the ladder would be typically be about 150 ms or so depending on the size and complexity of the program.
Yes, agreed: if the per-scan time of the ladder program (S:35, IIRC) is longer than the bit-cycle of the chosen FRC bit then the program would likely miss some rising edges.
The BSL would never execute every scam of the ladder code. ...
Actually this is only true in typical operation i.e. if the code does not poke the control structure's bits apart from what happens in the BSL instruction.
If you duplicate my code in
post #7, then you will see that the BSL behavior can indeed be tricked into shifting the bits every scan.
The key is to recognize that the only way to detect a "rising edge" of a bit is to know (i.e. store) the state of that bit from the previous scan (N.B. GaryS, in his last post, basically says just that in between the lines).
So the concept of "rising edge" actually involves the
combined states of two bits: the source bit which has the rising edge to be detected; the storage bit which contains the state of the source bit
from the previous scan.
I.e. in ladder, the rising edge detection looks like this:
Code:
source_bit storage_bit
-----] [-----+------------------------( )------------+---
| |
| storage_bit rising_edge_bit |
+-----]/[----------------( )------------+
The point is that state of the [rising_edge_bit] is dependent on the states of
both the [source_bit]
and the [storage_bit].
So if, after that previous rung, another rung were added like this:
Code:
force_rising_edge storage_bit
-----------] [------------------------(U)------
Then, whenever [force_rising_edge] was 1, the [rising_edge_bit] will be assigned a 1 on every subsequent scan that [source_bit] was 1.
What I was doing in the example in post #7 was just that i.e. putting a 0 into the [storage bit] (i.e. R6:0.EN) of the BSL's [rising edge-detection] machinery.
Play it in your head, or better yet, code my example in post #7 and run it: you will see the 1 bit jump 8 positions, from L10:0/7 to L10:0/15 (actually it takes 8 scans; with no other code running that takes less than 10ms, so it appears to be instantaneous).
