Friday, January 28, 2011

Case Structures in LabVIEW

Below see the context help for the case structure:

Here are two images that make a good example of what this looks like in a VI from the great information that I talked about here:

When the case is true.

When the case is false.

Thursday, January 27, 2011

Context Help in LabVIEW

This is a small thing, but the context help window is a real useful tool.  It can be turned on with the key combination, SHIFT+CMD+H (as shown above).

By default he context help window will show information about the use of whatever element is active.

The 'Lock Context Help' feature allows a developer to keep the context help for a particular element available even when that element is deselected.

Monday, January 24, 2011

Basic Propositional Logic with LabVIEW

Earlier I posted this about a cool PL shell:

Here are some screen shots from a quick LabVIEW VI that I built to demonstrate various logic gates. 

When X is true and Y is false:

When X is true and Y is true:

Here is what the VI looks like:

Friday, January 21, 2011

Tufts Center for Engineering Education and Outreach (CEEO) is produced by the Tufts Center for Engineering Education and Outreach (CEEO) and LEGO Education.

All sorts of good stuff here, like tutorials that open directly in LabVIEW:

Thursday, January 20, 2011

NXT Shell

The NXT Shell is a program that is run on the NXT brick in the background during direct mode execution. Since some remote mode commands do not have a direct mode analog, the shell will execute these commands. The shell has 2 main purposes: 1) the sensor view screen and 2) execution of shell commands.

This is an important requirement for running programs from a computer for debugging/etc.

Wednesday, January 19, 2011

More LabVIEW Debugging

Last week I pointed out how cool 'Highlight Execution' is:

This week I am happy to say that it gets even better:

There are many concepts covered in this tutorial that are what one would expect (e.g. breakpoints,  single stepping, and suspending execution).  The item that really got my attention though was the probe tool.  Despite the name (seriously NI, couldn't you name the thing the 'Data Inspector' or something?), this is a very cool tool.  The ability to watch data move through a VI and to be able to see the value of the data on the wire is pretty slick.

The following is all directly from the tutorial referenced above:

Use the Probe tool, shown as follows, to check intermediate values on a wire as a VI runs. 

Take advantage of the Probe tool if you have a complicated block diagram with a series of operations, any one of which might return incorrect data. Use the Probe tool with execution highlighting, single stepping, and breakpoints to determine if and where data is incorrect. If data is available, the probe immediately updates during single stepping or when you pause at a breakpoint. When execution pauses at a node because of single stepping or a breakpoint, you also can probe the wire that just executed to see the value that flowed through that wire. 

Tuesday, January 18, 2011

Propositional Logic

An interesting Propositional Logic shell:

The documentation is very good, and there are a ton of features that I have not looked at.  Below find examples of printing a truth table, entailment checking, and formula evaluation:

Monday, January 17, 2011

LabVIEW - Web Publishing Tool

Last week I talked about the simple example of the light sensor:

This is a really simple example, but it works great to make sure that everything is working between computer, LabVIEW, and the NXT.

The VI ended up looking like this:

When run, it displays the light sensor measurement both on the NXT screen and also on the front panel of the VI (via the Waveform Chart).

This was interesting, but what I really wanted to do was to prove to myself that the Web Publishing Tool worked.

Here are the steps to setup a simple read only web page (in my case to an internal IP address):

I then was able to use my browser to access the page:

Pretty cool stuff.

Lots of possibilities.

Imagine a network of robots deployed globally that are able to share data via the Internet.

Then again, maintain a healthy fear of the Robot Apocalypse.

Friday, January 14, 2011

Constraint Satisfaction Problems

CSPs are a very interesting set of problems.  I have recently started looking at cream (, a class library for constraint programming in Java and it appears pretty cool so far.

Below is a screen shot of a simple example program that uses cream:

Thursday, January 13, 2011

Robots Are More Than Just Software

This is one of my favorite Lego Mindstorms NXT 2.0 robots:

Details (and other great deisgns) can be found here:

Wednesday, January 12, 2011

Lego Mindstorms NXT Color Sensor in Light Sensor Mode (Again)

"All of this has happened before, and all of this will happen again." - Battlestar Galactica 

This is the Context Help for the PolySensor VI that is a part of the Lego Mindstorms NXT Module for LabVIEW.


The PolySensor is currently configured as the Color_None VI, which is similar to what one had to do in NXT-G and LabVIEW 7.1 when using the color sensor (which ships with the NXT 2.0 kits) as a light sensor.

In some ways this is no big deal to configure the sensor as needed and can be seen as a feature as it allows for the one piece of hardware to be a color sensor, light sensor, or lamp.

That said, I have recently started working with LabVIEW 2010 and had to relearn this when working through the first example in the Getting Started with LabVIEW for NXT documentation.  Doing this is easy enough (it has taken more time to document that it took to figure it out and do it).
From the PolySensor VI select 'Read Color' -> 'No Light":

And that is all there is to it.  The NXT module for LabVIEW 2010 seems like a huge improvement over what I have used in the past, but some of the lessons learned from older versions still apply.

Tuesday, January 11, 2011

Highlight Execution

Here is a quick video that shows one of my favorite features in LabVIEW:  'Highlight Execution'

This is a simple example that I built and ran (taken from the Getting Started Guide) that shows a VI that simulates a sawtooth signal with a variable amplitude that can be adjusted with the amplitude control, processes it with a function and then outputs both the original signal and the processed signal to a waveform graph indicator. 

Debugging will never be the same.