labview statechart module tutorial - search...
Post on 12-Oct-2018
256 Views
Preview:
TRANSCRIPT
LabVIEW Statechart Module Tutorial
Overview
This NI LabVIEW Statechart Module tutorial is designed for the LabVIEW online evaluation
environment, so it does not depend on any hardware. It covers the basics of creating a statechart-
based application.
Introduction to Applications Built with Statecharts
With an existing statechart-based application, this section illustrates how you can use statecharts.
The application is a ceiling fan that has variable speeds and a light that can be toggled on/off.
Additionally, this application makes use of a synchronous statechart architecture. Synchronous
architectures periodically read inputs and write to outputs and are not dependent on an external
trigger to cause the statechart to evaluate conditions. Synchronous applications are best suited for
real-time, field-programmable gate array (FPGA), and embedded applications.
1. Open Ceiling Fan (sync).lvproj. Expand LV Statechart.lvsc.
2. Statecharts consist of triggers, inputs, outputs, state data, and a diagram. Open Edit
Triggers and Groups. This section is where you can add external triggers that can cause a state
transition. Because you are dealing with a synchronous statechart, no triggers have been created.
Click OK.
3. Open Inputs.ctl. Here you can see four different input values – light, fan, switch, and stop
buttons.
4. Open Outputs.ctl. This has two indicators – a light status LED and fan status numeric
indicator.
5. Also included inside a statechart is StateData.ctl. State data is a control that can act as a set
of temporary variables that are accessible only within the statechart.
6. Open Diagram.vi. This is now the statechart logic for the ceiling fan. Statecharts are
primarily made of regions, states, and transitions. A region is a container for one or more
states, a state is the condition that the statechart is in, and a transition is a means to move
between states.
7. Double-click the transition that goes between Fan Off and Fan On.
8. This brings up the Configure Transition dialog window, where the LabVIEW code that
defines a transition is located. The tabs Guard and Action define where the LabVIEW code is
written. A guard is a conditional that is evaluated to determine whether a transition should be
executed, while the action tab specifies a behavior of the system when a transition is taken. Click
OK.
11. States have several types of actions. Entry actions are executed every time the state is
entered, and exit actions are executed when the state is exited. You can make additional actions
depending on the behavior in the system. Click OK.
12. Looking at the statechart, the behavior is described as follows: initially, the statechart is in
the Switch Off state. Once the switch is turned on, you enter the Switch On superstate. In this
state, you contain two orthogonal regions that act independently of each other. Inputs can change
the light from the Light Off state to Light On and likewise for the Fan Off and Fan On states.
Ultimately, you can terminate the statechart by the Stop input.
13. Switching back to the Project Explorer window, open the FanLightDemo – Sync.vi.
14. Bring up the block diagram by typing <Ctrl+E>. The statechart is executed by the Run
Statechart.vi.
15. Switch back to the front panel. Run the VI.
16. Experiment with the buttons and observe how this impacts the statechart.
Creating a Statechart Application
This section covers developing a statechart and integrating it into your application, which
simulates the heating and cooling of a water tank. It consists of a tank being heated to a user-
defined temperature, after which the tank is cooled to another user-defined temperature. The
system has an emergency switch that stops the process at any point.
First you need to create your project.
1. From the LabVIEW Getting Started screen, select Empty Project.
2. Right-click My Computer and select New >> Statechart.
3. Save the statechart as Temperature Monitor.
4. You have created the statechart file structure in the Project Explorer window.
You now have created the framework for your statechart. The following section outlines the
steps required to build your statechart-based application – inputs, outputs, diagram, code, and
integration.
The main statechart creation steps are defining your system inputs, determining the system
outputs, creating a diagram representing your statechart, implementing the behavior in LabVIEW
code, and then integrating the statechart into your LabVIEW application.
Defining Inputs
During this phase, create the input cluster to your statechart.
1. From the Project Explorer window, open up Inputs.ctl.
2. Rename the button as “Stop.”
3. Add three numeric controls for High Temperature, Low Temperature, and Current
Temperature. The completed input cluster should look like the image below.
4. Open StateData.ctl. You can use this control for temporary values and internal state data. In
this example, maintain a copy of the current temperature. Rename the control to Temperature.
Determining Outputs
Now that you have completed the inputs to your system, you can create the output of your
statechart.
1. From the Project Explorer window, open Outputs.ctl.
2. Rename the numeric indicator as Temperature. The completed output cluster should look
like the image below.
Creating Diagrams
Now that the input and outputs are complete, you can create the diagram that represents your
statechart.
1. Open up Diagram.vi. During this part of the exercise, you use only the Statechart
Development palette.
2. Create a state named Controller. Within this state, create a region called Temperature
Control. Additionally, the diagram requires an Initial pseudostate and a transition. The diagram
should look like this:
3. Within the Temperature Control region, add two additional states called Heating and
Cooling. These states need to be connected by a transition. Within this region, you need to add
initial pseudostate and a transition. The diagram should now look like this:
4. Outside the controller state, add a Terminal pseudostate. Add a transition from the
controller state to the terminal and a transition from the cooling state to the terminal block. The
diagram should look like the image below. This is the completed statechart diagram for your
application.
Implementing Code
With your diagram complete, you now can implement your LabVIEW code into the statechart.
1. Right-click the transition entering the Heating State. Select Configure Transition.
2. In the configure state dialog, under the Action tab, wire Inputs.Current Temperature to
StateData.Temperature.
3. Right-click the Heating state. Select Configure State.
4. In the Configure State dialog, create a static reaction by pressing the Create button in the
bottom left of the window. Select the newly created static reaction and navigate to the Action
Tab. Within the action tab, add the value of 1 to the Statedata.Temperature. Wire this value to
Statedata.Temperature and Output.Temperature. Click OK.
5. Now add code to the transitions between Heating and Cooling. This code determines when
the transition between heating and cooling occurs. Right-click the transition and select
“Configure Transition…”
6. Select the Guard tab. Change the inputs to be both StateData.Temperature and
Inputs.High Temp. Determine whether the state data temperature is greater or equal to high
temperature. Wire the output of the comparison to the Execute? terminal. If the current
temperature is greater than or equal to the high temperature, it transitions to the cooling state.
Click OK.
7. Configure the Cooling state. Right-click the cooling state and select Configure State…
Within the Configure State dialog, select StateData.Temperature. Subtract 1 from the value
and wire to StateData.Temperature and Output.Temperature terminals.
8. Configure the transition leaving the cooling state. Right-click the transition and select
Configure Transition. In the guard code, compare whether StateData.Temperature is less than
or equal to Input.Low Temp. If this is true, the transition should execute. Wire the output of this
comparison to the Execute? terminal.
9. Configure the transition leaving the Controller state and ending at the terminal state. In the
guard code, wire Input.Stop to the Execute? terminal.
10. Now the statechart diagram is complete with the functionality that you need. The final step
is to generate the code for the statechart by clicking the Generate LabVIEW Code for this
Statechart button.
Integrating the Statechart into Your Application
You have completed your statechart. Next, call and execute your statechart from your LabVIEW
application.
1. From the Project Explorer window, create a new VI.
2. On the block diagram, from the Statechart >> Statchart Communication palette, select
Run Statechart.vi.
3. Right-click the Run Statechart.vi and select Link to Statechart. Link to the temperature
monitor statechart that we just created.
4. Right-click the input terminal to the Run Statechart.vi and create a control.
5. Switch to the front panel and add a Waveform Chart to the user interface.
6. Switch back to the block diagram. Right-click the Run Statechart.vi output terminal and
select Cluster, Class, & Variant Palette >> Unbundle by Name.
7. Wire the output from Unbundle by Name to the Waveform Chart. Place a timed loop
around the code. Wire the Terminated? terminal from the Run Statechart.vi to the stop of the
while loop.
8. Right-click the Run Statechart.vi and select Configure… From the configure dialog, under
Statechart Diagram Display, check the Show Terminal? check box.
9. Create an indicator for the Diagram Display terminal of the Run Statechart.vi. The
completed code should look as follows:
10. Enter values for current temperature, high temperature, and low temperature and run the VI.
The completed front panel should look as follows.
More Information and Examples
Here are a few bundled examples of applications built with the LabVIEW Statechart Module.
Fan Demo (Asynchronous) – The ceiling fan demo using asynchronous architectures.
SPI Statechart Demo – SPI protocol developed using statecharts.
PackML – Package Machine Language machine model.
For more shipping examples, in LabVIEW, go to the menu option Help>>Find Examples… to
open the Example Finder.
Browse under Toolkits and Modules >> Statechart to find additional statechart examples.
For more information on the LabVIEW Statechart Module, visit ni.com/statechart.
top related