Asynchronous Call - collect OR forget?

Hi all,
I want to optimize one of my LabView procedures. Let's say that I've got 2 VIs that return the same values, but use differend data sources. I'd like to launch both of them and simply collect the result from the faster one.
I figured I could do this by running both VIs asynchronously and polling a global variable, but I was hoping that there is a better solution.
If I "Wait on asynchronous call" for both VI, I'll wait for the slowest one to finish. Is there a way to check if VI has finished its job without running into "wait on asynchronous call"?
Thanks in advance!
Tomasz
Solved!
Go to Solution.

In this case, I would probably go with the notifier.  You could possibly also go with a User Event.
There are only two ways to tell somebody thanks: Kudos and Marked Solutions
Unofficial Forum Rules and Guidelines

Similar Messages

  • Teststand New Thread VS LabVIEW "Call & Forget" Asynchronous call

    Hi everyone,
    Here is an example taken from the ni.com website showing how to use LabVIEW to post a TestStand Notifier.  I have modified the example to fit the situation I needed to use it for.  I have an example which works fine (When I use a TestStand new thread to launch the Notifier VI) and an example which does not work (When I use a LabVIEW "Call & Forget" Asynchronous call to launch the Notifier VI).
    I would like to understand why it doesn't work in the second situation. The reason why I would prefer the 2nd situation which currently doesn't work is that I try to eliminate all multi-threads from an obsolete sequence written by someone else a few years ago so that I can troublesoot it and update the code to make it work with today's new reality.
    Also, for my personal knowledge.  I don't understand why the second strategy doesn't work.  The Testsand notifier reference is the same and hadled the same way.  I have included my example files with the 2 situations in seperate sequences files.
    Thanks in advance to the person who will be able to enlight me.
    Nien 
    Solved!
    Go to Solution.
    Attachments:
    New Thread Or Dynamic Call.zip ‏41 KB

    Hello Nien,
    This isn't a TestStand issue.  I suggest you take this to the LabVIEW forum.  Looking over your code your Notifer and Forget.vi is dependent on the notifier.vi.  So it's not necessarily anything wrong with the sequence steps but actually within your LabVIEW code itself.  One suggestion is to insert a simple error handler.vi in your Call Notifier and Forget.vi.  You have error wires connected to the functions itself, which is good practice but you don't have anything to inform you if an error occurs or not.  I would suggest you to run try to debug your LabVIEW code, such as using highlight execution, while you're running your code so you know where exactly the error is happening.  
    Thanks,
    Jonathan R.
    Applications Engineer
    National Instruments

  • Wait on Asynchronous Call - why so long?

    LV 2013, Win7
    I have a window which comes and goes, during program operation.
    This window has 72 subPanels, each containing a reentrant copy of the same VI for a "block".  I insert the VI in the subpanel, and then run the VI with a CALL and FORGET call.
    When the user closes the window, all the block VIs terminate, and the window closes.  I don't care if the closing behind the scenes still goes on after the window disappears.
    But when the user QUITs the program, with this window up, I need to make sure that all the block VIs have terminated before I shut down other things (close files, etc).
    To that end, I changed the CALL and FORGET to a CALL and COLLECT operation, and installed a WAIT ON ASYNCHRONOUS CALL for each instance at the end of the big window code.  This is after the blocks have been commanded to die (via an event).
    I see from the debugging file (a portion is pictured) that it takes over 1000 mSec to wait for all the instances to die.
    The thing is, if I change that "0" to "1000", then what I would expect is that the actual waiting time would drop to < 100 mSec.
    My thinking is that during that timed wait, the blocks would be dying anyway, so it would take less time to actually wait on them.
    But when I do that, nothing really changes.  The listed time is still over 1000 mSec.
    If I limit the number of blocks to 12, the time is 97 mSec, for 24 it is 185, for 36 it is 576, and so on - it's proportional to the number of blocks.
    So, what is really happening?  If it's just waiting on things to die, why doesn't the timed wait affect the numbers?
    I originally  (when I used CALL and FORGET) kept track of how many were opened and how many were closed and waited until that became zero, but this is a cleaner way of doing it, at least in theory.
    Am I missing something?
    Steve Bird
    Culverson Software - Elegant software that is a pleasure to use.
    Culverson.com
    Blog for (mostly LabVIEW) programmers: Tips And Tricks
    Solved!
    Go to Solution.

    Have you checked how long the first loop of the For loop takes, versus all of the others?
    So I tried that, several times - the pattern is the same as shown here.  The first few lines are from the blocks themselves, it's the last thing they do.
    Looks like there's ONE case where there's a bigger delay than expected,  All told, this takes about 600 mSec.
    Maybe the debugging process affects that (* waves to Mr. Heisenberg * )
    The 300-400 mSec is back to where I first saw this delay.  Apparently the unreleased refs clog up the system enough to drive it up to 1000 (or 2000 mSec as I saw in one case).
    Still, I don't understand why a timed delay ahead of the WAITS doesn't affect the WAIT time.
    But I guess that's not important.  It must be actually doing more work than simply asking "is it dead yet?"
    Steve Bird
    Culverson Software - Elegant software that is a pleasure to use.
    Culverson.com
    Blog for (mostly LabVIEW) programmers: Tips And Tricks

  • How can we tell if a VI is already running before calling Start Asynchronous Call?

    The new Start Asynchronous Call node is awesome for spawning multiple instances of reentrant VIs.  However, I've stumbled a bit in using it for non-reentrant VIs.  The old practice of using the "Run VI" method would allow us to check the Execution.State of the VI before invoking the method to run it.  That way if the State was Running or Run Top Level, we could skip the invoke node and just use a property node to open its front panel.  WIth the Start Asynchronous Call node, it looks like we have to use a strictly typed static VI reference, and when we open the VI reference, the VI gets reserved and its Execution.State = Running.  So, how can I tell if it is not just reserved by the thread but actually executing before making a redundant Start call?
    By the way, the redundant Start has interesting behavior.  It will actually cause the targeted VI to be executed again after it stops.  Even if you hit the Abort button on the target VI, it will immediately execute again and again equal to the number of times the Start Asynchronous Call node was run.  There's nothing wrong with that, and I suppose the simple answer is to just go back to using the old "Run VI" method.  It's just that the ability to wire up those inputs directly to the connector pane is so nice.  Perhaps I am missing something obvious.  Oh, I am referring to the Call and Forget mode (0x80).
    Thanks,
    Dan
    Solved!
    Go to Solution.

    Just throwing it out there, I know I'm a year.5 late on this but if it's a psuedo-modal dialog or some other window that you only want a single instance visible at one time, you can check the FP.State property on the strictly typed vi reference. If it's loaded and visible to the user it will be "Standard", if it was closed or not opened prior then the state will be "Closed".
    I think the standard behavior of serializing execution on another thread would be great for doing a pre-set number of iterations with a sub vi in a non-blocking sort of way but for sub vi's meant for UI interaction checking FP.State works.
    Philip
    CLD

  • Unexpected loop behaviour with asynchronous call

    I am having trouble with loop behaviour when using an asynchronous call.
    I am building an application to record simultaneously temperature (NI USB-TC01 thermocouple), displacement (DC voltage, read from an Agilent 34401a) and resistivity (using a Keithley 2400 sourcemeter).
    I am using a voltage sweep function on the Keithley 2400 to alternate current direction in a sample and measure the voltage drop - this is a common technique for eliminating thermal emf from resistance measurements. But what you need to know is that I set the number of current cycles I want and then wait for the instrument to measure and return the meausurements - up to 50 samples, which takes nearly 30 seconds. With the other two measurements, I have to programmatically call a measurement vi for each sample I want.
    I have set up my application to asynchronously program the resistivity measurement and then wait for the response, and I want to in parallel measure temperature and position until the resistivity is done. I then want to record the mean and standard deviation for each signal. I used an event structure to interrupt the temperature and position measurements when done.
    The problem I am running into is that after the first resistivity measurement is completed and I go to do the second one, the loop that measures temperature and displacement only runs twice, so I only get two samples, regardless of how many resistivity samples I want to collect. For example, if I want 50 resistivity samples at a time, the first iteration will measure rougly 40 samples of temperature and displacement, but any subsequent iterations will only measure twice.
    I know this is probably overwhelming to understand the operation, but can anyone help? I have attached my code ('Delatometer') as well as a test vi I built that uses the same structure but has no interactions with instruments ('asynchronousCall').
    The
    Attachments:
    Delatometer.zip ‏221 KB
    asynchronousCall.zip ‏29 KB

    I forgot to mention...the test vi that I uploaded executes as expected, so I am thinking that maybe its an issue with the instrument calls? I also found that if I run the Delatometer program in 'highligh execution mode' it runs properly, and it is my understanding that in 'highlight execution mode' there is no multi-threading.

  • Asynchrono​us Call - collect values without waiting for sub VI to finish executing

    Hi All, I'm relatively new to LabVIEW and for the first time I'm attempting to make use of Asynchronous calls in a program.
    What I would like to accomplish, generally, is this: At the beginning of the main vi, begin running a sub-vi in the background. This sub-vi is collecting streaming data from an instrument with a refresh rate of 50Hz. At various points in the main vi I would like to call the instantaneous value of that streaming data from the sub vi, passing it back into the main vi, while allowing the sub-vi (the streaming data collection) to continue running. The reason for this, is that I need to collect the data from this instrument many times wihtin a loop, and the connection initialization to the streamin data instrument is both slow and faulty, and takes too long if I have to initialize the connection, collect the data, close the connection, each time I wish to collect the data. I would prefer to initialize the connection once at the beginning, have a stream of continuous data being collected in the background, and then at certain points within the main vi loop, query that streaming data for its instantaneous value, but allow the streaming data sub vi to continue running.
    I recognize that a method to allow the streaming data collection sub vi to run in the background is to use the Asynchronous call method - however, to collect the data I need to use an asynchronous wait, which will only collect the data if the streaming data sub vi finishes executing. How can I collect the data at a particular instant while still allowing the subvi to keep running (thereby minimizing the number of times the connection to the instrument needs to initialized)?
    Any suggestions or alternative methods would be great!
    Thanks
    Jason

    This is typically solved in a different way than what you envision. Have your parallel deamon post its current values to a buffer. This could be a global variable (gasp!!) or an intelligent global variable (a VI with loop that executes always once and has an unitialized shift register that can either be initized or read based on a control input). You can add extra code to the read and write selection such as scaling etc to turn the intelligent global into an action engine that does extra things on its different methods.
    Rolf Kalbermatter
    CIT Engineering Netherlands
    a division of Test & Measurement Solutions
    Attachments:
    Intelligent Global.vi ‏19 KB

  • Asynchronous calls in BEA CORBA

    Hi all,
    from what we know it is possible to asychronous calls with CORBA via those methods
    - AMI
    - Notification Service
    - one way request
    I dont see in the current version of BEA Tuxedo (8.1) that AMI is supported .
    Notification Service is available , but it seems that the channel is one blocking
    process. Therefore I have doubts re performance.
    Are one way requests blocking or unblocking ? Accorsing to the documentation BEA
    is recommending those because of the lack of quality of service and scalability
    issues.
    What is the best way to do asynchronous calls with BEA Tuxedo CORBA ?
    Any hints ?
    Thanks,
    Iris

    What you are proposing makes good sense. The problem with
    asynchronous communication is the problem with errors. The
    typical send and forget many asynchronous systems use leads to
    serious reliability problems. About the only way to guarantee
    reliability is to use a transacted queuing mechanism such as
    /Q. Using CORBA for external communication and ATMI inside
    seems like a reasonable approach. You may run into difficulties
    though if you need a single server to be both an ATMI server
    and a CORBA server. I'm not certain that is supported. In your
    case though it sounds like you'll have a CORBA server that is
    an ATMI client and that should work.
    Regards,
    Todd
    "Iris Peters" <[email protected]> wrote:
    >
    Hi Todd,
    the system we are investigating is already using ATMI and /Q. The client
    has got
    a system which is based on the pipeline principle which is asynchronous.
    Our client
    would like to know if this system if appropriate for using asynchronous
    CORBA
    messages inside and not ATMI anymore . There are also ideas to use CORBA
    to interface
    with external systems.
    Our suggestion is to just use CORBA to interface from and to external
    and leave
    the ATMI stuff as it is amd maybe just provide a CORBA wrapper for the
    ATMI calls
    to external.
    Regards,
    Iris
    "Todd Little" <[email protected]> wrote:
    Tuxedo does not provide AMI. Besides the alternatives you listed,
    one can also use the Dynamic Invocation Interface to acheive
    deferred synchronous behavior. Can you describe what it is you
    are trying to accomplish and how you see asynchronous messaging
    helping you?
    An alternative might be to use ATMI and use Tuxedo's /Q mechanism.
    Regards,
    Todd
    "Iris Peters" <[email protected]> wrote:
    Hi all,
    from what we know it is possible to asychronous calls with CORBA via
    those methods
    - AMI
    - Notification Service
    - one way request
    I dont see in the current version of BEA Tuxedo (8.1) that AMI is supported
    Notification Service is available , but it seems that the channel is
    one blocking
    process. Therefore I have doubts re performance.
    Are one way requests blocking or unblocking ? Accorsing to the documentation
    BEA
    is recommending those because of the lack of quality of service andscalability
    issues.
    What is the best way to do asynchronous calls with BEA Tuxedo CORBA?
    Any hints ?
    Thanks,
    Iris

  • Is there a way to process multiple asynchronous calls individually (instead of all at once)?

    Hello,
    I have a function that saves a record using a RPC call (asyncToken with a new responder).  When I save an individual record (pressing "s" key), it works fine.  However, when I attempt to save multiple records simultaneously (bound to "v" key) (I have a for loop running through the selectedItems in the datagrid), it performs strangely.
    For anyone who hasn't experienced this, the successive calls seem to get stacked (literally - i.e. using a stack) and processed at the end of all operations in that block of code (I had trace functions before and after the call that were executed before I saw the result confirming this).
    What I would like to do is to simulate multiple AsyncToken usages with a single click, but still have them all occur individually since right now, the function saves the last item in the stack 8 times instead of saving each of the 8 items separately.
    OR
    Is there another means of RPC using something like "interruptToken" as opposed to asyncToken?  (In most other areas I've seen, asynchronous calls are performed as interrupts and dealt with immediately, thats why this procedure confused me for a bit)
    Thanks in advance,

    The second paragraph you posted is definitely worthwhile - still figuring out some of the inner workings of Flex calls (not just RPC stuff) that I use as I am pretty new to flex.
    I don't have the code with me at the moment, but I think I have to use separate calls to the save function.  My situation is this (and I plan on updating with code on Monday if necessary):
    I have a datagrid that is populated using a single RPC (which is loaded into an arrayCollection first then the datagrid).  Changes are made to the datagrid through a copy/paste function that I made, but these changes are only reflected on the datagrid (i.e. not in the dataprovider).  When the user hits "save", the selected line (selectedItem actually - i.e. not an index but the object itself) is passed to another class which contains a modified version of my "modify data" function (brings up a dialog after choosing a given line allowing editting/validation of certain fields regarding the selectedItem).  This changed version of "modify data" is then called and immediately closed effectively saving this record (without allowing the user to alter fields - so they don't have to hit save twice).
    With the copy/paste function, I make all of these changes en masse and then have a loop that goes something like
    for each (_object:Object in myDatagrid.selectedItems)
         callSaveFunction(this, _object);
    which ideally loops through the data and saves each item that has been changed.  If there is a way to save all of the data in the datagrid simultaneously, I would appreciate a bit of help there (perhaps dealing with the bindings - right now I have the object I save as the destination and the source is myDatagrid.selectedIndex.[field name]).
    Good to know about the other stuff, though - my understanding was a little bit lacking before

  • Error in calling collection procedure.

    Hi Experts,
    In a package I have one procedure "setscores_ram_bulk" with collection varaiavles.
    And other two procedures are "UpdateRelatedOrders" and "SetGeoFraudScore" with out collections.
    I am calling collection procedure "setscores_ram_bulk" in non collection procedures "UpdateRelatedOrders" and "SetGeoFraudScore".
    I am getting the below error.
    PLS-00306:wrong number or types of arguments in call to 'SETSCORES_RAM_BULK' .
    I am sending my code.
    CREATE OR REPLACE PACKAGE GAFT_PROG_DIT.INTERNAL_SCORING_setscore_Bulk
    IS
    TYPE rec_setscores IS RECORD
    pBUID     score.buid%TYPE,
    OrderNum   score.order_num%TYPE,
    ScoreType  VARCHAR2(100),
    p_Score       score.velocity_score%TYPE
    type pp_rec_setscores is table of rec_setscores index by pls_integer;
    PROCEDURE UpdateRelatedOrders (pBUID IN NUMBER, OrderNum IN VARCHAR2);
    PROCEDURE SetGeoFraudScore (pBUID         IN     NUMBER,
                                   OrderNum      IN     VARCHAR2,
                                   ZipCode       IN     VARCHAR2,
                                   CountryCode   IN     VARCHAR2,
                                   score         OUT NUMBER);
    PROCEDURE setscores_ram_bulk (p_rec_setscores  pp_rec_setscores);                              
    END;
    CREATE OR REPLACE PACKAGE BODY GAFT_PROG_DIT.INTERNAL_SCORING_setscore_Bulk
    IS
       PROCEDURE UpdateRelatedOrders (pBUID IN NUMBER, OrderNum IN VARCHAR2)
       IS
          tScoreID    STAGING_ORDER_DATA.SCORING_ID%TYPE;
          tVelocity   SCORE.VELOCITY_SCORE%TYPE;
          tNegative   SCORE.NEGATIVE_SCORE%TYPE;
          tTrend      SCORE.TREND_SCORE%TYPE;
          CURSOR scoreCursor (
             scoreID    NUMBER,
             OrdNum     VARCHAR2)
          IS
             SELECT ORDER_NUM
               FROM STAGING_ORDER_DATA
              WHERE     SCORING_ID = scoreID
                    AND ADDRESS_TYPE = 'S'
                    AND ORDER_NUM != OrdNum;
       BEGIN
          SELECT SCORING_ID
            INTO tScoreID
            FROM STAGING_ORDER_DATA
           WHERE BUID = pBUID AND ORDER_NUM = OrderNum AND ADDRESS_TYPE = 'S';
          IF tScoreID IS NOT NULL
          THEN
             SELECT VELOCITY_SCORE, NEGATIVE_SCORE, TREND_SCORE
               INTO tVelocity, tNegative, tTrend
               FROM SCORE
              WHERE BUID = pBUID AND ORDER_NUM = OrderNum;
             FOR ord_rec IN scoreCursor (tScoreID, OrderNum)
             LOOP
                setscores_ram_bulk (pBUID,ord_rec.ORDER_NUM,'V',tVelocity);
                setscores_ram_bulk (pBUID,ord_rec.ORDER_NUM,'N',tNegative);
                setscores_ram_bulk (pBUID,ord_rec.ORDER_NUM,'T',tTrend);
             END LOOP;
             IF scoreCursor%ISOPEN
             THEN
                CLOSE scoreCursor;
             END IF;
          END IF;
       END UpdateRelatedOrders;
        PROCEDURE SetGeoFraudScore (pBUID         IN     NUMBER,
                                   OrderNum      IN     VARCHAR2,
                                   ZipCode       IN     VARCHAR2,
                                   CountryCode   IN     VARCHAR2,
                                   score            OUT NUMBER)
       IS
          tZipCodeExist   NUMBER;
          tScore          NUMBER;
       BEGIN
          SELECT COUNT (Score)
            INTO tZipCodeExist
            FROM MASTER_GEO_FRAUD
           WHERE REPLACE (UPPER (ZIP_CODE), ' ', '') =
                    REPLACE (UPPER (ZipCode), ' ', '')
                 AND COUNTRY_CODE = CountryCode;
          IF tZipCodeExist > 0
          THEN
             SELECT Score
               INTO tScore
               FROM MASTER_GEO_FRAUD
              WHERE REPLACE (UPPER (ZIP_CODE), ' ', '') =
                       REPLACE (UPPER (ZipCode), ' ', '')
                    AND COUNTRY_CODE = CountryCode;
          ELSE
             tScore := 1000;
          END IF;
    setscores_ram_bulk (pBUID,OrderNum,'XS',tScore);
          COMMIT;
          score := tScore;
       END SetGeoFraudScore;
       PROCEDURE setscores_ram_bulk (p_rec_setscores pp_rec_setscores)
       IS
       BEGIN
          FORALL i IN 1 .. p_rec_setscores.COUNT
             MERGE INTO   score s
                  USING   (SELECT   p_rec_setscores (i).pBUID buid,
                                    p_rec_setscores (i).OrderNum order_num,
                                    p_rec_setscores (i).p_score score
                             FROM   DUAL) p
                     ON   (s.buid = p.buid AND s.order_num = p.order_num)
             WHEN MATCHED
             THEN
                UPDATE SET
                   velocity_score =DECODE (p_rec_setscores (i).ScoreType,'V', p.score,velocity_score),
                   negative_score =DECODE (p_rec_setscores (i).ScoreType,'N', p.score,negative_score),
                   trend_score =DECODE (p_rec_setscores (i).ScoreType,'T', ROUND (p.score),trend_score),
                   vendor_combined_score =DECODE (p_rec_setscores (i).ScoreType,'X', p.score,vendor_combined_score),
                   vendor_bt_score =DECODE (p_rec_setscores (i).ScoreType,'XB', p.score,vendor_bt_score),
                   vendor_st_score =DECODE (p_rec_setscores (i).ScoreType,'XS', p.score,vendor_st_score)
             WHEN NOT MATCHED
             THEN
                INSERT  (buid, order_num, received_date_time)
                    VALUES  (p.buid, p.order_num, SYSDATE);
          FORALL i IN 1 .. p_rec_setscores.COUNT
             MERGE INTO   score_filter_apply s
                  USING   (SELECT   p_rec_setscores (i).pBUID buid,
                                    p_rec_setscores (i).OrderNum order_num,
                                    p_rec_setscores (i).p_score score
                             FROM   DUAL) p
                     ON   (s.buid = p.buid AND s.order_num = p.order_num)
             WHEN MATCHED
             THEN
                UPDATE SET
                   velocity_score =DECODE (p_rec_setscores (i).ScoreType,'V', p.score,velocity_score),
                   negative_score =DECODE (p_rec_setscores (i).ScoreType,'N', p.score,negative_score),
                   trend_score =DECODE (p_rec_setscores (i).ScoreType,'T', ROUND (p.score),trend_score),
                   vendor_combined_score =DECODE (p_rec_setscores (i).ScoreType,'X', p.score,vendor_combined_score),
                   vendor_bt_score =DECODE (p_rec_setscores (i).ScoreType,'XB', p.score,vendor_bt_score),
                   vendor_st_score =DECODE (p_rec_setscores (i).ScoreType,'XS', p.score,vendor_st_score)
             WHEN NOT MATCHED
             THEN
                INSERT (buid, order_num, received_date_time)
                    VALUES   (p.buid, p.order_num, SYSDATE);
       END setscores_ram_bulk; 
       END;
       /Please help me.
    Thanks in advance.

    BluShadow wrote:
    Paul  Horth wrote:
    You haven't taken any notice of what Alberto posted in {message:id=11026562} I see.
    Why should anyone bother helping you if you never think we have answered your questions?Indeed, that must be a new record:
    >
    Total Posts: 336
    Total Questions: 160 (160 unresolved)
    >
    Out of 160 questions... none of them have been resolved.
    That's either down to poor answers (very unlikely with the amount of experts around) or poor questions (quote likely) or sheer laziness on feeding back on answers and marking questions as answered when they have been (most likely).Indeed, your own post just after Alberto's seems to sum it up :-)

  • Notify an application user that an asynchronous call of a bi publisher report has been completed

    Hi experts,
    We have an ADF application (11g) from where we call BI Publisher (11g) reports by using bi publisher web services.
    I have the following 2 requirements:
    Run the reports asynchronously
    Notify each user that the report which has been asynchronously called has been completed.
    My thought was to use the scheduleReport web service which is asynchronous by default.
    My problem is how to notify only the specific user using "http notification" that the report is ready.
    http://docs.oracle.com/cd/E28280_01/bi.1111/e22259/reporttriggers.htm#BIPDV008
    Can you please help me on this?
    Regards,
    Dimitris

    I've converted the Blob to a Clob but still can't get it to appear in the BI Report. It shows up in the XML file as a bunch of text character, but in the report if I use the fo: instructions it remains blank, and if I don't, it shows the same text data that is in the XML file.
    Perhaps BI Reports aren't meant to show database images? Is there another tool I can use instead (data is in APEX 4.0) 11g.?

  • Asynchronous call in OSB

    Hi, I was trying to call a business service in an asynchronous way. I used publish action but I can´t get the response of the service. It seems it just work with one-way services like a file adapter. Any help please.

    When you say you are making an asynchronous call, then you would not care about the response.
    If you are looking for a response from the service then you should use a service callout instead.
    Let me know if my understanding is incorrect.
    Thanks,
    Patrick

  • SOAP Receiver Adapter (Asynchronous Call)

    Hi All,
    Scenario is  Proxy to Webservice asynchronous call.
    Scenario configuration is done as follows.
    1) Imported the WSDL and using as a asynchronous inbound interface.
    2) SOAP receiver channel is configured with the target URL & soapAction as given in the WSDL as (soap address & soap Action).
    3) Configured the proxy server details as required.
    SOAP channel is successfully sending the message to the application as DLVD.
    But the issue is target application  not receiving the data. What could be the reason ? I am wondering , i have tried with the external tool like Altova XML Spy & SOAP UI  sending data to the webservice & it's  working fine.
    Please suggest me if anything which can help to resolve this issue.
    Thanks
    Ashwin

    In this case you can do the following:
    1. start your tcpmon or TCPGateway, add there a listener e.g. on port 9090
    2. configure the target URL in TCPGateway for this listener
    3. configure the target URL in your XI SOAP Receiver Adapter to http://<ip of TCPGateway>:9090
    4. now execute the scenario again in XI
    (make sure XI can reach your TCP Gateway, e.g. check Proxy)
    I have used this method successfully for error tracking. In some cases it is necessary to add 2 listeners in TCPGateway and route e.g. 9090 to 9191 and from there to the end (I did not analyse why).
    Then you will be able to see what XI is really sending and you will see the full response from the partner side. You can then compare the XI request data with those which are sent via soapUI. This should give a clue about the problem.
    CSY

  • How to move files in background (asynchronous call)?

    Hello
    I would like to make an an Asynchronous call to the Move.vi for moving files as a background process.
    I am having the following problems:
    - The static VI Reference as input to the Open VI Reference function asks for a path to the VI to be called, but I can't find it. Where exactly is Move.vi located?
    - The Type Specifier VI Refnum node accepts VIs via drag and drop, but only from an explorer window, not from the LabView VI palette. Again, I need to know where to find Move.vi. Or is there another way to specify the connector pattern?
    It all works, if I call Move.vi from within a wrapper VI (because I know where to find that), but for the sake of simplicity I would like to avoid that step.
    I'd appreciate any suggestions, also alternative approaches for moving files in the background.
    Sebastian

    Move is not a VI, but a primitive, so you can't call it like that. As you've seen, the wrapper method works.
    Try to take over the world!

  • Problem about asynchronous call: subVI front panel doesn't pop up when called.

    Dear All,
    I'm new to LabVIEW, and this is the first time I try to use the asynchronous call.
    I'm using LabVIEW 2011.
    I want to build a directory for several VIs, and it should allow users to open more than one of the VIs at the same time by pushing the buttons. Before building this directory, I simply tried to use asynchronous call to call a VI form another VI, but found a big problem.
    I followed the steps in the help file, created a strictly typed reference, set the option to x80 because I don't need the return. When I run it for the first time, it worked fine: the subVI popped up and run. Then I closed the subVI. But for the sencond time and on, when I run the caller VI, the subVI didn't pop up, instead it seemed to run silently on background because when I manually opened it from the file I found it running. Besides, I didn't find any option like "show front panel when called" of the asynchronous call.
    The caller VI and subVI are attached. The address of subVI in caller VI should be changed accordingly.
    What should I do to make it work properly? Thanks very much for  any idea!
    Solved!
    Go to Solution.
    Attachments:
    asynchronous_call.vi ‏8 KB
    boolean.vi ‏7 KB

    Jeff·Þ·Bohrer wrote:
    A better approach is to set the vi properties programaticly like this:
    Jeff, you will be happy to know that I used this tactic in full force on a project recently (lots of dialogs in this program).  Not sure how many LabVIEW reboots it has saved me from.  Reuse VIs made it even easier to do.
    There are only two ways to tell somebody thanks: Kudos and Marked Solutions
    Unofficial Forum Rules and Guidelines

  • Asynchronous call to web servie using pl/sql

    1) How do I make an aynschronous call uisng pl/sql. I am currently using utl_http.
    But it is expecting me to get repsonse using utl_http.get_response.
    Is there anyway I can make asynchronous call to web service? Please give me examples if any.

    Web services are NOT asynchronous as the HTTP application protocol is not asynchronous. A web service cannot (as an sync callback event) initiate a call to the web browser (client app) - as the web browser does not have a tcp listening endpoint. The web service must respond using the EXISTING tcp session established via a connect() call from the browser.
    PL/SQL code executes in a dedicated or shared server process. Execution is serialised. So asynchronous calls are not supported and non-existent. Again, async processing requires some from of notification (callback event, message handler or signal interrupt handler) to inform the main process  (while it is executing code), that the async call has completed.
    And this does not exist in PL/SQL processing for very good reasons. (Oracle would have been one of the most unstable products on the market if it did support async PL/SQL processing, as 99% of developers would not understand how to use it correctly, and would have severely violated the fundamental concurrency and MVCC principles)
    What can be done via PL/SQL (and SQL) is parallel processing - not to be confused with async processing. The API in PL/SQL to use for that is DBMS_PARALLEL_EXECUTE. You can also self roll this using DBMS_JOB or DBMS_SCHEDULER.
    No default IPC exists for inter process communication between parallel processes. If IPC is needed, it needs to be manually coded using a standard SQL table (where row locking provides for mutexes and semaphores), or something like DBMS_PIPE.

Maybe you are looking for