On Jul 11, 2011, at 05:47 , Herman Bruyninckx wrote:

> On Mon, 11 Jul 2011, Steven Bellens wrote:
>
>> 2011/7/11 Dominick Vanthienen <dominick [dot] vanthienen [..] ...>:
>>> Hi,
>>>
>>> There is a way to get events IN a component with a statemachine by creating a port and write to it: something like
>>> events_in = rtt.InputPort("string")
>>> tc:addPort(events_in, "events_in", "rFSM event input port")
>>> fsm.getevents = rfsm_rtt.gen_read_events(events_in)
>>>
>>> But now I want to get the events OUT of a component with a statemachine ...
>>> I figure something like:
>>> events_out = rtt.OutputPort("string")
>>> tc:addPort(events_out, "_events_out", "current events in this FSM")
>>> rfsm_rtt.gen_write_events(events_out)
>>>
>>> but this doesn't exist yet?
>>
>>
>> Why would you want to do that? The statemachine should receive events
>> and take appropriate actions, but sending out new events, to where?
>> Another state machine?
>
> Of course! Hierarchical and parallel state machines are obvious FSM
> architectures to have.

Completely agreed. And this was, IMHO, the single most important thing that was available in v1, that was lost with the v2 transition. This is one of the primary reasons we have not upgraded to v2 - we can't live without this.
S

Hi Klaas,

