NI TestStand
Modified type not reflected in the sequence file or how to force sequence files to use latest version of all types?
Solved!
Hello you,
We are using types which are essentially just calls to .dlls.
Now, I had to modify all our custom types.
What I did is that I have updated type and incremented version from 0.0.0.1 to 0.0.0.2
I expected that once I open the sequence file, which is using this type, it will automatically used updated type.
Instead of that, I got a small plus. When using diff tool, it shows that "Modified in Editor" file is using updated type(?!)
When I open exact step, it is still previous version.
My question is how to enforce sequence file to use latest versions of types?
how to force it globally? We Are calling these types in hundreds of steps, across dozen sequence files.
Would it be better solution if I did not increment sequence file?
We are using git to store our sequence files and types. Across many stations, we are checking out and using only latest types
thanks
@IvanZj wrote:
[...]
What I did is that I have updated type and incremented version from 0.0.0.1 to 0.0.0.2
[..]
Kudos for doing so, you are doing a big favour to your future self!
@IvanZj wrote:
[...]
I expected that once I open the sequence file, which is using this type, it will automatically used updated type.
Instead of that, I got a small plus. When using diff tool, it shows that "Modified in Editor" file is using updated type(?!)
[...]
The "+" sign is TestStands gentle way of saying: there was I type conflict, I resolved it myself.
The automatic type conversion can be configured in your Station Options.
The resolution takes place for your sequence file in memory, as long as you don't save it to disk, you won't see any type updates when reopening the seq file.
When you open up the Types Window, you will find the types loaded to memory and where they are used
You won't find different version numbers for the same type here.
TestStands automatic type resolution (though depending on the StationOPtions settings) will in general use the latest type version.
So best practice would be to roll out type updates using TypePalette Files, since it works best with the default TypeConflictResolution settings.
There are some aspects, you have to consider though: if you are updating a type while developing, there is an option to atcually reload the instances which are already in memory
A word of warning: if the update of the type refers to modifying the default module: these changes will only reflect in new instances of the step.
Regarding Custom (Step) Types I highly recommend reading (screenshot above originates from there).
@Oli_Wachno wrote:
A word of warning: if the update of the type refers to modifying the default module: these changes will only reflect in new instances of the step.
@Oli_Wachno,
Thanks for your reply,
Just to be sure that I understand it correctly.
as an example.
these are my station options:
I have following type, where i use "default module":
And I use this type in the sequence file:
now I want to change my type's "default module", to something like this:
I open sequence file where it is used. There is a plus sign and old .net invocation. Default .net invocation and parameters won't be changed and there is no way to do bulk update of default module once it has been used. Is that correct?
(type changed.png)
(types show that sequence file is using latest type.png)
The thing is that we are using .net invocation for communication between the teststand and our device under test. And we have been doing it in this way. Using default module. Now the problem is that middle layer every now-and-then gets changed. Parameters is added or invocation modified.
Do I understand it correctly that we are not using types in optimal way? That it would be better to use invoke .dll as poststep?
@IvanZj wrote:
The thing is that we are using .net invocation for communication between the teststand and our device under test. And we have been doing it in this way. Using default module. Now the problem is that middle layer every now-and-then gets changed. Parameters is added or invocation modified.
Do I understand it correctly that we are not using types in optimal way? That it would be better to use invoke .dll as poststep?
You could in write yourself some TestStand code which updates all default module calls of that step type.
The default module is just not meant to be used as you do.
Using a sub step would be the way to go, though usually prestep is used.
