So… Why LabVIEW?

Abstract Away 

One of the major benefits of using LabVIEW is and has always been the ease of getting off the ground.  

While SiLA is a well-designed framework that boasts easy implementation, like any text-based language, there is some groundwork that needs to be set up beforehand. By creating a wrapper of functions in LabVIEW, all the complexities of a text-based language can be abstracted away and turned into more approachable inputs and outputs.  

Depending on your exact needs, the SiLA commands can even be wrapped into groups of commands that function as a single block. Once this block is proven to work, it can be reused repeatedly, executing complicated commands in the background without the user having to worry about specific software details. 

For example, the top image becomes the bottom image.

Faster Ramp-Up 

As a visual language, LabVIEW allows users with less programming experience to understand what is going on. 

If a SiLA application requires some modifications due to new needs in your lab, a user with minimal programming experience can jump in and adapt the program to fit their new needs. Calling a LabVIEW-wrapped SiLA function is as simple as finding the correct file, dragging and dropping it into your program, and connecting the appropriate wires.  

Data Entry and User Experience 

It is easy to add new inputs or enter complicated data into a LabVIEW program. 

As a framework primarily used in a laboratory, the data entry and processes can get very complicated. LabVIEW allows the users to quickly adjust and implement new changes without much hassle. 

A function that expects an array can easily be adjusted to accept all forms of file types that you may have that data stored in. LabVIEW supports binary input, spreadsheet input, measurement files, configuration files, and waveform files that can all be converted into your desired format with native functions and input into your SiLA wrapper. 

Sounds great! Why doesn’t everyone do this? 

While there are many advantages to a well-developed SiLA wrapper in LabVIEW, there are also some difficulties.  

Abstract Away 

Yep, you read that right. The abstraction, while great for the end user, adds some difficulty for initial development. 

Since the SiLA DLLs are a text-based integration, they cannot be directly read in LabVIEW. This means that the creation of the LabVIEW wrapper itself can require additional digging and testing. DMC has worked with several tools to parse DLLs into LabVIEW wrappers, such as JetBrains dotPeek, so reach out to us if this is a sticking point! 

Errors 

An error in a SiLA method is hard to trace. 

If an error occurs at any point during a specific SiLA method call, the entire method will report as an error. This can create some difficulties, as the user will not be able to dig into the actual text-based code to see which line is causing the errors. 

Conclusion 

A well-designed LabVIEW SiLA wrapper can save researchers an extensive amount of time in an ever-changing environment. By integrating SiLA into LabVIEW, scientists can do what they do best without worrying whether their hardware is going to perform.  

The post SiLA Integration with LabVIEW appeared first on DMC, Inc..