• Not Answered

Sequence Action Confirm Parameter Path

We recently had an issue of a sequence action appearing to "skip".  We soon discovered that it was not skipping, but that there was an issue with how we confirm written values.  I would like to see if anyone can validate this theory.

To provide an example:  If a sequence action writes "@MODULE@/CAS_IN := 30" we will typically configure the Confirm within that action to "@MODULE@/CAS_IN = 30".  I suspect that this confirmation will ALWAYS be true and instantaneous.  I think this is the case because this confirmation does not require a module scan.  If the confirmation were instead: "@MODULE@/PID1/CAS_IN = 30"  then the module would have to scan successfully and the PID1 block would have to be written to by the CAS_IN parameter.  My theory is that when you write and confirm the same exact parameter path, the statement will always be true and always be instantaneous.  I think this may be because there is some "register" or "unloaded online value place-holder" of sorts for online values.  The confirmation verifies the register but not the actual online module parameter, and thus does not require a module scan, and therefore is always instantaneous.

Can anyone comment on this?

13 Replies

  • To confirm that a value has been written, you can check for the .AWST Asynchronous Write Status field to be 0; for example: '@module@/CAS_IN.AWST' = 0.
    Should you prefer to confirm the written value has the effect you wish, you could have the confirm check for the appropriate result. In this example, the value of CAS_IN.CV is written to SP.CV when MODE.ACTUAL = CAS, so the confirm could be '@module@/SP.CV' = 30, which would be True when the MODE is set properly.
    Though it's usually not advised to check a floating point value to be = to a number, since the confirmation is checking to the value just written, it should work.
    You could have the confirm expression check for the applicable process condition to be affected: '@module@/PV.CV' >= SP.CV * 0.9, though checking the process condition may be best done in a transition following this step.
    Hope this helps.
  • In reply to JDWheelis:

    As JD suggests the use of AWST will confirm a value has been written, when the write is within the same controller this will be instantaneously be written and will immediately confirm. If the write is across controllers the write could be buffered depending on how many writes are occurring to other controllers and NOT be instantaneously written. If you don't confirm this properly there are situations (which you have seen) that appear that the logic didn't execute which is actually the result of the buffered write being removed from the buffer if it hasn't been written yet and the logic has moved on.

    I would highly discourage using values written because of the one issue JD describes but I would say the bigger issue is any limiting that could be done (SP High/Low, Out High/Low, etc) which if tuned later would get the logic hung up or logic overwriting the value (SP/Out tracking).

    Using the AWST confirm will always work regardless of potential floating errors, limiting, or logic overwriting the value written.
  • In reply to JDWheelis:

    Thank you! How can we know if CAS_IN.AWST = 0 because the current write was successful vs the previous write the last time this sequence ran? Could the write be unsuccessful but the Confirm CAS_IN.AWST = 0 bit becomes true before the CAS_IN.AWST can reflect the write status due to the latest write action?
  • In reply to Eric Gratz:

    No the value will always initially be 0 for AWST but you can look in Books Online for some more information under:

    • Configuration->General Configuration->Controller considerations->Inter-Controller communication guidelines
    • Configuration->Recommended Practices->Using recommended engineering practices->Recommended practices for using DeltaV batch-> Using confirm expressions in an SFC, phase, or phase logic module

    One note about the last suggested section is there is a bullet item talking about when using AWST and it describes a time delay of 1 second required when writing and checking, this isn't required and I thought this was getting updated but apparently it hasn't been updated yet. Checks for AWST can be done immediately without a time delay in your configuration.

  • In reply to Matt Stoner:

    Hi Matt,

    This came up last year too. I have one site that had such a nasty experience fixing confirmations to include the AWST due to experiencing real issues that they require some documentation from Emerson that the delay is no longer necessary before they will stop adding it. Is there anything you can do to help us get that documentation?

    Thanks!!!
  • In reply to Brian Hrankowsky:

    I've never seen it necessary as we have been using this confirm style (no delay) for a very long time (version 4/5 or earlier). I actually had conversations with Product Engineering in Austin on this topic who initially thought it was still needed but they had tested nearly 1/2 billion writes, exceeded some recommended limits and had no failures. As a result the KBA AP-0900-0113 was modified in Aug 2018 to remove the below comment (which you won't find in the document other than in the revision history and the same documentation as Books Online).

    When using an AWST (Asynchronous Write Status) in a Pulse Action confirm expression or a transition expression, the PARAMETER.AWST status value will initially be “0” (Success) before the pulse write becomes active. A time delay of 1 second is required between writing to the PARAMETER.CV and checking the PARAMETER.AWST; the .AWST status should cycle from “0” (Success) to “2” (Write Pending) and back to “0” (Success) in approximately 0.5 second for a successful write.

    Not sure if that is the documentation you would need or not but I think if you had the earlier version of the KBA with that verbage in it and the latest shows it has been removed would be good enough.

  • In reply to Matt Stoner:

    Can we assume a Pulse Action to write to PARAMETER.CV will always cause PARAMETER.AWST to change from 0 to 2? Using the confirmation PARAMETER.AWST = 0 assumes that this value had been 2 after the pulsed write action.
  • In reply to Eric Gratz:

    Sorry for delay, I was celebrating a Superbowl win!

    A write to a parameter in the same controller will be instantaneous (will be 0) unless the write was unable be done (i.e. writing RCAS mode and RCAS mode isn't enabled on PID1/MODE). If the destination write is in another controller it will be 2 (or non-zero) on a pulse action. So you can write the value in the action and confirm on the same action that the .AWST of the parameter written to is zero.

    Possible values for AWST:
    -4 means 'write rejected'
    -3 means 'external reference not resolved'
    -2 means 'parameter not configured'
    -1 means 'module not configured'
    0 means 'success'
    1 means 'not communicating'
    2 means 'write pending'
  • In reply to Matt Stoner:

    Hi Matt,
    who won the bowl? ;-)
    I have such discussions often with my customer about the right confirm expression and even when they are really needed.
    I guess, if I have to check that a write to a parameter into the own controller must be verified would kill my trust in such an system.
    The main point is if we have an inter controller communication due to the reason, that they could be delayed through the write queue.
    As
    Would you say it where enough to check on the AWST sub-parameter = 0 instead to check is the former value just confirmed. So, as the default expression promote it.
    I ask, because we have a specific logic in one EM, which hold some alarm limit to the PV_SCALE end-range under certain conditions.
    If another phase send the same command and default alarm limits, which do not have any function for that specific command, it try to confirm that an i.e. assignment LO_LIM:=0 , confirm LO_LIM=0 , while the logic in the EM in another ctrl still want set it to LO_LIM:= -1 as Scale-Endvalue.
    Due to the asyncronuos execution of both modules it can come to a dead lock here if the EM overwrite the value from 0 to -1 before the phase step action confirms.
    Can we use just LO_LIM.AWST = 0 in the confirm expression regardless of the value?
    The point is that a phase write allways all Phase parameter down to the EM in our case, but sometimes it is not used for a specific command and even not set from the recipe, so that the phase writes the default value.
    The EM instead is the last instance to check for those parameters. If the AWST confirmation, without checking the value too, would be enough then we can save a lot of work(Pharma->GMP). Just make the phase happy that it wrote the value to the target and the EM that it could overwrite that parameter to the useful value.
    I would never think that the value will be incorrect anyway due to the invisible internal controller communication.
    I guess very deep in the cellar of DeltaV is a logic which will do that anyway, because it must also decide to which number it has to set the AWST and we can trust this function. So, the simple check on LO_LIM=0 in the cofirm expression is not necessary, while AWST gives a better feedback that the written value reached really the parameter and not only an register in a buffer on the way only.
    Hope it is clear to you what I mean.
    Thank You, Michael
  • In reply to Michael Krispin:

    Wow, somehow I have missed this comment so sorry for the very long delay Michael.

    As mentioned previously we have been using only the AWST = 0 confirm for many many revisions of DeltaV and the only time we have to use the value written is when the value written is reset after completion of task like a timer/totalizer reset. In those cases were the value is false, written to true and then to know has been reset it will get set back to false locally we have to also add AND PARAMETER = FALSE. This is because the value hasn't been written yet so it will be FALSE (indicating reset complete) but we have to ensure the value has been written (AWST = 0) which will then have the value TRUE (indicating reset is required) and then the module will see this, do the required action and reset back to FALSE. So in your example for alarm limits you won't need value confirms and only using the LIMIT.AWST = 0 as the confirm will be sufficient. Other confirms would need to be looked at depending on how the logic works to confirm the action really has been "completed".
  • In reply to Matt Stoner:

    Hi Matt,
    In principle you confirm my thoughts and it will lead into a generic coding.
    Generic code shall be used where ever possible as a good engineering practice.

    No problem if you answer late.
    This chat is also valid in many years and if someone search for this chapter later, he/she can find this here.
    That drive me to say thank you to Emerson, that they provide such a user knowledgebase at all.
    BR, Michael
  • In reply to Michael Krispin:


    I have a recent GSC Call for confirmation of when and how to use the AWST as Books Online and the KBA guidance on confirms indicates that a correlating parameter value or the written parameters value should be used. in cases where they cannot (e.g. a reset parameter that doesn't hold its value) the AWST method needs to be used and needs at least a 0.5 second delay in the condition (e.g. step time > 1) to allow time for the AWST to change from OK as it will be OK immediately after the write. The GSC confirmed to us this year that this is the correct approach.

    We had used the AWST across the board previously , but ran into problems in an older version of DeltaV where sequences were moving on without the value actually being written. The fix provided by Emerson had included adding the step time delay to the confirms. This is annoying to the users because every step has a 1 (or more) scan delay whether it is really needed or not.

    I know we have another thread where you had mentioned having done a lot of testing on this in more recent versions of DeltaV without the delay on the AWST and did not have issues. Is there any way to get a final verdict on this?
  • In reply to Brian Hrankowsky:

    The KBA AP-0900-0113 (not AP-0900-0133 that is referenced in your call) use to have the wording of waiting for time and it was tested/confirmed by Product Engineering that the delay time wasn't required so the KBA was updated in Aug 2018 with this revision description "Deleted consideration when using Asynchronous Write status (AWST) in a Pulse Action Confirm" so this isn't an open item.

    I would trust KBA's before I would trust Books Online (BOL) as it seems for things like this...the update of BOL is "forgotten". I'll send a note to Austin to highlight this difference.