Jump to content


Popular Content

Showing content with the highest reputation since 08/19/2019 in all areas

  1. 9 points
    So I wasn't there but there was a public announcement at GDevCon about a new edition of LabVIEW called Community Edition which is the LabVIEW Professional version (I read that as application builder included), and completely free with no watermarks for non-commercial use. NI hasn't made any post about timelines, or other details yet but I hear those are in the works. This is obviously a huge thing for LabVIEW as any monetary barrier to entry will discourage new developers from experimenting with LabVIEW. And then there is the fact that those that are familiar with LabVIEW, can keep up with the newest version outside of their company, or when they are between jobs.
  2. 2 points
    I'll be there as well. Since this will officially kick off my vacations, I will not be presenting this year 🙂. I'm eager to sit back, relax, learn and chat with all you guys & gals.
  3. 2 points
  4. 2 points
    Breaking News: R&D expert at technology company predicts the end of the world within the next year!
  5. 2 points
    I had this discussion with a good friend of mine who is a senior developer in a texted based language. He has 15 years of experience in real world development, has probably 10 developers under him, and he keeps up with all the latest in the tech and software development world. He mentioned to me a few times that in his experience he sees the projects that have many many layers of abstraction, and code hiding behind code, only to find that debugging them is difficult. And even searching for what a function is actually doing leads down many holes of things calling things. Where the intermediate developers make a program that is straight forward, and does what it needs to. His conclusion is that his years of experience of seeing when things work well and when they don't, help guide him how complex or how simple a set of code needs to be. And when he talks about OO he very much is open to the idea that he just doesn't fully get it, but all of his experiences are summarized with "It looks great and it sounds like it solves my problems, but then in practice it falls apart" and I followed it up with a reply I've heard and that was "Well maybe you just don't fully grasp the right way to use it." And his reply was "That's what OO experts tell me." When it comes to LabVIEW I feel like I have a good mix of OO and non-OO code. Having no classes in a large project is probably a bad sign. And having all clusters be a class, is also probably a bad sign. Hardware abstraction, and plugin architectures is a couple places that OO just fits in really well in my mind. Reuse code in general also works well. Everywhere else I'm not apposed to it, but I can see some draw backs.
  6. 1 point
    I'll probably be able to attend a presentation or two each day. I'll also be there for the Tuesday night meetup at the Hideout.
  7. 1 point
    Thanks for explanation, so I shouldn't worry about those. I am asking because I have some stability issues with code and trying to pinpoint it with DETT toolkit. What might not be normal is these startup handshake queues, they should be released after "Ack Startup" right?
  8. 1 point
    @Brainiac did you solve this in the end? The code below shows how I do it, this works completely fine for me on Windows 7..10. The Generation Batch File is the complete path on disk, I don't use the Working Directory input.
  9. 1 point
    I'll be there, presenting a regular session and a 7x7.
  10. 1 point
    Hi Jim, Have you try to use the Region Functions from the Windows API? You can download an LLB that call this API on here. Below an example base on the size of a Tab control. Hope this helps. Benjamin
  11. 1 point
    A JSONtext example, ssumming all dictonary items are the same type: Alternately, keep items in JSON format so they can be treated differently at a later step:
  12. 1 point
    This idea, though it is a request for the reverse operation, illustrates how one can convert a cluster (in a variant) into an array-of-variants that contain the individual cluster elements. This did not exist when the OpenG Variant Tools were made, and OpenG is based on the (much slower) operation of manipulating flattened data.
  13. 1 point
    I got the class name part working with the NI VI GetClassName.vi. I'm going tot try to get it working with FPGA DMA channels...... lol. Wish me luck ðŸĪŠ
  14. 1 point
    We could try running iperf, just to confirm it's the loopback adapter and not the code. But as I said, we've run the same code with 2 hardware NICs (10G) connected on the same computer and it works fine.
  15. 1 point
    I noticed on sourceforge that there is a version 4.2 of OpenG Zip. Will it be released as a package anytime soon?
  16. 1 point
    I believe you! 🙂 During testing of this release I came across a problem that first dumbfounded me. On most systems it seemed to work fine but when executing it in LabVIEW 7.1 on Windows it consistently crashed. The problem turned out to be memory alignment related. One of the data structures passed to the shared library happened to be 43 bytes long. Inside the shared library was however some assignment operator where an internal temperary variable of that structure located on the stack was first filled in and then assigned to the passed in variable. C does allow to assign whole structure variables by value and the compiler then generates code to copy the whole variable. Except that Visual C did not bother to make it exactly 43 bytes but simply copied 48 bytes which resulted in random trash from the stack being copied after the end of the variable. On most platforms LabVIEW seemed to align the parameters it was passing to the Call Library Node such that this extra buffer overwrite didn't collide with any of the other parameters , but in LabVIEW 7.1 it somehow always wanted to pack the paramers tightly so that this copying corrupted the buffer pointer passed to the next parameter of the function. This was normally supposed to be a NULL pointer but of course wasn't NULL after this assignment and then the shared library crashed. I'm pretty sure that this was also the reason why it normally would encounter trouble on 64-bit Linux. And no this problem did not exist in pre 4.1 versions. This particular structure got extended when I incorporated the latest minizip 1.2 sources from Nathan Moinvaziri to support 64-bit archive operation. Previous versions used the standard stock minizip 1.1 sources included in the zlib source distribution.
  17. 1 point
    The DMA FIFO is silly fast if configured correctly. I have used it in a VST to losslessly stream (continuously for tens of hours) something on the order of several GB/s to disk. That was using PXI, and not myRIO though. Don't forget, the host (RT) is actually the place where data gets buffered, and this is where you can make a nice big buffer. You don't really need a big buffer on the FPGA, you just need to make sure you read from the host buffer fast enough. As Tim_S said, do the trick where you read zero samples, this will return no data but will give you the number of samples actually available.
  18. 1 point
    Iperf3 gets ~95% of the theoretical speed of a 1G Ethernet easily and reliably on Windows, without being CPU bound. It requires multiple threads to get there, A single thread will be limited by the scheduler. It doesn't matter much whether it is TCP or UDP.
  19. 1 point
    There are lots of design decisions with C++, C#, and Java that in hindsight are poor, but I don't feel like the author focused on the problematic parts, and maybe confused/conflated encapsulation and abstraction. In my opinion, this style of OO can be best described by: the ability to bundle data (something like a struct or record) and operations on that data (methods, which are essentially functions with an implicit "this" argument) into classes the ability to extend classes via inheritance, and automatically and irrevocably get subtype polymorphism, which can be ad-hoc through overrides the ability to hide implementation details within a class (private fields & methods) Additional ad-hoc polymorphism via interfaces I don't think I have a problem with a language having any of those features. I don't know if bundling data and operations is helpful, but I certainly don't think having the option is harmful. I do appreciate that the <class instance>.<method>() syntax is ergonomic. This can also be achieved by "." being syntax sugar where <expression>.<function>(...args) is equivalent to function(expression, ...args). I do think it's a problem when developers shoehorn their data types into convoluted inheritance hierarchies, but this isn't an OO problem. It's equally problematic when developers shoehorn data types into any convoluted data representation. I acknowledge that there may be some times where the type extension along with the subtype polymorphism may be an elegant representation. Hiding implementation details is not something I see as problematic at all, and it's not unique to OO languages. Other languages allow private struct fields and other definitions that are only usable inside the module where they're defined. It's nice when languages have something more powerful than these style of interfaces like Rust's traits or Haskell's typeclasses, but I don't think that makes interfaces bad, maybe just less useful. The big problems with these languages are: null - Anywhere you expect a class instance you must also expect the possibility of null. Terrible! unchecked exceptions - effectively an implicit potential return type of every function you write. Terrible! lack of type-safe sum-types/discriminated unions/tagged unions. Abstract parent class and multiple concrete children, the OO equivalent, is comparatively clunky. Scala's case classes are a nice implementation with an OOish flavor. lack of robust treatment of functions as data (this is improving as functional concepts are making their way into other languages) inability to extend the functionality of classes without subtyping Unsoundness in Java's type system via inappropriate generic covariance C++ being enormous and complicated loads of safety issues in C++, but it should get a partial pass for being a lower level language C++'s lack of package manager - this is an ecosystem problem, not a language problem verbosity What are the alternatives? Maybe<T> instead of null (a generic sum type which is either T or nothing. It must be cased on) Result<T, Error> instead of exceptions (another generic sum type that is either T or an error. It must be cased on, and what an "error" is a different language decision) Give the option for sum-types! Please LabVIEW! Give facilities for functions as data, lambda functions, partial application, etc. Rust-style traits, typeclasses Appropriate generic covariance/contravariance (invariance if you can't be sound otherwise - restrictive is better than unsound) Good package managers & build systems type inference What languages do these things well that are easy to use? In my opinion: TypeScript, F#, and Scala, which all also support OO stuff. Rust is probably my favorite language, but it is not easy. Haskell is great as a learning experience, but is definitely difficult and is so high level that it makes it hard to reason about when your program will do what at runtime because of laziness.
  20. 1 point
    I've gotten a test bench of 1 MS/sec of 32-bit data (24-bits plus 8-bits channel identifier) across FPGA->RT->Windows using DMA channel to RT FIFO to TCP and let it run overnight without drop of any data. Buffer was set to maximum size of U32. Now that was with a cRIO rather than a myRIO. Are you using NI's recommendations for best practices? Particularly the one where you check for available (request 0 samples) and then read all is a good way to read on the RT side. If you wait until the buffer is full then the FPGA can (and almost certainly will) overwrite before host side can service an interrupt.
  21. 1 point
    Here is a new version 4.2.0b1 for the ZIP library. I didn't test it in every LabVIEW version on every platform. What I did test was MacOSx 32-bit and 64-bit LabVIEW 2014, Windows 32-bit and 64-bit LabVIEW 7.0, 7.1, 8.6, 2009, 2016, 2018, Linux 32-bit 7.1 and 8.6, and NI Linux x86 LabVIEW 2016. Other realtime targets I hadn't handy at the moment. Support for Linux 64-bit and NI Linux RT ARM as well as VxWorks and Pharlap is contained. The realtime support will only get extracted when installing into LabVIEW for Windows 32-bit and through a seperate exe file that is invoked and will prompt for an administrative elevation of this installer. You then have to go into NI Max and into the Software part of your target and select to install additional components. In the list should be an OpenG ZIP Tools version 4.2.0 package visible. Select that to be installed on your target. There are still following problems that I haven't implemented/fixed yet: 1) archives that contain file names with other encodings than your platform code page will go certainly wrong. This is probably not solvable without doing absolutely every file IO operation in the shared library too, since the LabVIEW file IO functions don't support any other encodings in the path. 2) If you try to zip up directories containing soft/hard inks then the current implementation will compress the actual target file/directory into the archive instead of a link and expanding zip archives that contain such links will expand just a small text file continaing the link destination. This is something I'm looking into to solve in the next release by allowing optionally adding a special link entry into the archive and create such a link on the filesystem when extracting. This is mostly of concern on Linux and MacOSX. While Windows also allows for such links nowadays it is still quite an esoteric feature and user accessible support for it is minimal (you have to use the command line or install additional third party tools to create/modify such links). Hope to hear from other platforms and versions and how it goes there. Without some feedback I'm not going to create a release. oglib_lvzip-4.2.0b1-1.ogp
  22. 1 point
    I would say here you are just describing what an Actor does and nothing specific to OOP. An Actor can be an object but doesn't have to be from my experience. I personally think that this use of inheritance can be the most difficult to actually understand/maintain as well. If you've ever used an NI's Actor Framework where the inheritance reaches depths of 5+, trying to understand what the Actor does can be quite difficult (though someone might claim this is because they violated SRP). Perhaps I'm missing some historical context though and should read some older papers.
  23. 1 point
    Ask the others on this forum... they'll tell you I try never to promise future functionality. All sorts of things can conspire against a feature. I mean, everything from a malicious server virus wipes out all of last week's code changes across all backups to NI deciding to "change course" and go into knitting and not releasing any more software. But... taking all of that into account... you can have some faith that it'll be in the next full version of LabVIEW, sometime next year. If there is a next year... 🙂
  24. 1 point
    I suspect UTF uses "Set Scope", which is a separate method that doesn't do the propagation. The UTF authors may have written their own propagation loop. You could use the same workaround (I acknowledge how annoying that would be to write, but at least the option exists). BTW, looking at code, turns out that the "And Propagate" version was written to always prompt. That's how the Library Properties dialog works. On my machine as of this morning, there's a new Boolean parameter to "skip prompt" on that method.
  25. 1 point
    Thanks AQ. After posting here, I also opened a support ticket. I guess, I can close that now. By the way: NI's Unit Test Framework seems to work even with private methods. One can see the access scope changing in the project when the tests are running. At a cursory glance, the UTF is just 'regular' LabVIEW. So I wonder how that works or what the workaround is.
  26. 1 point
    If your front panel is broken up into panes (which I think would help you if it was) then you can also set the color of the pane programatically with the Pane Color property.
  27. 1 point
    The programming term you should look into is Futures and Promises. It is about handling results not yet received (such as defining their order, as you wish to do). Single-element Queues, as TomOrr0W suggests, is what I usually use.
  28. 1 point
    I don't know of any ready-built solutions, but I did come up with the idea below when you mentioned not wanting to reorder (there may be a way to do this with channel wires, but I am not really familiar with that feature) (vi is also attached, saved to LV2018): Parallel Processing Order.vi
  29. 1 point
    I threw this together, and maybe someone will find it useful. I needed to be able to interact with cmd.exe a bit more than the native system exec.vi primitive offers. I used .NET to get the job done. Some notable capabilities: - User can see standard output and standard error in real-time - User can write a command to standard input - User can query if the process has completed - User can abort the process by sending a ctrl-C command Aborting the process was the trickiest part. I found a solution at the following article: http://stanislavs.org/stopping-command-line-applications-programatically-with-ctrl-c-events-from-net/#comment-2880 The ping demo illustrates this capability. In order to abort ping.exe from the command-line, the user needs to send a ctrl-c command. We achieve this by invoking KERNEL32 to attach a console to the process ID and then sending a ctrl-C command to the process. This is a clean solution that safely aborts ping.exe. The best part about this solution is that it doesn't require for any console prompts to be visible. An alternate solution was to start the cmd.exe process with a visible window, and then to issue a MainWindowClose command, but this required for a window to be visible. I put this code together to allow for me to better interact with HandbrakeCLI and FFMPEG. Enjoi NET_Proc.zip
  30. 1 point
    Screwdrivers are $29.99 though, that's how they get you.
  31. 1 point
    Maps in LabVIEW 2019?
  32. 1 point
    We'll grow into it eventually 😋
  33. 1 point
  34. 1 point
    View File GRBL 1.1 Hi everyone, Since GRBL standard is open source, I decided to post my Library that I used in LabVIEW to interface a standard GRBL version 1.1 controller. Not all GRBL function has been integrated, but this is a very good start. Enjoy and let me know your comments. Benoit Submitter Benoit Submitted 07/26/2018 Category Hardware LabVIEW Version  
  35. 1 point
    I have created a new package with an updated version of the OpenG ZIP library. The VI interface should have remained the same with the previous versions. The bigger changes are under the hood. I updated the C code for the shared library to use the latest zlib sources version 1.2.8 and made a few other changes to the way the refnums are handled in order to support 64 bit targets. Another significant change is the added support for NI Realtime Targets. This was already sort of present for Pharlap and VxWorks targets but in this version all current NI Realtime targets should be supported. When the OpenG package is installed to a LabVIEW 32 bit for Windows installation, an additional setup program is started during the installation to copy the shared libraries for the different targets to the realtime image folder. This setup will normally cause a password prompt for an administrative account even if the current account already has local administrator rights, although in that case it may be just a prompt if you really want to allow the program to make changes to the system, without requiring a password. This setup program is only started when the target is a 32 bit LabVIEW installation since so far only 32 bit LabVIEW supports realtime development. After the installation has finished it should be possible to go in MAX to the actual target and select to install new software. Select the option "Custom software installation" and in the resulting utility find "OpenG ZIP Tools 4.1.0" and let it install the necessary shared library to your target. This is a prelimenary package and I have not been able to test everything. What should work: Development System: LabVIEW for Windows 32 bit and 64 Bit, LabVIEW for Linux 32 Bit and 64 Bit Realtime Target: NI Pharlap ETS, NI VxWorks and NI Linux Realtime targets From these I haven't been able to test the Linux 64 Bit at all, as well as the NI Pharlap and NI Linux RT for x86 (cRIO 903x) targets If you happen to install it on any of these systems I would be glad if you could report any success. If there are any problems I would like to hear them too. Todo: In a following version I want to try to add support for character translation of filenames and comments inside the archive if they contain other characters than the ASCII 7 bit characters. Currently characters outside that range are all getting messed up. Edit (4/10/2015): Replaced package with B2 revision which fixes a bug in the installation files for the cRIO-903x targets. oglib_lvzip-4.1.0-b2.ogp
  36. 1 point


    Since the standard Tick Count VI has very limited resolution, I made a simple timer using the QueryPerfomanceCounter methods in the windows kernel32.dll. The output is the time in seconds as a double precision value.

  • Create New...

Important Information

By using this site, you agree to our Terms of Use.