Jump to content

Black Pearl

  • Content Count

  • Joined

  • Last visited

  • Days Won


Everything posted by Black Pearl

  1. I assume the queue might be better in performance. More use cases (SEQ, producer-consumer) -> NI put more manpower behind the optimization code -> better performance. I think 8.5 it was a big marketing about Qs and multicore performance, they never adressed notifiers. But might be completely missleading, as a notifier only needs 1 piece (the current piece) of data while a queue might queue up (as the name suggests), so those optimizations would be unneccesary for a notifier. Felix
  2. No. Dreamed of broken resistors. Didn't replace a schematic. Wish you better dreams. Felix
  3. Just some unqualified basics from my experience. I care about EE safety in germany (little experience from my side and tech not legal dep), so might be different with american steam engines . But statistically touching 230VAC is giving you a chance of about 2% to get killed. For the legal issues, you have 'employers responsibility' for anything that happens (in germany: BGV A1 and BGV A3 for EE). So for me, if someone is killed by bad electrics I produce, my boss (= employer) will hang. If he has no idea about EE, he can delegate this responsibility to me (in written form -> vEFK=responsi
  4. I'm developing a LED based light source (solar simulator) for the photovoltaics industry and research labs. Public information is available in this scientific publication. Felix
  5. I second Daklu. After all, we have an undo operation. Maybe we can just have a checkbox 'do not show this message again'. And make sure there is an ini file entry for this, so we can keep this setting across machines by simply copying the ini file. Felix
  6. I havn't used Ton's API, as I wrote my own (less complete) at the same time. It is useful if you use some automated process (e.g. build scripts). For my reuse packages, I use a pre-build hook in the OpenG builder to extract the log from hg and create a LogFile.txt that is deployed with the package. Also, I have written (but I don't really use them) small vi's that allow you e.g. to rename a vi (save under new name + tell hg that it's renamed) and the like. Didn't had the time to continue on this. But for integration of hg with the LV-IDE, you need the API. Felix
  7. Depending on the complexity of the problem, I also start with pseudo-code. On the more detailed level, I keep an uml model together with the code. For state machines, at least a bubble and arrow diagram (using dia, OpenOffice/MSOffice, or simple a paper) will be my starting point. Both get pasted as pictures on the BD. The most 'primitive' form is a simple comment on the BD as Val pointed out. I think this practice is 'good' and even is encouraged by NI for the exams (I think you get points when just commenting 'this vi will save the data' as much as coding it actually). Those design comment
  8. Offline commits sounds interesting. The main troubles I had with SVN is to manage changes I coded at customers location. At least took me a frustrating half an hour or so. Using mercurial (and above article statesit is pretty similar to git) did resolve these issues in an elegant way. It proved to be robust enough to accept copy&paste behaviour instead of the correct push&pull way to sync between the hard disc of the dev PC and the USB Flash drive. Having to deal with possible IT infrastructure changes, I'm glad to rely on a tool that will be able to adapt to those changes very quick
  9. Difficult to say, if I'd follow AQ, a must have is the hitchhickers guide. On the practical side, I found it difficult to get a book with the reason that I'd like a library on my workspace. The promise to get a new worker addicted to LV gives me a free wish-list on LV-books, and let them do their own selection some more. But actually, there aren't many books on LV, and I don't use any of the other exept the two you mentioned. Look at the projects you like, get some domain information. I've got a cool set of EE books. My bedtime lecture at the moment is (rough translation from german) 'elect
  10. I'd say templates are the way to go with VI scripting. And copy/replace operations. If you need to create things completely by code, you need to write a lot of code. And most of the time 'useless' code just to make the created code look nice (minimizing wire bends). You can take a look at my latest project here. I think about 50% of the scripting-related code is just to get the wires redrawn as they were before. Felix
  11. You need to enable VI Scripting in the options to have methods/properties for this. (LV2009 and later). If you open the BD of a protected VI without a correct pswd, you receive an error. Felix
  12. Thanks, I have a NI CAR for this behaviour. You can select Demo SubVI using Global.vi as Top-Level VI instead. All you miss is to see that it's recursing through SubVIs as well. Felix
  13. Original idea by SteveChandler Now available for beta testing. Developed in 7.1, should run in any newer version. License: BSD, © Felix Schubert Dependencies: OpenG, included with suffix Instructions: Unzip attachement Start Globals2FGV.llb and run it Select Global Variable VI -> Demo/Demo Global.vi Select Top-Level VI -> Demo/Demo VI Using Global.vi Select FGV Target Folder -> Demo Open Demo/Demo SubVI using global.vi and Demo/Demo VI Using Global.vi Press the transform button Take a look at the VIs mentioned above and inside the FGV Target Folder Customization: Change
  14. AQ, thanks for this explanation. More than once (when VI scripting) I stumbeled on the fact, that unrelated objects actually have a common set of properties. Are your considerations already down to the SW level (e.g. about an alternative class ancestry or other means that group these properties together, e.g. seperate objects that will be included in the 'old' obejct)? On the abstract level, structures and SubVIs have a lot of similarities. Most obvious: both own a diagram (sometimes more than one, e.g. Case Structure). This is important, as we now can distinguish between 'inside' and
  15. I had some similar design issues. The solution I came up was a state machine and a queue for communication. The state machine periodically checks the queue (timeout=0ms) if it gets a 'Pause' message. In the pause state, the SM waits (timeout -1) until it receives a 'resume' command. In the state transitions, the tasks are closed/initialized. About semaphores. I think it is easier to use the subVi boundary for this. An action engine always protects data from concurrent access. Concerning uml, it's not really that complicated. Most you can find on wikipedia. Another ressource was M$ Visio, wh
  16. If I climb a mountain and view everything from such a high abstraction level, that's clear. You propably need to do software in graphical IDEs such as LabVIEW or uml to see it. But actually it boils down to software-developement basics. You have a box around something (the SubVI boundary, a loop, encapsulation in OOP, virtual folder). Formulated it the wrong (graphical) way. Encapsulation is the abstract concept, the box around is the graphical (language-specific) implementation. But it's hen and egg (the ancient greeks and geometry, that's long before we invented tubes and transistors). Se
  17. My guess is that another event case was executing (and showing it's SubVIs FP). During this, a click was performed on the suspected button (has to be enabled) on the Main VI. When the SubVI was closed and the event was finished, the queued up event was proceeded. Propably a more complex variation of this, which did also do the disabeling&greying out. Felix
  18. Sharing data between parallel process requires some kind of reference. You can either use a by-ref class implementation or use a LV-native reference communication (queue, user event, notifier). Using a by-ref object is similar to the LV2-style global/ActionEngine (with the bonus that you have inheritance as well as multiple instances). A situation where you won't be able to avoid by-ref is recursive data structures. Another situation where you might use by-ref is when translating code from other OOP languages or using their design patterns/architecture ('cause they are by-ref). Using a messe
  19. I once wrote a 'converter' that was able to create xml files from LV code and recreate the LV code from the xml file. In my testing I did use kdiff3 to see if the LV->xml->LV->xml produced the same xml files. Based on this experience, this will be the issues you will need to solve to make it usable: There is no 'lines' in LV code as in text. To serialize it, the complier/IDE/converter needs to impose such an 'order' on wires and nodes. To my finding, it's the order in which the objects are created. So if you delete some section of the code and recreate it identically, the seriali
  20. Let's look a bit deeper into the meaning of static and dynamic. Remember text based languages with arrays. Static: Known at built time, e.g. the variable is defined as array[1..10]. Dynamic: Memory is allocated at run-time when the specific operation is executed, e.g. CreateArray(10). In OOP, this maps to the class/object relation. Static stuff is 'owned' by the class, while dynamic stuff is 'owned' by the object, e.g. memory is allocated when the object is created. If I remember correctly, in java I could declare an attribute as static, meaning all instances of the clas (objects) share the
  21. I haven't done interviews, but just experience with how people performed around me. Most important is they do more of your work than you need to invest to keep them busy. So you most likely will want someone who is strong at doing the job on his/her own independently (otherwise you might just become a bad manager). I think a good indication could be their hobby projects. (team spitrit, fields of expertise, independence). Felix
  22. You are right in this simplified example. The compiler can optimize this code. But the conclusion (parallelism) is implying a branching (into multiple threads!). Propably I get's a bit clearer if I extend the example: j=i+1 foo(i) i=j Seems to be perfectly sane if i,j are ints. If they are pointer (e.g. to objects), we already have a race-condition desaster. Furthermore, I see no way a compiler could prevent this. The programmer will need to take care (e.g. foo(i) my_i=i.clone //this should happen before returning -> caller might change the object in the next line return ) Felix
  23. Thanks for that positive story. Actually it is hard to believe the attitude of text-based programmers looking at a graphical code as a kind of 'toy'. I work in a very thight interdisciplinary team. When we talk about electronics, we look at the schematics and not at text. If we need a mechanical construction, we also look at drawings. And whenever we do design some optics, we have beams, surfaces and lenses drawn. And when something is measured/characterized, it's also graphically plotted. So really weired to do text-based software. Here I would disagree. There is a very important diffe
  24. I don't think both are really similar. Just to highlight some major differences: * Q's can be used as data structures: FIFO, stack (FILO) -> recursion, SEQ. * Events can be used as a one-to-many or many-to-many communication. Felix
  • Create New...

Important Information

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