LabVIEW
Damped oscillations
Solved!
Hi Feedy,
what have you tried so far? Where are you stuck?
LabVIEW comes with a lot of math functions, including sin() and exp(). So all you need is to create an array of "t" values and apply your formula with your constants A, gamma, omega and phase). Math is easy as all basic math functions support polymorphism to handle arrays directly: you don't even need a loop to calculate u(t)!
Start with a ramp of times (ID array [t]) and graph it. It should be a straight line that starts at zero and goes up.
Create controls for all parameters (A, gamma, w, phase). Place a graph.
Now modify it with one parameter at a time and graph each internedate result::
First, multiply the time ramp with "-gamma" (no loop needed) and take "e" to the power of it. If gamma is positive (and -gamma thus negative), you'll now get a curve that starts at one and decreases exponentially. Adjust gamma so it goes down smoothly over the graph range,( i.e. not drop instantly or remain nearly constant).
Now add "A" which you use to multiply the resulting array from above. If A=1, nothing would change, but for other A, the data will scale accordingly.
Now multiply the [t] with w, add the phase, and take the sine. Multiply that with the result from above.
Graph it again, and voila! 😄
Now place everything in a while loop, add a small wait, add a stop button and run it again. At this time you can play with the parameters and see in immediately how the output changes.
Please do not maximize the front panel and diagram to the screen! This makes it difficult, because you cannot see both and you cannot see the help windows (which you need!) at the same time.
To create a time ramp, use ramp pattern, not a simple array control. Define start and end times and the number of desired points. There is also a function to negate. No need for anything blue.
@Feedy wrote:
I think it works. Do you think that's right?
Congratulations! I am sure you learned a lot.
Yes, it works, but there are a few flaws that have nothing to do with the algorithm, but are good habits to learn.
- "Ramp by samples" never changes and can go before the loop since the output is always the same.. It only needs to run once when the VI starts, and not millions of times per second. Of course you could make its inputs controls (start,end time, # of points) and then it would need to go inside the loop, of course.,
- As I already said, you loop needs a small wait (e.g. 50ms). Currently, it uses 100% of a CPU core mostly repeating the exactly same calculation over and over as fast as the computer allows. This wastes battery and makes your computer running hotter than needed. The loop does not need to spin faster than your capability of changing controls. (In the next lesson, you could even start using an event structure so the recalculation only happens when a control is changed).
- There is still a function to negate. No need to multiply by -1.
- Once all your controls have reasonable values, make their values default so we can immediately run it with typical data. At the moment all your controls are zero, giving a very uninteresting output. (enter reasonable values, select all controls (not indicators!), then menu...edit...make selected values default.)
- You might want to add some scaling to have reasonable units (e.g. phase in degrees instead of radians). I sometimes prefer unit-less, making the slider go from -1 to 1, calling it "phase/pi", and multiplying with pi on the diagram (not shown).
- It is not a good idea to have extra periods in the file name ("Damped oscill..vi")
- Arrange the code more logically and avoid all these wire bends. Avoid unecessary right-to-left wires.
- Make the controls more usable, e.g. by replacing them with sliders.
here's ow it could look like.
