NI Week 2017 (1 of 3)
Erdos Miller had a great time this past week at NI Week 2017, we got to sit down at a variety of sessions and have summarized our notes from several sessions divided into three blogs.
This blog contains notes regarding:
- Session AD0414 which covers why and how to install linux packages on your NI Linux Target
- Session AD0832 which covers how to speed up development with right click menus
- Session AD0395 which covers how to communicate between targets in the actor framework
- Session 0546 which focused on deep learning on NI hardware/software
Getting the most out of your Linux RT Target
This was a great session for cRIO users who are not quite familiar with the power of the linux operating system. The session touched on iptables a linux based firewall that can increase security for internet facing RIO targets, Syslog an industry standard protocol useful for communicating events and errors, and the LAMP application stack which provides embedded web services.
IP Tables provide firewall-like functionality to the cRIO. With the use of IP Tables, specific ports can be shut down or made available only to specific IP addresses. In addition, connections to ports can be rate-limited assisting in prevention of Denial of Service attacks.
System Log provides a log file for logging software events and debug information. One of the best use cases is for exporting the Actor Framework Debug Trace information. This information is normally viewed through the Desktop Trace Execution Toolkit, however, on a real-time target this information becomes inaccessible. By modifying the AFDebug.lvlib, we can have it log the trace information to the SysLog instead.
The LAMP (Linux/Apache/MySQL/PHP) software stack. Implementing the LAMP stack allows the cRIO to act as a webserver and provide PHP-based website design. Using LAMP allows us to bypass the use of LabVIEW web services to provide browser-based user interface access.
Detailed information can be located at: https://forums.ni.com/t5/NI-Linux-Real-Time-Documents/Getting-the-Most-Out-of-your-NI-Linux-Real-Time-Target/ta-p/3523211
This session was geared towards LabVIEW developers wanting to code faster using keyboard shortcuts and minimizing mouse clicks. Quick drop, Shortcut Menus (aka Right-Click menus) and Scripting Springboard were discussed.
Quick drop allows the user to search for controls and VIs in the project and palettes and add them to the front panel and block diagram, respectively, without navigating the palettes or project explorer. An extended functionality of Quick Drop is keyboard shortcuts that perform repetitive tasks such as Ctrl + I to insert items. To create custom Quick Drop Shortcuts, developers can use the QuickDrop Plugin Template.
There are plenty of Community Quick Drop keyboard shortcuts that automate repetitive actions in LabVIEW. A cool one is the Class Method Browser (Ctrl+C) by Moore Good Ideas, Inc. which allows the user to browse methods callable on that class and (Ctrl+Shift+C) to browse messages an actor can send.
Shortcut Menus provide plenty of functionality in LabVIEW via right-clicking on different items. In LabVIEW 2015, R&D added the ability to create your own right-click menu plugins and included a template to make the process easier. My favorite Community Shortcut Menus are the Grow to N by jtagg, which allows you to grow a growable node to a specific size instead of trying to change the size with the cursor and Change Mechanical Action from Diagram by Darren, which allows the developer to change the mechanical action of a Boolean control from the block diagram.
For those that want to start scripting or would like an easier way to test their scripting tasks, the Scripting Springboard is a great tool. This is a great tool to add to your Tools menu in LabVIEW by placing the Springboard folder under the <LabVIEW>\project folder.
Quick Drop Enthusiasts Community Group: http://forums.ni.com/t5/Quick-Drop-Enthusiasts/gp-p/grp-1251
LabVIEW Shortcut Menu Plug-Ins Community Group: http://forums.ni.com/t5/LabVIEW-Shortcut-Menu-Plug-Ins/tkb-p/3013
Scripting Springboard: https://github.com/jacobson3/Scripting-Springboard
Crossing the Gap: Inter-Target Communication in Actor Framework
This was one of my favorite sessions at NI Week. Allen covers the history of inter-target communication in the Actor Framework and then introduces and explains the current communication tools available. The information provided in this session provides benefits in the form of testability, consistency and scalability of the Actor Framework without sacrificing network communications or utilizing inefficient network communication libraries.
Allen began by discussing the original solution, “Linked Network Actors”. It was mentioned that Linked Network Actors was based on traditional queued message handler solutions for network communication. However, Linked Network Actors are now deprecated in favor of Nested Endpoint Actors.
Nested Endpoint Actors provide the current solution for network communication. Unlike Linked Network Actors, Nested Endpoint Actors support both TCP and Network Streams communication. Nested Endpoint Actors pass Actor Framework messages between each other before forwarding the message to the calling actor. This allows developers to treat both targets as if they’re two separate actor trees on the same target.
Finally, Allen discussed the “Launch Remote Actor”. This allows developers to dynamically run Actors in remote application instances separate for the current running instance. One of the biggest use-cases for Launch Remote Actor is continuous integration with Jenkins. A LabVIEW executable operating on the run-time engine cannot compile a build specification. Using Launch Remote Actor, a Jenkins service executable can be created to run in the background full-time. When Jenkins needs to run a build, the Jenkins service can run the LabVIEW development environment and use Launch Remote Actor to run an actor in the development environment to compile the build specifications.
Deep Learning with LabVIEW and Acceleration on FPGAs
Although primarily a plug for NGENE’s upcoming release for their deep learning library for use in LabVIEW; the session gave a very functional example of how deep learning can be used on NI Hardware to solve very complex problems with neural networks; without a neural network, solving these problems would be very difficult to impossible.
Deep learning, is a process by which a software can be taught through static data how to make decisions using a neural network. By having a database of information regarding the task at hand, it can be taught to be able to solve a problem with quantifiable certainty. For example, you can teach a neural network through examples what the number six looks like when hand-written and given enough examples, it can identify newly written numbers that didn’t exist in its teaching database.
The twist to NGENE’s library is that the goal was to be able to use the FPGA (or conventionally the GPU) to accelerate the training process, thus the process of machine learning could be fully optimized and later pruned and compressed. Imagine being able to place a neural network on a Vision system that could identify people and cars in real-time at a frame rate fast enough to make decisions.
Computer code may seem structured and sterile. But, like any skill there is an art [..]
Put One Foot In Front of the Other