Does your idea apply to LabVIEW in general? Get the best feedback by posting it on the original LabVIEW Idea Exchange.
Browse by label or search in the LabVIEW Real-Time Idea Exchange to see if your idea has previously been submitted. If your idea exists be sure to vote for the idea by giving it kudos to indicate your approval!
If your idea has not been submitted click New Idea to submit a product idea to the LabVIEW Real-Time Idea Exchange. Be sure to submit a separate post for each idea.
Watch as the community gives your idea kudos and adds their input.
As NI R&D considers the idea, they will change the idea status.
Give kudos to other ideas that you would like to see in a future version of LabVIEW Real-Time!
Many networks have NTP (network time protocol) time servers locked to a GPS signal with claimed accuracy of better than 1 millisecond. NTP seems to be the de facto standard for distributing accurate time to systems accross a network. I would like to see a VI that can use this widely available protocol to set the system time with as much accuracy as possible. TheRT Set Date and Time VI only permits specifying the time down to 1 second.
A forum contributor has provided a VI to read the NTP protocol, but uses the RT Set Date and Time VI to set the RT target system time losing any resolution beyond the second. This VI eliminates the greater precision available using the NTP protocol. The contributed VI also does not implement any of the advanced algorithms to improve the accuracy of using NTP over a network which are described at NTP.org and at links that may be found there.
Very tight synchronization (millisecond or better) of many RT targets is possible when the NTP protocols are fully implemented. I need accurate millisecond resolution on many RT targets over a wide (several thousand square miles) area. These RT targets recieve their data streams via radio telemetry so signal propagation time over the area is essentially zero. Processing of the data relies on the relative accuracy of time-tags generated at multiple sites.
If you try to select "Run As Startup" before having built the application you are stopped by LabVIEW with the phrase "The Real-Time application has not been built. You must build the application before deploying."
This is bad behaviour. Instead LabVIEW should silently do the requested task, including any prerequisite ones (the build), or at least offer me to grant it access to do so. The Run As Startup choice already includes the deployment option (no complaints from it if I have not done that yet), there is no reason why it could not do the build as well.
A number of times, I have found the Real-Time Clock configuration screen in Measurement & Automation Explorer to be very limited. With only the options to set the Time-Zone/Daylight Savings Time/UTC, I feel like there could and should be more!
Adding a feedback to show what the current RTC is set to similar to the Windows Clock configuration would be GREAT! Additionally, add the functionality of the RT Set Date/Time VI to Measurement & Automation Explorer.
We frequently run into issues where the Daylight Saving Time value is different between the US and the rest of the world (frequently=twice a year).
I believe all of this can be resolved by adding 1 layer of abstraction to translate a base RT system clock to the user-specified specifications to be added to timestamp data, schedule tasks, and so-forth.
Having used our LabVIEW 2011 StateChart module with great success on a CompactDAQ system, I now have a new project using a CompactRIO 9075 which will be controlling a hydraulic test unit. I would like to again use our StateChart Module so the functionality of the machine is understandable to all stakeholders.
The best NI example project I could find is the Chemical Mixing Example w/StateChart. It is exactly what I need except that it is a "headless" architecture. I need a 1:1 networked communication to my host PC for recipe entering and data logging much like the Bioreactor Example in the CompactRIO Developers Guide. See attached architecture jpg. I need to know how, specifically, to add a Host UI and incorporate network streams for the Host Command sender -> RT Command Parser.
In other words, what software architecture would combine the Chemical Mixing Example (w/StateChart) with the Bioreactor Example?
The console mode of RT controllers has very limited functionality. It would be great if all or most of the settings of the controller were editable from the console.
File browsing and transfer, plus software loading, would be nice too. We have had cases where the controller is operational and holds valuable data, but because the network interface has gotten damaged we have had no way to extract that data...
Different versions of NI-RIO only support certain versions of Labview, see link below. You can not have Labview 8.5.1 Real-Time & 2011 Real-Time co-exist on the same PC because NI-RIO 4.0 only supports up to 8.6.1. Wouldn't it be nice if you could install multiple version of NI-RIO just like you can have multiple version of Labview?
Currently, when you add a new (not existing) cRIO controller and chassis to a LabVIEW project, there is no check as to whether this is a valid configuration or not. For example, you can successfully add a cRIO 9072 controller with a 9112 chassis to a project, even though the 9072 is a controller with an integrated chassis. I believe that the LabVIEW Project interface should notify the user (via dialog box) that this is not a valid configuration before they can add modules and start developing code to use an invalid configuration.
It would be nice if attaching a thumbdrive to a cRIO / RT usb port triggered a "mounted" event or interrupt in the RT OS. Currently the only way to discover if a thumbdrive has been connected is to periodically run a file/folder info VI and see if one is present. It would be nicer if we could register a dynamic event and wait for it using an event structure, or similarily register for an interrupt event would work as well.
In my case, the use-scenario is a field maintenance person going out and manually plugging in a thumb-drive about once every 4 weeks to get the stored log files off of the controller. (No, we cannot use remote access in this case due to customer network restrictions.) So, in my case, I can easily use the polling solution, but if there is one thing I don't like to do, its to write polling code of any sort. It seems so wasteful. Other possible use cases could be to detect the presence of a thumb-drive and check for patch/updates, copy over new configuration files, etc.
I did not see any options for this in labVIEW. I saw only you can play around writing and reading sound files and perform some manipulation to sound file.
Why not we compare two sound files extensively and indicate about similarities. For example, a system is running with constant sound(Motor is running in good case) and other hand the same system is running bad after some days or years(sound is different and louder with noise).
Second, if we can compare a sound with another sound, that would be interesting and possibly useful in applications. I know that many sensors out there for this operation but thought of interest to see it digitally in labVIEW.
If any thing wrong with my idea, please let me know.
If I have variable library with virtual folders and I choose "Export to..." only top level variables are exported to the file. I suppose that also variables inside virtual folders should be exported. I think virtual folders make structure clear and export/import is useful if you are working with several projects in different computers. I would like to see them work together.
I've been attempting to perform a relatively simple homing routine on a motion axis where there are two limit switches (forward and reverse) and a home switch located somewhere in the middle. The homing routine starts by advancing forward and if it does not see a home switch, it will continue in the forward direction until the forward limit switch is activated. At this point, the routine will reverse the direction of motion and continue searching for a home switch until it would eventually see it (thus it is guaranteed that the home switch is found.) Once the home switch is activated, the routine performs a fine tuning procedure by slowly backing away from the home switch (in the forward direction again) until it is no longer active.
When using a c-series servo interface module, there is a Stop Mode property that one can set for each limit switch to either stop immediately, decelerate or disable the drive (See fig. Axis Properties and Limit Stop Mode ). When the stop mode is set to Disable drive, the homing routine fails upon triggering a limit.
There are property nodes available to read the stop mode however the nodes are read only. (see fig. PropertyNode)
It would be nice to have the ability to programatically change the stop mode depending on the motion being performed. Our application requires that the drives be disabled upon activation of any limit switch under regular motion. However, during a homing routine since the disable drive stop mode impedes the routine, it would be benefitial to be able to change the stop mode to decelerate for the duration of the homing routine, and then change it back to disable drive once homing is complete.
I need a simple way to stop, from a PC, the startup application (if any) running on the RT system. This would work without prior knowledge of what is running on the RT.
This could be VI based solution that I could use in developing a startup upload application.
This would allow me to FTP new application files to the RT system as new startup code. Currently, if there is a startup application running on the RT system I cannot replace the application file since it is in use and I cannot stop the application without having access to the LV development system. I want too make this upload process into a user run software application for a PC connected to the RT system - without the user having access to the LV development software.
I'd like to create a timing source from an RT FIFO reference to drive a timed loop. The timing source would tic whenever there an element is placed into the RT FIFO, facilitating a timed loop to be configured for reading elements from the RT FIFO as they become available. This would only be available for blocking mode on read. Once the loop awakes, the user can then read the FIFO with a 0 timeout to get the data.
This would provide all the nice features of timed loops to loops that need to be timed by data showing up in the FIFO. Right now you have to place a while loop that blocks on the RT FIFO and wrap it in a timed sequence for CPU assignment and priority.
I propose having the timed loop accept one or more timing source(s). The loop would wakeup and execute if any of the chosen timing sources tic'd. If multiple sources tic'd, then the 1st timing source would execute first.
This would ease the creation of more complex timing schemes on the host. For example, application needs to wake up every 50ms and whenever a timing source tics. Both wake up events need to operate on the same data and neither should happen at the same time. Typically this means you write two timed loops and a lot of handshaking overhead... or a single while loop with a lot of timing structure built into it and probably encompassed by a timed sequence structure so you get priority and CPU assignment.
All of this would be much easier if a single timed loop could handle multiple timing sources. All of your data would be in the same shift register(s) and you don't have to write any handshaking code to prevent simultaneous execution.
Obviously the GUI for this would be somewhat complex, but for the programmatic inputs you can simply turn most of them into arrays.
Ability to create a GUI (with touchscreens) using the graphics capability on desktop PC's. Maybe something like PEG (portable embedded GUI). For small testers, I don't necessarily want a PC or touchscreen PC running CE or XPE. The PC's involve a lot of setup, virus concerns, etc that I don't need on some testers. Support would be much easier also. Plus, in a lot of organizations, they don't understand the difference between PC's for desktops and PC's for production stands. You end up getting a "standard" PC with a lot of restrictions on it that requires several different groups to support when it fails.
At the moment Labview RT does not support high speed USB 2.0 (EHCI) functionality on PXI-8xxx controllers even if the controller has supporting hardware. We implemented a copy operation to transfer data files from a harddrive on the PXI chassis to an external USB connected flash drive using the copy VI, and only obtained speeds at USB 1.1 (OHCI) levels. We also tried a move version using the Move VI with similar results. The controller used in our tests was a PXI-8186, which has USB 2.0 ports.
My discussions with NI Support and the R&D team indicate this a limitation imposed by the ETS RTOS from Phar Lap that Labivew RT runs on. This is inline with the fact that VxWorks supported controllers have access to EHCI speeds as per this faq:
I understand that the FE vi's needed to be optimized for speed so that they could be put inline without disturbing RT timing. But it would be nice to be able to send a string description
with the fault so that it would show up in the DSM. An example would be a fault due to trying to send an invalid remote message. It would be nice if the invalid message string could be logged with the fault event.
I think making it optional would still preserve the determinism when needed.