1

Question

Is there a way to programmatically set what FPGA variables I am reading from or writing to so that I can generalize my main simulation loop for every object that I want to run? The simulation loops for each object are identical except for which FPGA variables they read and write. Details follow.

Background

I have a code that uses LabVIEW OOP to define a bunch of things that I want to simulate. Each thing then has an update method that runs inside of a Timed Loop on an RT controller, takes a cluster of inputs, and returns a cluster of outputs. Some of these inputs come from an FPGA, and some of the outputs are passed back to the FPGA for some processing before being sent out to hardware.

My problem is that I have a separate simulation VI for every thing in my code, since different values are read from and returned to the FPGA for each thing. This is a pain for maintainability and seems to cry out for a better method. The problem is illustrated below. The important parts are the FPGA input and output nodes (change for every thing), and the input and output clusters for the update method (always the same).

example main simulation VI

Is there some way to define a generic main simulation VI and then programmatically (maybe with properties stored in my things) tell it which specific inputs and outputs to use from the FPGA?

If so then I think the obvious next step would be to make the main simulation loop a public method for my objects and just call that method for each object that I need to simulate.

Thanks!

Improve this question

2 Answers 2

Reset to default
2

The short answer is no. Unfortunately once you get down to the hardware level with LabVIEW FPGA things begin to get very static and rely on hard-coded IO access. This is typically handled exactly how you have presented your current approach. However, you may be able encapsulate the IO access with a bit of trickery here.

Consider this, define the IO nodes on your diagram as interfaces and abstract them away with a function (or VI or method, whichever term you prefer). You can implement this with either a dynamic VI call or an object oriented approach.

You know the data types defined by your interface are well known because you are pushing and pulling them from clusters that do not change.

By abstracting away the hardware IO with a method call you can then maintain a library of function calls that represent unique hardware access for every "thing" in your system. This will encapsulate changes to the hardware IO access within a piece of code dedicated to that job.

Using dynamic VI calls is ugly but you can use the properties of your "things" to dictate the path to the exact function you need to call for that thing's IO.

An object oriented approach might have you create a small class hierarchy with a root object that represents generic IO access (probably doing nothing) with children overriding a core method call for reading or writing. This call would take your FPGA reference in and spit out the variables every hardware call will return (or vice versa for a read). Under the hood it is taking care of deciding exactly which IO on the FPGA to access. Example below:

enter image description here

Keep in mind that this is nowhere near functional, I just wanted you to see what the diagram might look like. The approach will help you further generalize your main loop and allow you to embed it within a public call as you had suggested.

Improve this answer
Sign up to request clarification or add additional context in comments.

2 Comments

This is great, thanks! But it looks like no matter what I would still need to hard-code the interfaces that I need for each thing in my application rather than, for example, initialize those mappings from some kind of init file, correct? With your approach though, I can keep things abstracted and maintain my mappings in a single place.
Your observation is correct. There is no feature (as far as I am aware) that will allow you to dynamically map the IO points on that node. The only other possibility you might consider (albeit a more complex option) is to do all your IO through a protocol over DMA access as opposed to front panel register access. Your things would all use the same code to talk to the FPGA via DMA and the FPGA code would handle returning the data from (or to) the appropriate hardware channel.
0

This looks like an [object mapping] problem which LabVIEW doesn't have great support for, but it can be done.

My code maps one cluster to another assuming the control types are the same using a 2 column array as a "lookup."

enter image description here

enter image description here

Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.