Yes, I was right -- you have a single loop where you generate data points and display them. Consider the operation of your program if you do not display the data as a Chart, but instead simply display (as an indicator) the most recent value. The loop will go into your sub-VI, wait the appropriate time to generate a point, return, display, and immediately call the sub-VI again. Fine, it should run at the speed of the sub-VI.
Now add the Chart. Same thing happens, but now you move the Chart. The top-level routine, tasked with displaying the Chart, needs to use additional time to repaint the Front Panel, so it take it. Now when you call the sub-VI again, time has elapsed.
What you need to do is to run two loops in parallel, so-called Producer-Consumer Design Pattern. Have your sub-VI return a Waveform (not a Chart). This loop becomes the Producer -- all it does is "produce" a Waveform at whatever rate the sub-VI specifies. Create a Queue of Waveforms outside this loop, and enqueue the Waveform onto it. In a parallel loop (usually written below the Producer Loop), write the Consumer loop, into which you pass the same Queue. Here you Dequeue the (latest) Waveform and display it on the Chart.
Now, while this runs, move the Chart. The Consumer loop will be delayed (because you are refreshing its Front Panel), but the Producer loop, running in parallel, just keeps going, putting more points on the Queue. When the Consumer finishes its Front Panel update, it blithely plots whatever is on the Queue. If you look carefully at the traces being plotted, you should notice that when you move the Chart, the plotting temporarily stops, then the "missing" points are speedily plotted and plotting resumes at whatever rate it was before you moved things. This is the power of parallel processing and LabVIEW.
Bob Schor
P.S. -- there are examples of Producer Consumer patterns -- if you open LabVIEW and go to File, New, you should see some examples under From Template.
