# User provided files:
# Package directory:
.../packagename/manifest.xml, Makefile, CMakeLists.txt,...
# Sources:
.../packagename/src/*.cpp
# Headers:
.../packagename/include/packagename/*.hpp
 
# Build results:
# Built Component libraries for 'packagename':
.../packagename/lib/orocos/gnulinux/*.so|dll|...
# Built Plugin libraries for 'packagename':
.../packagename/lib/orocos/gnulinux/plugins/*.so|dll|...
# Type libraries for 'packagename':
.../packagename/lib/orocos/gnulinux/types/*.so|dll|...
# Build information for 'packagename':
.../packagename/packagename-gnulinux.pc

orocos_component( mycomponent ComponentSource.cpp )
target_link_libraries( mycomponent ${YOUR_LIBRARY} )

import("packagename")

# Install dir (the prefix):
/opt/orocos
 
# Headers:
/opt/orocos/include/orocos/gnulinux/packagename/*.hpp
# Component libraries for 'packagename':
/opt/orocos/lib/orocos/gnulinux/packagename/*.so|dll|...
# Plugin libraries for 'packagename':
/opt/orocos/lib/orocos/gnulinux/packagename/plugins/*.so|dll|...
# Type libraries for 'packagename':
/opt/orocos/lib/orocos/gnulinux/packagename/types/*.so|dll|...
# Build information for 'packagename':
/opt/orocos/lib/pkgconfig/packagename-gnulinux.pc

orocos_component( mycomponent ComponentSource.cpp )
target_link_libraries( mycomponent -lfoobar )

RTT_COMPONENT_PATH=/opt/orocos/lib/orocos
export RTT_COMPONENT_PATH

import("packagename")

export LUA_PATH=";;$HOME/src/git/orocos/ocl/lua/modules/?.lua"

#!/bin/bash
RTTLUA_MODULES=`rospack find ocl`/lua/modules/?.lua
if [ "x$LUA_PATH" == "x" ]; then
    LUA_PATH=";"
fi
export LUA_PATH="$LUA_PATH;$RTTLUA_MODULES"

$ ./rttlua-gnulinux
OROCOS RTTLua 1.0-beta3 / Lua 5.1.4 (gnulinux)
>

$ rosrun ocl rttlua-gnulinux
OROCOS RTTLua 1.0-beta3 / Lua 5.1.4 (gnulinux)
>

$ ./rttlua-gnulinux
OROCOS RTTLua 1.0-beta3 / Lua 5.1.4 (gnulinux)
> require("rttlib")
>

require("rttlib")
rttlib.color=true

> rttlib.stat()
Name                State               isActive  Period         
lua                 PreOperational      true      0              
Deployer            Stopped             true      0        

> rttlib.info()
services:   marshalling scripting print LuaTLSF Lua os
typekits:   rtt-corba-types rtt-mqueue-transport rtt-types OCLTypekit
types:      ConnPolicy FlowStatus PropertyBag SendHandle SendStatus TaskContext array bool
            bools char double float int ints rt_string string strings uint void
comp types: OCL::ConsoleReporting OCL::FileReporting OCL::HMIConsoleOutput OCL::HelloWorld
            OCL::LuaComponent OCL::LuaTLSFComponent OCL::TcpReporting
...

> tc = rtt.getTC()

> =tc
TaskContext: lua
state: PreOperational
isActive: true
getPeriod: 0
peers: Deployer
ports: 
properties:
   lua_string (string) =  // string of lua code to be executed during configureHook
   lua_file (string) =  // file with lua program to be executed during configuration
operations:
   bool exec_file(string const& filename) // load (and run) the given lua script
   bool exec_str(string const& lua-string) // evaluate the given string in the lua environment

alias rttlua='rlwrap -a -r -H ~/.rttlua-history rttlua-gnulinux'

> pin = rtt.InputPort("string")
> pout = rtt.OutputPort("string")
> =pin
 [in, string, unconn, local] // 
> =pout
 [out, string, unconn, local] // 

> tc:addPort(pin)
> tc:addPort(pout, "outport1", "string outport that contains latest X")
> =tc -- print tc interface to confirm it is there.

> =pin:connect(pout)
true
> return pin
 [in, string, conn, local] // 
> return pout
 [out, string, conn, local] // 
> 

> tc = rtt.getTC()
> depl = tc:getPeer("Deployer")
> cp=rtt.Variable("ConnPolicy")
> =cp
{data_size=0,type="DATA",name_id="",init=false,pull=false,transport=0,lock_policy="LOCK_FREE",size=0}
> depl:connect("compA.port1","compB.port2", cp)

> rttlib.info()
services:       marshalling, scripting, print, os, Lua
typekits:       rtt-types, rtt-mqueue-transport, OCLTypekit
types:          ConnPolicy, FlowStatus, PropertyBag, SendHandle, SendStatus, TaskContext,
                array, bool, bools, char, double, float, int, ints, rt_string, string, strings, uint, void
comp types:     OCL::ConsoleReporting, OCL::FileReporting, OCL::HMIConsoleOutput, 
                OCL::HelloWorld, OCL::LuaComponent, OCL::TcpReporting, OCL::TimerComponent,
                OCL::logging::Appender, OCL::logging::FileAppender,
                OCL::logging::LoggingService, OCL::logging::OstreamAppender, TaskContext

> cp = rtt.Variable("ConnPolicy")
> =cp
{data_size=0,type="DATA",name_id="",init=false,pull=false,transport="default",lock_policy="LOCK_FREE",size=0}
> cp.data_size = 4711
> print(cp.data_size)
4711

> =rtt.globals
{SendNotReady=SendNotReady,LOCK_FREE=2,NewData=NewData,SendFailure=SendFailure,\
SendSuccess=SendSuccess,NoData=NoData,UNSYNC=0,LOCKED=1,OldData=OldData,BUFFER=1,DATA=0}
> 

> =rtt.globals.LOCK_FREE
2

> tc = rtt.getTC()
> depl = tc:getPeer("Deployer")
> depl:import("kdl_typekit")
> t=rtt.Variable("KDL.Frame")
> =t
{M={Z_y=0,Y_y=1,X_y=0,Y_z=0,Z_z=1,Y_x=0,Z_x=0,X_x=1,X_z=0},p={Y=0,X=0,Z=0}}
> t.M.X_x=3
> t.M.Y_x=2
> t.M.Z_x=2.3
...

> t:fromtab({M={Z_y=1,Y_y=2,X_y=3,Y_z=4,Z_z=5,Y_x=6,Z_x=7,X_x=8,X_z=9},p={Y=3,X=3,Z=3}})

> t:fromtab{M={Z_y=1,Y_y=2,X_y=3,Y_z=4,Z_z=5,Y_x=6,Z_x=7,X_x=8,X_z=9},p={Y=3,X=3,Z=3}}

> ref=rtt.Variable("array")
> ref:resize(3)
> ref:fromtab{1,1,10}
> print(ref) -- prints {1,1,10}
...

> p1=rtt.Property("double", "p-gain", "Proportional controller gain")

> tc=rtt.getTC()
> tc:addProperty(p1)
> =tc -- check it is there...

> tc=rtt.getTC()
> pgain = tc:getProperty("pgain")
> =pgain -- will print it

> p1:set(3.14)
> =p1  -- a property can be printed!
p-gain (double) = 3.14 // Proportional controller gain

> p1=3.14

> print("the value of " .. p1:info().name .. " is: " .. p1:get())
the value of p-gain is: 3.14

> d = tc:getPeer("Deployer")
> d:import('kdl_typekit')
> f=rtt.Property('KDL.Frame')
> =f
 (KDL.Frame) = {M={Z_y=0,Y_y=1,X_y=0,Y_z=0,Z_z=1,Y_x=0,Z_x=0,X_x=1,X_z=0},p={Y=0,X=0,Z=0}} // 
> f.M.Y_y=3
> =f.M.Y_y
3
> f.p.Y=1
> =f
 (KDL.Frame) = {M={Z_y=0,Y_y=3,X_y=0,Y_z=0,Z_z=1,Y_x=0,Z_x=0,X_x=1,X_z=0},p={Y=1,X=0,Z=0}} // 
> 

> tc:removeProperty("p-gain")
> =tc         -- p-gain is gone now
> p1:delete() -- delete property and free memory
> =p1         -- p1 is 'dead' now.
userdata: 0x186f8c8

> d = tc:getPeer("Deployer")
> =d:getPeriod()
0

> d = tc:getPeer("Deployer")
> op = d:getOperation("getPeriod")
> =op -- can be printed!
double getPeriod() // Get the configured execution period. -1.0: no thread ...
> =op() -- call it
0

> d = tc:getPeer("Deployer")
> op = d:getOperation("getPeriod")
> handle=op:send() -- calling it
> =handle:collect()
SendSuccess    0

> tc=rtt.getTC()
> depl=tc:getPeer("Deployer")
> depl:loadService("lua", "marshalling") -- load the marshalling service in the lua component
true
> =tc:provides("marshalling"):writeProperties("props.cpf")
true

> -- get the writeProperties operation ...
> writeProps=tc:provides("marshalling"):getOperation("writeProperties")
> =writeProps("props.cpf") -- and call it to write the properties to a file.
true

> depl:loadService("lua", "marshalling") -- load the marshalling service
> depl:loadService("lua", "scripting") -- load the scripting service
> print(tc:provides())
Service: lua
   Subservices: marshalling, scripting
   Operations:  activate, cleanup, configure, error, exec_file, exec_str, getPeriod,
                inFatalError, inRunTimeError, isActive, isConfigured, isRunning,
                setPeriod, start, stop, trigger, update
   Ports:       
    Service: marshalling
       Subservices: 
       Operations:  loadProperties, readProperties, readProperty, storeProperties,
                    updateFile, updateProperties, writeProperties, writeProperty
       Ports:       
    Service: scripting
       Subservices: 
       Operations:  activateStateMachine, deactivateStateMachine, eval, execute, 
                    getProgramLine, getProgramList, getProgramStatus, getProgramStatusStr,
                    getProgramText, getStateMachineLine, getStateMachineList,
                    getStateMachineState, getStateMachineStatus, getStateMachineStatusStr,
                    getStateMachineText, hasProgram, hasStateMachine, inProgramError,
                    inStateMachineError, inStateMachineState, isProgramPaused, isProgramRunning,
                    isStateMachineActive, isStateMachinePaused, isStateMachineRunning,
                    loadProgramText, loadPrograms, loadStateMachineText, loadStateMachines,
                    pauseProgram, pauseStateMachine, requestStateMachineState, resetStateMachine,
                    runScript, startProgram, startStateMachine, stepProgram,
                    stopProgram, stopStateMachine, unloadProgram, unloadStateMachine
       Ports:       
> 

RTT::internal::GlobalService::Instance();

gs = rtt.provides()

gs:require("os") -- or: rtt.provides():require("os")

rtt.provides("os"):argc() -- returns the number of arguments of this application
rtt.provides("os"):argv() -- returns a string array of arguments of this application

-- create activity for producer: period=1, priority=0,
-- schedtype=ORO_SCHED_OTHER (1).
depl:setActivity("producer", 1, 0, rtt.globals.ORO_SCHED_RT)

-- create activity for producer: period=0, priority=0,
-- schedtype=ORO_SCHED_OTHER (1).
depl:setActivity("producer", 0, 0, rtt.globals.ORO_SCHED_RT)

depl:setMasterSlaveActivity("name_of_master_component", "name_of_slave_component")

-- deploy_app.lua
require("rttlib")
 
tc = rtt.getTC()
depl = tc:getPeer("Deployer")
 
-- import components, requires correctly setup RTT_COMPONENT_PATH
depl:import("ocl")
-- depl:import("componentX")
-- import components, requires correctly setup ROS_PACKAGE_PATH (>=Orocos 2.7)
depl:import("rtt_ros")
rtt.provides("ros"):import("my_ros_pkg")
 
 
-- create component 'hello'
depl:loadComponent("hello", "OCL::HelloWorld")
 
-- get reference to new peer
hello = depl:getPeer("hello")
 
-- create buffered connection of size 64
cp = rtt.Variable('ConnPolicy')
cp.type=1   -- type buffered
cp.size=64  -- buffer size
depl:connect("hello.the_results", "hello.the_buffer_port", cp)
rtt.logl('Info', "Deployment complete!")

$ rttlua-gnulinux -i deploy-app.lua

$ rosrun ocl rttlua-gnulinux -i deploy-app.lua

require("rttlib")
tc=rtt.getTC();
 
-- The Lua component starts its life in PreOperational, so
-- configureHook can be used to set stuff up.
function configureHook()
   inport = rtt.InputPort("string", "inport")    -- global variable!
   tc:addEventPort(inport)
   cnt = 0
   return true
end
 
-- all hooks are optional!
--function startHook() return true end
 
function updateHook()
   local fs, data = inport:read()
   rtt.log("data received: " .. tostring(data) .. ", flowstatus: " .. fs)
end
 
-- Ports and properties are the only elements which are not
-- automatically cleaned up. This means this must be done manually for
-- long living components:
function cleanupHook()
   tc:removePort("inport")
   inport:delete()
end

require "rttlib"
 
tc=rtt.getTC();
 
function configureHook()
   outport = rtt.OutputPort("string", "outport")    -- global variable!
   tc:addPort(outport)
   cnt = 0
   return true
end
 
function updateHook()
   outport:write("message number " .. cnt)
   cnt = cnt + 1
end
 
function cleanupHook()
   tc:removePort("outport")
   outport:delete()
end

require "rttlib"
 
rtt.setLogLevel("Warning")
tc=rtt.getTC()
depl = tc:getPeer("Deployer")
 
-- create LuaComponents
depl:loadComponent("producer", "OCL::LuaComponent")
depl:loadComponent("consumer", "OCL::LuaComponent")
 
--... and get references to them
producer = depl:getPeer("producer")
consumer = depl:getPeer("consumer")
 
-- load the Lua hooks
producer:exec_file("producer.lua")
consumer:exec_file("consumer.lua")
 
-- configure the components (so ports are created)
producer:configure()
consumer:configure()
 
-- connect ports
depl:connect("producer.outport", "consumer.inport", rtt.Variable('ConnPolicy'))
 
-- create activity for producer: period=1, priority=0,
-- schedtype=ORO_SCHED_OTHER (1).
depl:setActivity("producer", 1, 0, rtt.globals.ORO_SCHED_RT)
 
-- raise loglevel
rtt.setLogLevel("Debug")
 
-- start components 
consumer:start()
producer:start()
 
-- uncomment to print interface printing (for debugging)
-- print(consumer)
-- print(producer)
 
-- sleep for 5 seconds
os.execute("sleep 5")
 
-- lower loglevel again
rtt.setLogLevel("Warning")
 
producer:stop()
consumer:stop()

-- stupid example:
iface_spec = {
   ports={
      { name='inp', datatype='int', type='in+event', desc="incoming event port" },
      { name='msg', datatype='string', type='in', desc="incoming non-event messages" },
      { name='outp', datatype='int', type='out', desc="outgoing data port" },
   },
 
   properties={
      { name='inc', datatype='int', desc="this value is added to the incoming data each step" }
   }
}
 
-- this create the interface
iface=rttlib.create_if(iface_spec)
 
function configureHook()
   -- it is safe to be run twice, existing ports
   -- will be ignored. Thus, running cleanup() and configure()
   -- will reconstruct the interface again.
 
   iface=rttlib.create_if(iface_spec)
   inc = iface.props.inc:get()
   return true
end
 
function startHook()
   -- ports/props can be indexed as follows:
   iface.ports.outp:write(1)
   return true
end
 
function updateHook()
   local fs, val
   fs, val = iface.ports.inp:read()
   if fs=='NewData' then iface.ports.outp:write(val+inc) end
end
 
function cleanupHook()
   -- remove all ports and properties
   rttlib.tc_cleanup()
end

require "rttlib"
tc=rtt.getTC()
d = tc:getPeer("Deployer")
 
-- create a HelloWorld component
d:loadComponent("hello", "OCL::HelloWorld")
hello = d:getPeer("hello")
 
-- load Lua service into the HelloWorld Component
d:loadService("hello", "Lua")
 
-- Execute the following Lua script (defined a multiline string) in
-- the service. This dummy examples simply modifies the Property.  For
-- large programs it might be better tostore the program in a separate
-- file and use the exec_file operation instead.
proggie = [[
      require("rttlib")
      tc=rtt.getTC() -- this is the Hello Component
      prop = tc:getProperty("the_property")
      prop:set("hullo from the lua service!")
]]
 
prop = hello:getProperty("the_property") -- get hello.the_property
print("the_property before service call:", prop)
hello:provides("Lua"):exec_str(proggie) -- execute program in the service
print("the_property after service call: ", prop)

require "rttlib"
tc=rtt.getTC()
d = tc:getPeer("Deployer")
 
-- create a HelloWorld component
d:loadComponent("hello", "OCL::HelloWorld")
hello = d:getPeer("hello")
 
-- load Lua service into the HelloWorld Component
d:loadService("hello", "Lua")
 
mon_state = [[
      -- service-eehook.lua
      require("rttlib")
      tc=rtt.getTC() -- this is the Hello Component
      last_state = "not-running"
      out = rtt.OutputPort("string")
      tc:addPort(out, "tc_state", "currently active state of TaskContext")
 
      function check_state()
         local cur_state = tc:getState()
         if cur_state ~= last_state then
            out:write(cur_state)
            last_state = cur_state
         end
         return true -- returning false will disable EEHook
      end
 
      -- register check_state function to be called periodically and
      -- enable it. Important: variables like eehook below or the
      -- function check_state which shall not be garbage-collected
      -- after the first run must be declared global (by not declaring
      -- them local with the local keyword)
      eehook=rtt.EEHook('check_state')
      eehook:enable()
]]
 
-- execute the mon_state program
hello:provides("Lua"):exec_str(mon_state)

$ rttlua-gnulinux -i service-eehook.lua
> rttlib.portstats(hello)
the_results (string)  = 
the_buffer_port (string)  = NoData
tc_state (string)  = Running
> hello:error()
> rttlib.portstats(hello)
the_results (string)  = 
the_buffer_port (string)  = NoData
tc_state (string)  = RunTimeError
> 

function check_inport_conn(tc)
   local portnames = tc:getPortNames()
   local ret = true
   for _,pn in ipairs(portnames) do
      local p = tc:getPort(pn)
      local info = p:info()
      if info.porttype == 'in' and info.connected == false then
         rtt.logl('Error', "InputPort " .. tc:getName() .. "." .. info.name .. " is unconnected!")
         ret = false
      end
   end
   return ret
end

rttlib.mappeers(check_inport_conn, depl)

require "rttlib"
tc=rtt.getTC()
depl=tc:getPeer("Deployer")
 
-- define or import check_inport_conn function here
 
-- dummy deployment, ports are left unconnected.
depl:loadComponent("hello1", "OCL::HelloWorld")
depl:loadComponent("hello2", "OCL::HelloWorld")
 
rttlib.mappeers(check_inport_conn, depl)

0.155 [ ERROR  ][/home/mk/bin//rttlua-gnulinux::main()] InputPort hello1.the_buffer_port is unconnected!
0.155 [ ERROR  ][/home/mk/bin//rttlua-gnulinux::main()] InputPort hello2.the_buffer_port is unconnected!

require "rttlib"
require "rfsm"
require "rfsm_rtt"
require "rfsmpp"
 
local tc=rtt.getTC();
local fsm
local fqn_out, events_in
 
function configureHook()
   -- load state machine
   fsm = rfsm.init(rfsm.load("fsm.lua"))
 
   -- enable state entry and exit dbg output
   fsm.dbg=rfsmpp.gen_dbgcolor("rfsm-rtt-example", 
                   { STATE_ENTER=true, STATE_EXIT=true}, 
                   false)
 
   -- redirect rFSM output to rtt log
   fsm.info=function(...) rtt.logl('Info', table.concat({...}, ' ')) end
   fsm.warn=function(...) rtt.logl('Warning', table.concat({...}, ' ')) end
   fsm.err=function(...) rtt.logl('Error', table.concat({...}, ' ')) end
 
   -- the following creates a string input port, adds it as a event
   -- driven port to the Taskcontext. The third line generates a
   -- getevents function which returns all data on the current port as
   -- events. This function is called by the rFSM core to check for
   -- new events.
   events_in = rtt.InputPort("string")
   tc:addEventPort(events_in, "events", "rFSM event input port")
   fsm.getevents = rfsm_rtt.gen_read_str_events(events_in)
 
   -- optional: create a string port to which the currently active
   -- state of the FSM will be written. gen_write_fqn generates a
   -- function suitable to be added to the rFSM step hook to do this.
   fqn_out = rtt.OutputPort("string")
   tc:addPort(fqn_out, "rFSM_cur_fqn", "current active rFSM state")
   rfsm.post_step_hook_add(fsm, rfsm_rtt.gen_write_fqn(fqn_out))
   return true
end
 
function updateHook() rfsm.run(fsm) end
 
function cleanupHook()
   -- cleanup the created ports.
   rttlib.tc_cleanup()
end

return rfsm.state {
   ping = rfsm.state {
      entry=function() print("in ping entry") end,
   },
 
   pong = rfsm.state {
      entry=function() print("in pong entry") end,
   },
 
   rfsm.trans {src="initial", tgt="ping" },
   rfsm.trans {src="ping", tgt="pong", events={"e_pong"}},
   rfsm.trans {src="pong", tgt="ping", events={"e_ping"}},
}

-- alternate lua deploy script
require "rttlib"
 
tc=rtt.getTC()
d=tc:getPeer("Deployer")
 
d:import("ocl")
d:loadComponent("Supervisor", "OCL::LuaComponent")
sup = d:getPeer("Supervisor")
 
sup:exec_file("launch_fsm.lua")
sup:configure()
cmd = rttlib.port_clone_conn(sup:getPort("events"))

$ rosrun ocl rttlua-gnulinux -i deploy.lua
OROCOS RTTLua 1.0-beta3 / Lua 5.1.4 (gnulinux)
INFO: created undeclared connector root.initial
> sup:start()
> in ping entry
 
> cmd:write("e_pong")
> in pong entry
 
> cmd:write("e_ping")
> in ping entry
 
> cmd:write("e_pong")
> in pong entry

import("ocl")
loadComponent("Supervisor", "OCL::LuaComponent")
Supervisor.exec_file("launch_fsm.lua")
Supervisor.configure

$ rosrun ocl deployer-gnulinux -s deploy.ops
INFO: created undeclared connector root.initial
   Switched to : Deployer
 
  This console reader allows you to browse and manipulate TaskContexts.
  You can type in an operation, expression, create or change variables.
  (type 'help' for instructions and 'ls' for context info)
 
    TAB completion and HISTORY is available ('bash' like)
 
Deployer [S]> cd Supervisor 
 
TaskBrowser connects to all data ports of Supervisor
   Switched to : Supervisor
Supervisor [S]> start 
 = true                
 
Supervisor [R]> in ping entry
 
Supervisor [R]> leave 
 Watching Supervisor [R]> events.write ("e_pong")
 = (void)              
 
 Watching Supervisor [R]> in pong entry
 
 Watching Supervisor [R]> events.write ("e_ping")
 = (void)              
 
 Watching Supervisor [R]> in ping entry
 
 Watching Supervisor [R]> 

require "rfsm_rtt"
 
-- get reference to exec_str operation
fsmfile = "fsm.lua"
execstr_op = comp:provides("Lua"):getOperation("exec_str")
rfsm_rtt.service_launch_rfsm(fsmfile, execstr_op, true)

-- mother_fsm.lua is a basic fsm with 2 simple states
 
return rfsm.state {
 
   StateA = rfsm.state {
      entry=function() print("in state A") end,
   },
 
   StateB = rfsm.state {
      entry=function() print("in state B") end,
   },
 
-- consistent transition naming makes overriding easier
   rfsm.trans {src="initial", tgt="StateA" },
   tr_A_B = rfsm.trans {src="StateA", tgt="StateB", events={"e_mother_A_to_B"}},
   tr_B_A = rfsm.trans {src="StateB", tgt="StateA", events={"e_mother_B_to_A"}},
}

-- daughter_fsm.lua loads mother_fsm.lua
-- implementing extra states, transitions and functions
-- by adding and overriding the original ones.
 
require "utils"
require "rttros"
 
-- local variables to avoid verbose function calling
local state, trans, conn = rfsm.state, rfsm.trans, rfsm.conn
 
-- path to the fsm to load
local base_fsm_file = "mother_fsm.lua"
 
-- load the original fsm to override
local fsm_model=rfsm.load(base_fsm_file)
 
-- set colored outputs indicating the current state
dbg = rfsmpp.gen_dbgcolor( {STATE_ENTER=true}, false)
 
-- Overriding StateA 
-- In "mother_fsm.lua" StateA is an rfsm.simple_state
-- Here we make it an rfsm.composite_state
fsm_model.StateA = rfsm.state {
 
        StateA1= rfsm.state {
                entry=function() print("in State A1") end,
        },
 
        StateA2 = rfsm.state {
                entry=function() print("in State A2") end,
        },
 
        rfsm.transition {src="initial", tgt="StateA1"},
        tr_A1_A2 = rfsm.transition {src ="StateA1", tgt="StateA2", events={"e_move_to_A2"}},
        tr_A2_A1 = rfsm.transition {src ="StateA2", tgt="StateA1", events={"e_move_to_A1"}},
}
 
-- Overriding single transitions 
fsm_model.tr_A_to_B = rfsm.trans {src="StateA", tgt="StateB", events={"e_daughter_A_to_B"}}
fsm_model.tr_B_to_A = rfsm.trans {src="StateB", tgt="StateA", events={"e_daughter_B_to_A"}}
 
 
-- Overriding a specific function
fsm_model.StateB.entry = function()
                print("I am in State B in the daughter FSM")
        end
return fsm_model

require "rttlib"
require "rfsm"
require "rfsm_rtt"
require "rfsmpp"
 
local tc=rtt.getTC();
local fsm
local fqn_out, events_in
 
function configureHook()
   -- load state machine
   fsm = rfsm.init(rfsm.load("daughter_fsm.lua"))
 
   -- enable state entry and exit dbg output
   fsm.dbg=rfsmpp.gen_dbgcolor("FSM loading example",
                   { STATE_ENTER=true, STATE_EXIT=true},
                   false)
 
   -- redirect rFSM output to rtt log
   fsm.info=function(...) rtt.logl('Info', table.concat({...}, ' ')) end
   fsm.warn=function(...) rtt.logl('Warning', table.concat({...}, ' ')) end
   fsm.err=function(...) rtt.logl('Error', table.concat({...}, ' ')) end
 
   -- the following creates a string input port, adds it as a event
   -- driven port to the Taskcontext. The third line generates a
   -- getevents function which returns all data on the current port as
   -- events. This function is called by the rFSM core to check for
   -- new events.
   events_in = rtt.InputPort("string")
   tc:addEventPort(events_in, "events", "rFSM event input port")
   fsm.getevents = rfsm_rtt.gen_read_str_events(events_in)
 
   -- optional: create a string port to which the currently active
   -- state of the FSM will be written. gen_write_fqn generates a
   -- function suitable to be added to the rFSM step hook to do this.
   fqn_out = rtt.OutputPort("string")
   tc:addPort(fqn_out, "rFSM_cur_fqn", "current active rFSM state")
   rfsm.post_step_hook_add(fsm, rfsm_rtt.gen_write_fqn(fqn_out))
   return true
end 
 
function updateHook() rfsm.run(fsm) end
 
function cleanupHook()
   -- cleanup the created ports.
   rttlib.tc_cleanup()
end

import("ocl")
loadComponent("Supervisor", "OCL::LuaComponent")
Supervisor.exec_file("fsm_launcher.lua")
Supervisor.configure
Supervisor.start

rosrun ocl deployer-gnulinux -lerror -s deploy.ops

Deployer [S]> cd Supervisor
 
TaskBrowser connects to all data ports of Supervisor
   Switched to : Supervisor
Supervisor [R]> leave
 
Watching Supervisor [R]> events.write ("e_move_to_A2")
 
FSM loading example:    STATE_EXIT          root.StateA.StateA1
in State A2
FSM loading example:    STATE_ENTER         root.StateA.StateA2

peertab = rttlib.mappeers(function (tc) return tc end, depl)

print(peertab.robot)
-- or 
peertab.controller:configure()

> cp=rtt.Variable("ConnPolicy")
> cp.transport=3 -- 3 is ROS
> cp.name_id="/l_cart_twist/command" -- topic name
> depl:stream("CompX.portY", cp)

> depl:stream("CompX.portY", rtt.provides("ros"):topic("/l_cart_twist/command"))

> require "rttros"
> =rttros.find_rospack("geometry_msgs")
/home/mk/src/ros/unstable/common_msgs/geometry_msgs
> 

./rttlua-gnulinux
Orocos RTTLua 1.0-beta3 (gnulinux)
> return rtt.Variable("ConnPolicy")
{data_size=0,type=0,name_id="",init=false,pull=false,transport=0,lock_policy=2,size=0}

function ConnPolicy2tab(cp)
    if cp.type == 0 then cp.type = "DATA"
    elseif cp.type == 1 then cp.type = "BUFFER"
    else cp.type = tostring(cp.type) .. " (invalid!)" end
 
    if cp.lock_policy == 0 then cp.lock_policy = "UNSYNC"
    elseif cp.lock_policy == 1 then cp.lock_policy = "LOCKED"
    elseif cp.lock_policy == 2 then cp.lock_policy = "LOCK_FREE"
    else cp.lock_policy = tostring(cp.lock_policy) .. " (invalid!)" end
    return cp
end

rttlib.var_pp.ConnPolicy = ConnPolicy2tab

> return rtt.Variable("ConnPolicy")
{data_size=0,type="DATA",name_id="",init=false,pull=false,transport=0,lock_policy="LOCK_FREE",size=0}
>

cdeployer -s loadLua.ops

//load the lua service
loadService ("Deployer","Lua")
 
//execute your deployment file
Lua.exec_file("yourLuaDeploymentFile.lua")

$ <fsm_install_dir>/tools/rfsm-viz -f <your_fsm_file>.lua

cd $HOME
mkdir orocos
cd orocos
mkdir orocos-toolchain
cd orocos-toolchain
wget -O bootstrap-2.6.sh http://gitorious.org/orocos-toolchain/build/raw/toolchain-2.6:bootstrap.sh
sh bootstrap.sh
source env.sh

typegen
deployer-gnulinux
ctaskbrowser

# Updates to latest fixes of release branch:
autoproj update
# Builds the toolchain
autoproj build

cd $HOME
mkdir orocos
cd orocos
tar -xjvf /path/to/orocos-toolchain-<version>.tar.bz2
cd orocos-toolchain-<version>
./bootstrap_toolchain
source ./env.sh
autoproj build

autoproj update
autoproj build

autoproj switch-config branch=toolchain-2.3
autoproj update
autoproj build

autoproj update --reconfigure
autoproj build