On Mon, Jul 11, 2011 at 01:56:52PM +0200, Klaas Gadeyne wrote:
> Hi Markus, Hi Nick,
>
> > From: Markus Klotzbuecher <markus [dot] klotzbuecher [..] ...>
> > Subject: Re: [Orocos-Dev] getting events out the state machine
> > To: Dominick Vanthienen <dominick [dot] vanthienen [..] ...>
> > Cc: "orocos-dev [..] ..."
> >        <orocos-dev [..] ...>
> > Message-ID: <20110711094114.GD9795@PMA-10-048>
> > Content-Type: text/plain; charset=us-ascii
> >
> > On Mon, Jul 11, 2011 at 10:46:22AM +0200, Dominick Vanthienen wrote:
> >> Hi,
> >>
> >> There is a way to get events IN a component with a statemachine by creating a port and write to it: something like
> >>   events_in = rtt.InputPort("string")
> >>   tc:addPort(events_in, "events_in", "rFSM event input port")
> >>   fsm.getevents = rfsm_rtt.gen_read_events(events_in)
> >>
> >> But now I want to get the events OUT of a component with a statemachine ...
> >> I figure something like:
> >>   events_out = rtt.OutputPort("string")
> >>   tc:addPort(events_out, "_events_out", "current events in this FSM")
> >
> > So far this should work...
> >
> >>   rfsm_rtt.gen_write_events(events_out)
> >>
> >> but this doesn't exist yet?
> >
> > Indeed. There is no default mechanism to send out events.
>
> I definitely agree with the fact that raising an event should be part
> of the FSM metamodel!
>
> > Which events
> > precisely do you want get out? Only the ones you raised yourself, or
> > also the fsm internal (completion events)? For the first, to abstract
> > away from the port writing you can just create a "raise_event"
> > function yourself, for instance:
> >
> > --- Generate an event raising function.
> > -- The generated function accepts zero to many arguments and writes
> > -- them to the given port.
> > -- @param port outport to write events to
> > -- @return function to send events to the port
> > function gen_raise_event(port)
> >   return function (...) for
> >          _,e in ipairs{...} do port:write(e) end
> >    end
> > end
> >
> > raise_event=gen_raise_event(events_out)
> >
> > raise_event("e_1")
> > or multiple:
> >
> > raise_event("e_1", "e_2", "e3")
>
> I like this: It cleanly separates the semantics of the statemachine
> (raising events) from the mechanism it is implemented with in orocos
> (2.x), ie. using ports.
> Could you make the raise_event "call" by default part of your lua FSM
> (ie. adding it to the metamodel, instead of letting the user implement
> it him/herself?

That is something that would be done automatically if you choose to
run your FSM using the RTT skin...

Markus

On Mon, 11 Jul 2011, Klaas Gadeyne wrote:

> Hi Markus, Hi Nick,
>
>> From: Markus Klotzbuecher <markus [dot] klotzbuecher [..] ...>
>> Subject: Re: [Orocos-Dev] getting events out the state machine
>> To: Dominick Vanthienen <dominick [dot] vanthienen [..] ...>
>> Cc: "orocos-dev [..] ..."
>>        <orocos-dev [..] ...>
>> Message-ID: <20110711094114.GD9795@PMA-10-048>
>> Content-Type: text/plain; charset=us-ascii
>>
>> On Mon, Jul 11, 2011 at 10:46:22AM +0200, Dominick Vanthienen wrote:
>>> Hi,
>>>
>>> There is a way to get events IN a component with a statemachine by creating a port and write to it: something like
>>>   events_in = rtt.InputPort("string")
>>>   tc:addPort(events_in, "events_in", "rFSM event input port")
>>>   fsm.getevents = rfsm_rtt.gen_read_events(events_in)
>>>
>>> But now I want to get the events OUT of a component with a statemachine ...
>>> I figure something like:
>>>   events_out = rtt.OutputPort("string")
>>>   tc:addPort(events_out, "_events_out", "current events in this FSM")
>>
>> So far this should work...
>>
>>>   rfsm_rtt.gen_write_events(events_out)
>>>
>>> but this doesn't exist yet?
>>
>> Indeed. There is no default mechanism to send out events.
>
> I definitely agree with the fact that raising an event should be part
> of the FSM metamodel!
>
>> Which events
>> precisely do you want get out? Only the ones you raised yourself, or
>> also the fsm internal (completion events)? For the first, to abstract
>> away from the port writing you can just create a "raise_event"
>> function yourself, for instance:
>>
>> --- Generate an event raising function.
>> -- The generated function accepts zero to many arguments and writes
>> -- them to the given port.
>> -- @param port outport to write events to
>> -- @return function to send events to the port
>> function gen_raise_event(port)
>>   return function (...) for
>>          _,e in ipairs{...} do port:write(e) end
>>    end
>> end
>>
>> raise_event=gen_raise_event(events_out)
>>
>> raise_event("e_1")
>> or multiple:
>>
>> raise_event("e_1", "e_2", "e3")
>
> I like this: It cleanly separates the semantics of the statemachine
> (raising events) from the mechanism it is implemented with in orocos
> (2.x), ie. using ports.

+1

> Could you make the raise_event "call" by default part of your lua FSM
> (ie. adding it to the metamodel, instead of letting the user implement
> it him/herself?

What do you suggest exactly...?

> regards,
>
> Klaas

Herman

On Jul 11, 2011, at 07:56 , Klaas Gadeyne wrote:

> Hi Markus, Hi Nick,
>
>> From: Markus Klotzbuecher <markus [dot] klotzbuecher [..] ...>
>> Subject: Re: [Orocos-Dev] getting events out the state machine
>> To: Dominick Vanthienen <dominick [dot] vanthienen [..] ...>
>> Cc: "orocos-dev [..] ..."
>> <orocos-dev [..] ...>
>> Message-ID: <20110711094114.GD9795@PMA-10-048>
>> Content-Type: text/plain; charset=us-ascii
>>
>> On Mon, Jul 11, 2011 at 10:46:22AM +0200, Dominick Vanthienen wrote:
>>> Hi,
>>>
>>> There is a way to get events IN a component with a statemachine by creating a port and write to it: something like
>>> events_in = rtt.InputPort("string")
>>> tc:addPort(events_in, "events_in", "rFSM event input port")
>>> fsm.getevents = rfsm_rtt.gen_read_events(events_in)
>>>
>>> But now I want to get the events OUT of a component with a statemachine ...
>>> I figure something like:
>>> events_out = rtt.OutputPort("string")
>>> tc:addPort(events_out, "_events_out", "current events in this FSM")
>>
>> So far this should work...
>>
>>> rfsm_rtt.gen_write_events(events_out)
>>>
>>> but this doesn't exist yet?
>>
>> Indeed. There is no default mechanism to send out events.
>
> I definitely agree with the fact that raising an event should be part
> of the FSM metamodel!
>
>> Which events
>> precisely do you want get out? Only the ones you raised yourself, or
>> also the fsm internal (completion events)? For the first, to abstract
>> away from the port writing you can just create a "raise_event"
>> function yourself, for instance:
>>
>> --- Generate an event raising function.
>> -- The generated function accepts zero to many arguments and writes
>> -- them to the given port.
>> -- @param port outport to write events to
>> -- @return function to send events to the port
>> function gen_raise_event(port)
>> return function (...) for
>> _,e in ipairs{...} do port:write(e) end
>> end
>> end
>>
>> raise_event=gen_raise_event(events_out)
>>
>> raise_event("e_1")
>> or multiple:
>>
>> raise_event("e_1", "e_2", "e3")
>
> I like this: It cleanly separates the semantics of the statemachine
> (raising events) from the mechanism it is implemented with in orocos
> (2.x), ie. using ports.
> Could you make the raise_event "call" by default part of your lua FSM
> (ie. adding it to the metamodel, instead of letting the user implement
> it him/herself?
>
> regards,
>
> Klaas

The code outline above suggests that raising an event with parameters would be supported also, right? What would that code look like to the user?

raise_event("e_1", ???)

On Mon, Jul 11, 2011 at 12:08:45PM +0200, Dominick Vanthienen wrote:
>
>
> On 07/11/2011 11:41 AM, Markus Klotzbuecher wrote:
> > On Mon, Jul 11, 2011 at 10:46:22AM +0200, Dominick Vanthienen wrote:
> >> Hi,
> >>
> >> There is a way to get events IN a component with a statemachine by creating a port and write to it: something like
> >> events_in = rtt.InputPort("string")
> >> tc:addPort(events_in, "events_in", "rFSM event input port")
> >> fsm.getevents = rfsm_rtt.gen_read_events(events_in)
> >>
> >> But now I want to get the events OUT of a component with a statemachine ...
> >> I figure something like:
> >> events_out = rtt.OutputPort("string")
> >> tc:addPort(events_out, "_events_out", "current events in this FSM")
> > So far this should work...
> >
> >> rfsm_rtt.gen_write_events(events_out)
> >>
> >> but this doesn't exist yet?
> > Indeed. There is no default mechanism to send out events. Which events
> > precisely do you want get out? Only the ones you raised yourself, or
> > also the fsm internal (completion events)?
> What internal events do exist? e_done?
> That wouldn't make sense to send to another statemachine
> So I think I just need the events I raised myself

Currently AFAICR there are only the completion events. I'm sure there
are cases when it does make sense to distribute these too, but
probably not for fsm developers but rather for automatic generation of
parallel or hierarchical fsm graphs.

> > For the first, to abstract
> > away from the port writing you can just create a "raise_event"
> > function yourself, for instance:
> >
> > --- Generate an event raising function.
> > -- The generated function accepts zero to many arguments and writes
> > -- them to the given port.
> > -- @param port outport to write events to
> > -- @return function to send events to the port
> > function gen_raise_event(port)
> > return function (...) for
> > _,e in ipairs{...} do port:write(e) end
> > end
> > end
> >
> > raise_event=gen_raise_event(events_out)
> >
> > raise_event("e_1")
> > or multiple:
> >
> > raise_event("e_1", "e_2", "e3")
> This means that I have to make sure I do two things?:
> raise it internally: rfsm.send_events(fsm, "e_stopGlobal")
> raise it externally (=putting it on a port): what you described above ...

I would suggest to add it like below:

--- Generate an event raising function.
-- The generated function accepts zero to many arguments and writes
-- them to the given port and optionally to the internal queue of fsm.
-- @param port outport to write events to
-- @param fsm events are sent to this fsm's internal queue (optional)
-- @return function to send events to the port
function gen_raise_event(port, fsm)
return function (...) for
_,e in ipairs{...} do port:write(e) end
if fsm then send_events(fsm, ...) end
end
end

If you can confirm this works for you I'll add it to the
"rfsm_rtt.lua" helper module.

Markus