LabVIEW
Some User Events Are Not Triggering Across Different LabVIEW Libraries
Solved!
Thank you for your response.
In my application, I create and register all the User Events only once in the Main Launcher during initialization. As shown in the attached block diagram, I call Register For Events there and then pass both the User Event Refnum and the Event Registration Refnum to the different libraries that require them. None of the libraries create or register the events again.
The Event Structure in the consumer library uses the same Event Registration Refnum that was created in the Main Launcher.
@JÞB wrote:
You have accidentally created a queue with 1 source and N readers for your User Event.
You can prove this to yourself by using the Event Inspection Window! That tool is underappreciated but helpful when you repeatedly shoot yourself in the foot.
I won't go so far as to say "Never branch a User Event Refnum Wire!" There may actually be times when you want a single User Event to take an if, then Else action so, LabVIEW allows this syntax. It is on the developer then to ensure exactly 1 Event Structure registered for the same User Event Refnum is actually active.
Actually it is entirely possible to envision creating multiple handlers for the same user event registration. And as long as you don't care which handler is going to handle the event, but simply that exactly one of them is going to do that, it's not a problem. Possible reasons to do so could be that handling a specific event may be a lengthy process but that new events arriving should still be handled timely.
I would be slightly hesitant to do it in this way however as I could imagine that this use case is not very thoroughly exercised and tested and might result in an occasional race condition that could either result in an event being lost, processed twice or maybe a simple crash. The more proper solution would be to have one event receiver that spawns a new self terminating task for each incoming event.
Also, it is an obscure use pattern that future programmers on that application will most likely struggle to understand properly. And that future programmer quite easily could be the original programmer too.
Another gotcha to watch out for is of course about the lifetime of LabVIEW refnums. Creating refnums in a launcher that terminates after the real application got activated is the main problem many users run into when starting to build larger applications. Refnums only survive for as long as the top level VI in whose hierarchy it was created stays active. Once that top level VI terminates, all refnums created in its hierarchy are automatically collected and destroyed. For user events this can be extra problematic since the user event may have been created in such a hierarchy while the user event registration was correctly created in the current hierarchy, but when the original user event gets deallocated the registration is for a now invalid event and never will receive an event again.
Named refnums like Queues and Notifiers can alleviate that problem as the actual object is only deallocated when the last refnum to that object gets deallocated, but User Events and their registration are not named objects.
Thank you for the explanation. In my application, the launcher remains running for the entire lifetime of the application, so the User Event Refnums should remain valid.
Also, I've ensured there is sufficient time between consecutive Generate User Event calls.
What I'm observing is that some Event Structures receive the User Event correctly, while a few others never receive that same event. This behavior is consistent.
Given that, would you suspect an issue with the event registration itself (for example, some Event Structures not actually being registered for that specific User Event), rather than the lifetime of the User Event Refnum?
Is there any recommended way to verify that an Event Structure is actually registered for a particular User Event, or to inspect the contents of an Event Registration Refnum for debugging?
