LabVIEW
Generate user events by name?
Solved!
Hi,
When I generate a user event the event name is equal to the label of the input data type. Example: the user event name will be "Tray closed"
The events are bundled into a cluster.
Just for the example sake lets say I need to create 1000 user events. Its quite easy to create a cluster with 1000 event refnum and name them correctly so the event structures registering to these event will know the event name and datatype.
The problem is creating the 1000 user event refnums. I couldnt find a way except to copy the create user event node 1000 times and rename the boolean. Like this:
Assuming that the datatype is always boolean and I have a list of event names is there a way create the events in a for loop?
Thanks.
You can make 1 event that has a cluster with a string and the type.
Even better replace the string with an enum type def.
Optionally (not an improvement per se) replace the Boolean with a variant. nOw you can send anything.
Alternatively, you can make a container (a map would work nicely) with the strings and user event references.
Upside of keeping the map vs 1 event, is that you can register for individual events (efficient).
Downside of keeping the map vs 1 event, is that you have to register for individual events (more code).
Search LabVIEW like a graph!
@1984 wrote:Assuming that the datatype is always boolean and I have a list of event names is there a way create the events in a for loop?
You could try to script this.
I don't think it will be as convenient as you'd think.
Anything more than 2 you want to use arrays and loops, not copies.
@1984 wrote:I hope now my original intent makes more sense. Also wondering what are the other sensible ways to handle the scenario. I think events would be nice, but sure that others solved this in different ways as well.
It confirms how I read your initial question.
The answer is the same.
You'll have to either
+ throw everything in one event, and then you'll get all events and filter them based on the data, or
+ manually create the events
Of course you can mix...
The only thing manually created events give you is the name of the event in the event structure.
If you make a map of events, with the name as a string, you can dynamically register for only the desired events. If the event also has an ID (string\enum) you can register n times for individual events, or 1 time for n events. In the event structure, you'll get only individual events you register for, and than use the id to filter. This is more or less required, as the event name isn't useful.
You can actually make a bin of events, and amend the name of the registered event with a cluster (if there's >1 element):
This is cumbersome though. If you put the code in a subVI, you'll often not get updates, and it can get quite confusing.
Perhaps this article may help:
http://www.notatamelion.com/2016/03/22/dynamic-udes-the-power-for-reentrant-processes/
You could do this by creating an array of user events, one per Digital Input or whatever, and "naming" them with an enum that you use as an indexer for the array of events.
Proof of concept:
If you run this you will see that one loop each fires for DI 0 and 2, both loops fire for DI3, and none fire for DI1.
All events do have to share one case inside of the event handler, but it's trivial to just pass the enum into a case structure and put the code for each separate digital input in that structure, which is then named for each value change that it cares about, and should never fire for any digital changes that particular subVI doesn't care about.
@Kyle97330 wrote:
You could do this by creating an array of user events, one per Digital Input or whatever, and "naming" them with an enum that you use as an indexer for the array of events.
Proof of concept:
If you run this you will see that one loop each fires for DI 0 and 2, both loops fire for DI3, and none fire for DI1.
All events do have to share one case inside of the event handler, but it's trivial to just pass the enum into a case structure and put the code for each separate digital input in that structure, which is then named for each value change that it cares about, and should never fire for any digital changes that particular subVI doesn't care about.
That will get slower and slower when you add events.
There are going to be a few hundred. It might add up. Of course, you could use a map just like you've used an array. It will still get slower and slower, but at log(O) in stead of (O).
You'd also have to distribute all user events to all event structures, while for previous solutions only the registration needs the specific user event . No problem if it's all contained in a class of course, but it might be restrictive.
You are limited to an array of Boolean user events. If you ever want to add another data type, you won't be able to build the array.
You'll not have the name of the event in your event structure... But that's (practically) not achievable at all anyway.
You can actually make a bin of events, and amend the name of the registered event with a cluster (if there's >1 element):
This is cumbersome though. If you put the code in a subVI, you'll often not get updates, and it can get quite confusing.
While this is not a 100% solution to my problem it still helped me a lot to simplify the task so it is definitely worth to be marked as the solution.
See my implementation on the snippet below. Yes, the cluster has to be generated manually but that hell lot easier to do than to copy the create user event part of the code. Also if once I'll really need 1000 events then scripting the generation of the cluster is also a lot easier than generating a VI with 1000 VIs.
Thanks!
