LabVIEW
About x,y axis movement programs in LabVIEW
My code does exactly that (you can swap x and y if desired.
Might need minor tweaks, for example to ensure that the last point is only done once and not twice in succession (one for the end of the page and one for the beginning of the second page).
(Ideally, you can pre-calculate all positions for a two-page scan and then just index into that array.)
@ikeda_kaoru wrote:I am attaching the original program(fpga_test3.vi), which I am currently using.
I would like to incorporate your program into this program so that I can scan..
Sorry, I don't have access to (and much experience with) FPGA but I would not trust any code that wildly mixes datatypes (e.g. for join numbers). Just look at the coercion dots!
Basically, you are cycling through all 16bit numbers and split into two 8bit coordinates. It should be easy to adapt my code by just reversing some scans based on even, odd, etc.
We still don't know how you want to handle the turnaround (i.e. scan the last point once or twice?)
Kon-ban wa, Kaoru san.
I (unfortunately) misplaced my code, but just found it. I'll put a picture of it here so I can walk you through it, but will also attach the VI itself so you can try it out right away.
First observation is if you have 256 positions, you can't number them 0 to 256, as that is "one too many". If you have a For Loop (concentrate on the inner-most For Loop) that runs 256 times, incrementing by one, you will go from 0 to 255.
There are three Shift registers that make this work. The top (Boolean) one controls whether you are moving left-to-right (X increasing from 0 to 255) or decreasing (the True limb of the inner Case, which you can see in the attached VI) to move right-to-left. The second Shift Register is the Y coordinate, going from 0 to 255, incrementing by 1 each time through the loop.
This leaves the third Shift register for X. When moving left-to-right, X increments (as shown) each step, and when moving right-to-left (as governed by Shift register #1), X decrements. There's a little trick you'll see when you look at the code and pay attention to the two Case instances.
I provided two outputs. The first, Scan Array, is a 65536-element array of X, Y pairs, where Y changes "slowly" and X zips back and forth. This is created by passing the inner 256-point 2-D arrays of a single scan through a "concatenating" tunnel to tack the new arrays to the end of the preceding array. By passing these same 256-point arrays through an "array" tunnel, we get a 3-D "Array of Scans", where the first index is the "Scan number" (which is the same as the Y coordinate).
So when you run this code, you get 65536 values you can feed to Position Controllers which move no more than one step at a time (by Y slowly increasing while X goes back and forth). What about when you get to the end, and want to "do it again"?
I leave that as an "Exercise for the Reader". There are several choices -- make the "upward" move from (0, 255) back to (0, 0) without taking data, then do another 25536 steps. You can also simply run the whole thing in reverse, but then the time between samples of a spot depends on the position of the spot.
I believe you asked about timing. The zigzag scan I generated moves one step on one activator per step, so all you have to do put this in a timing loop.
Enjoy.
Bob Schor
@ikeda_kaoru wrote:
The lab view I am using is the 2019 version.
It appears that I cannot open your program. I will see if I can upgrade.
Here is it down converted to 2019.
(since it is flat code with nothing hidden, it would have been easy to recreate from the picture)
Hi ikeda,
@ikeda_kaoru wrote:
Can you tell me how to swap the x and y axes in this program?
By swapping the values of the two cluster elements after the ArrayToCluster function…
