Maksim Kuznetsov

Hello, when trying to install version 2.0.8.152 for LabVIEW 2023 Q1 (64-bit) I am getting the following error: Could it be the 64-bit LabVIEW?

I have an OPC actor to which I can subscribe for channel data change events. Channels are strings. However after some time I realised that using strings was not that convenient, especially if one of the channel names changes. So, I decided to create an enum of all OPC channels and subscribed in the following way: This approach allowed me to leave the OPC actor unchanged. Then this is how I handle the events: Now if need to change the OPC channel name, I can just change it in the typedef without touching anything else. Also writing/reading channels (separate messages supported by OPC actor) is convenient using an enum converted to string.

Hello James, Another short question from me. Are you planning to return the "attachment" feature for the outer-envelope? I remember using it for some time, but after installing the latest messenger library it seems to be gone. Thank you! Max

Thank you for sharing your opinion on using parent classes for actor references to prevent unwanted code coupling! I will use Send class. That would be great, really looking forward to these changes. ____________________________________________________________________ If I ask too many question, please tell me! But I have another one. I use TCP messengers quite often to send messages and subscribe. That works perfect! However today I tried to send a local queue in a message for the receiver to reply when asynchronous action is finished: The problem here is that I shared messenger references between 2 application instances which is not allowed. This approach works in the same application instance. I was wondering, is there a way to make the code above work across multiple application instances? I tried to create a TCP server instead of the "action result" queue, but that doesn't seem to work.

Hello everybody, I am currently cleaning up my projects and thought of the way that could potentially reduce the amount of things loaded in the development environment. This is the architecture used at the moment: Actor named "Main" launches actors A, B, C, D, E. The last actor E is launched and requires addresses of C, D. I pass these addresses (C, D) as specific actor references. That means that if I want to debug just actor E, the development environment will load actors C, D as well. And if one of them is broken, actor E will appear broken as well (even if I don't want to test functions related to C, D). Idea: Instead of passing specific actor references to actor E, I can use generic references for C, D (Actor type 2\Actor type2.lvclass) in actor E. Then if I want to work on actor E, actors C, D won't be loaded. _______________________________________________________________ Before implementing this idea for my project which will take substantial time, I would like to hear your opinion on this. Maybe I am missing something. Thank you in advance!

Thank you for your feedback. The honest reason why I am asking is a hope that someone will tell me which approach from many is the better one. Every now and then I am having a dispute over this with my colleagues and I am always saying that typedefs create additional coupling, but I realised that I never understood what it actually means, it was like a rule I used throughout my projects. Now I am not sure if I was right or wrong, clearly I have a lack of knowledge. Maybe someone can share their approach and reasons behind it? Thank you!

Hello James, There is a concept I am struggling to get my head around. For a long time I am following a method of not having typedefs in messages. Messages can contain various data and to make sure that the message is constructed correctly I have to consult the actor and copy the structure from it. Same applies for messages received. I believe this is called "zero-coupling". 1. If I am adding the actor reference to the VI, it brings all the dependencies of the actor to project, so I am becoming coupled to that actor, isn't it? (it is not like some generic reference) 2. Why in this case it is not advised to use actor's typedefs in messages (this could save time and less errors would appear during development)? 3. There is another method - to have a SubVI instead of typedef that will do the job of constructing (deconstructing) the message. But how is this different from using a typedef? SubVIs will also create more coupling. I have a feeling that my understanding of coupling is not full. It would be great to hear your thoughts about these points. Thank you! Kind regards, Max

Thank you once again Dr. Powell for sharing this powerful approach. I can see it being used in "Metronome" actor (e.g. Set Period). And I already started to use it in my projects. If you don't mind I would like to ask you another question: I have an actor (A) that launches a sub-actor (B) to delegate some tasks to it. When sub-actor (B) publishes an event, actor (A) gets a message. However I would like to publish that message beyond actor (A). So that actors subscribed to actor (A) would also receive events from sub-actor (B). Currently my approach is to send Observer Registry of actor (A) to sub-actor (B) during initialisation. Then sub-actor (B) publishes its events into Observer Registry of actor (A) directly. Another idea was to republish the event from actor (A) when it gets the message from sub-actor (B). Neither of these methods feel right to me. The first one shares internal reference of the actor (A). The second method is not as efficient (receives, then sends again). How would you approach this?

Hello, I have a little question about programming style. What do you think of using typedefs for message data? On the one hand when type changes in once place, all actors will get an update. On the other hand it creates additional coupling between actors. I am not sure what approach is better and why. Thank you!

I am now thinking of creating PPL for a Messenger Library, that is the best solution. I remember 2 years ago you suggested: Creating a PPL and relinking VIs in existing actors to that PPL should work. However how would you approach creating the PPL that will also appear in LabVIEW palette for development (as it is now with Messenger Library)? I would like to distribute PPL to developers seamlessly without having them to dig into the PPL and look for particular VIs.

Yes, Dr Powell, this is exactly what I was trying to do. Thank you for diagrams. I also realised it is not possible and shouldn't be possible based on this discussion: https://forums.ni.com/t5/LabVIEW-Idea-Exchange/Allow-type-casting-between-classes-types-in-PPLs-lvlibp-s-or/idi-p/3136231?profile.language=en Why it was necessary? Due to how TestStand Interacts with LabVIEW application instances: http://www.ni.com/product-documentation/14335/en/ TestStand steps tend to use the same application instance as LabVIEW executable (based on Messenger Library), this is why steps that used Messenger Library from another location didn't work. I wanted steps to be easily distributable, so had to keep dependencies (including Messenger Library) next to them. NI suggests to keep LabVIEW steps in PPL, that didn't work for me because it changed the namespace of the library. However, as you suggested, also changing namespace of the actor I communicate to, worked! So now I have two PPLs with exactly same names, but with different contents. One with actor, second with steps. Additionally, to make TestStand use a different application instance I specified a project path for each step (it forces it to use another application instance). Then I continued my experiments and included steps directly into the Actor PPL and it also worked perfectly without having multiple PPLs. Just one Actor PPL, that has API VIs that are called from TestStand. So far so good, it works well. Thank you very much! It is a relief and I learnt valuable things. P.S. Sharing PPL Messenger Library should also work, it will involve a little bit of extra work.

It is a good analogy. It is unfortunate that changing namespace affects the class names and hence brakes the communication. However for my particular task it is essential. I will try to remove the namespace from flattened address and see what happens. Thank you for all of your assistance and support. I highly appreciate it.

I haven't done that because the main idea was to actually have a separate namespace for a ppl and for the executable. It is unavoidable.

To eliminate the misunderstanding. I have 2 applications: One is a built executable, uses messenger library as is from VI package manager. Second is a ppl with one actor inside (possible on a completely different PC). I can't make these 2 applications communicate through a TCP messenger. I understand that PPL changes the namespace of all classes. Hence when flattening/unflattening messenger addresses the namespace is included. That is why communication doesn't work. To solve this I think I need to somehow remove the namespace when flattening and then add it when unflattening (in actor that runs from PPL). What do you think?

Thank you for the link. But, the problem appear even if I just have a single Actor that uses dependencies from ppl. Basically as soon as "Messenger Library" is put in ppl or a library the TCP Messenger brakes (I can send message without reply, but I can't receive replies). Apparently PPL also creates a namespace for everything that is inside and that brings us back to your reply: Is there any easy fix that I can apply to make Messenger Library work from ppl and library? Kind Regards. Maksims