LabVIEW
General strategies on producer/ consumer loop sampling, when consumer loop controls producer loop
Solved!
Does anyone have any advice on how to control a producer loop from a consumer loop? This application is sampling a sensor output in the producer loop, and when it reaches conditions which are determined in the consumer loop the sampling stops. The producer loop needs to be stopped at this point by the consumer loop, otherwise it would run indefinitely (unless the operator stopped it manually of course). However, when I try this I don't get functional code because the loop doesn't seem to execute. I can post a code snippet if requested, but I have kind of gone back to the drawing board with this and I'm just rethinking my overall approach so would be interested to know if anyone out there has had any experience with this type of functionality.
Hello DLTD,
Yes please, post your snippet.
Here is my solution with a queue. To stop de producer, I use a local variable.
If someone has a better solution, I'm curious
Thanks Yddet, I'll keep that in mind. I think what I will do next is start again from the beginning, as I was adapting some pre-existing code for a producer/ consumer loop structure and perhaps that wasn't the best approach. Here is the code snippet - it wasn't the original design but I added a conditional so that the default value of the bool controlling the producer loop end would theoretically be false, rather than undefined in case that was causing the loop not to execute. As it turned out, that made no difference
You could use a queue or notifier. But based on what I see, I would just put it all in a single loop. Make a VI for just processing the data. It should just accept that cluster your Read Sensor VI is already putting out and output the position and any other state information that is needed.
As a general rule, if the consumer has to command the producer you are likely doing something wrong.
Hi DLDT,
perhaps that wasn't the best approach
You have two loops, which should run in parallel, but you programmed them to run sequential - due to THINK DATAFLOW!
You CANNOT use wires to send values from one loop to the other while they run in parallel! (Well, there are channels nowadays which look like wires making it more tricky for LabVIEW beginners to understand the basic THINK DATAFLOW.)
Solution: use local variables - or notifiers…
The original version was all in a single loop, however this basically wasn't fast enough. Decoupling the processing from the sampling is a way of trying to optimise for speed. I'm just looking to see if it is possible, and what sort of performance improvement it would bring if so.
I understand that they are parallel loops. The mismatch is essentially temporal. I don't see this as a reason in itself for a solution to be impossible, however. Thanks for the suggestion on local variables or notifiers.
Yddet, I have developed a version of the producer/ consumer loop which uses a local variable to stop the producer loop. I needed to move the flush and release to after the producer loop and implement my own conditional logic etc. but your example was a good starting point so I'm marking it as the solution. Many thanks!
@DLTD wrote:
The original version was all in a single loop, however this basically wasn't fast enough.
Seriously? How much other processing did you have? The processing in the code you gave us was next to nothing to a CPU. Packaging into the queue would possibly take as much time as the processing.
Another option would be to use a pipeline architecture. The idea is to use a single loop, but let the processing still happen in parallel with the read. You basically just use that shift register you already have and let the processing of that data happen on the next iteration. No need for queues or local variables. This is a very common architecture in FPGA systems.
