One of my Shanghai teammates translates your post as follows:
@Tonynana wrote:
labview程序同时和程序A和程序B同时进行tcp通信，labview程序同时读程序A指令和读取程序B指令，用操作者框架怎么实现从程序A读取到0A指令就向程序B写入0Z指令，读到程序A的0B指令就向程序B写入0X指令，从程序B读到0C指令就向程序A发送0W指令，读到程序B的0D指令就向程序A发送0T指令？
A LabVIEW application talks to applications A and B in TCP simultaneously. How do I design the LabVIEW application to meet the following communication needs using the actor framework?
- Send command OZ to application B upon ack of command OA from application A
- Send command OX to application B upon ack of command OB from application A
- Send command OW to application A upon ack of command OC from application B
- Send command OT to application A upon ack of command OD from application B
Because this is cross-application, you are moving outside the domain of the Actor Framework itself. The network communication is not any sort of "enqueue message". Instead, you will follow a pattern similar to the design of AF talking to a real-time target.
In your LabVIEW application, you will create your hierarchy of actors to whatever it is that the LabVIEW application does. Somewhere in that hierarchy, you will have ONE actor that sends and receives network traffic. That actor might be up at the root or it might be down as a leaf, depending upon how relevant the network traffic is to the root of your application. Let's call that special actor "Listen To Network Actor." I'll call it LIN for short.
LIN is going to have a loop in its Actor Core that is going to monitor your network ports. If you are receiving on multiple ports, you will likely multiple loops (one per port) OR you will do polling to check all the ports on some interval. That's your choice... you can look at some of the LabVIEW shipping examples for client/server setups to find a style you like. Put that into LIN:Actor Core.vi.
In this design, Other actors in your hierarchy may SEND messages to other applications, but only LIN can receive messages. You are free to change that rule, but I suggest you follow it for your first design.
The other actors in your hierarchy will send messages to the other applications. For example, another actor might send message OA to application A. Application A will do whatever it does for that message. Then Application A will send the ack back to the LabVIEW application. LIN will be listening to the network and will hear the ack message in one of its Actor Core loops. It will see that the message is an ack for OA, so it will have the code to send command OZ to application B.
LIN will have the code to handle all of the network messages that your LabVIEW application can receive. If any other actor needs to know about the network traffic, LIN will send message objects through the actor tree in the usual enqueue way.
