roby 0.7

data/lib/roby/relations/influence.rb

@@ -0,0 +1,10 @@
+module Roby
+    module TaskStructure
+	relation :Influence, :child_name => 'influenced_task', :noinfo => true, :weak => true do
+	    def influenced_by(task)
+		add_influenced_task(task)
+	    end
+	end
+    end
+end
+

data/lib/roby/relations/planned_by.rb

@@ -0,0 +1,63 @@
+require 'roby/task'
+
+module Roby::TaskStructure
+    relation :PlannedBy, :child_name => :planning_task, 
+	:parent_name => :planned_task, :noinfo => true, :single_child => true do
+
+	# The set of tasks which are planned by this one
+	def planned_tasks; parent_objects(PlannedBy) end
+	# Set +task+ as the planning task of +self+
+        def planned_by(task, options = {})
+	    if old = planning_task
+		if options[:replace]
+		    remove_planning_task(old)
+		else
+		    raise ArgumentError, "this task already has a planner"
+		end
+	    end
+	    add_planning_task(task)
+        end
+    end
+
+    # Returns a set of PlanningFailedError exceptions for all abstract tasks
+    # for which planning has failed
+    def PlannedBy.check_planning(plan)
+	result = []
+	Roby::TaskStructure::PlannedBy.each_edge do |planned_task, planning_task, _|
+	    next unless plan == planning_task.plan && planning_task.failed?
+	    next unless planned_task.pending? && !planned_task.executable? && planned_task.self_owned?
+	    result << Roby::PlanningFailedError.new(planned_task, planning_task)
+	end
+
+	result
+    end
+end
+
+module Roby
+    # This exception is raised when a task is abstract, and its planner failed:
+    # the system will therefore not have a suitable executable development for
+    # this task, and this is a failure
+    class PlanningFailedError < LocalizedError
+	# The planning task
+	attr_reader :planned_task
+
+	def initialize(planned_task, planning_task)
+	    @planned_task = planned_task
+	    super(planning_task.terminal_event)
+	end
+
+	def message # :nodoc:
+	    msg = "failed to plan #{planned_task}.planned_by(#{failed_task}): failed with #{failure_point.symbol}"
+	    if failure_point.context
+		if failure_point.context.first.respond_to?(:full_message)
+		    msg << "\n" << failure_point.context.first.full_message
+		else
+		    msg << "(" << failure_point.context.first.to_s << ")"
+		end
+	    end
+	    msg
+	end
+    end
+    Control.structure_checks << TaskStructure::PlannedBy.method(:check_planning)
+end
+

data/lib/roby/robot.rb

@@ -0,0 +1,7 @@
+module Robot
+    class << self
+	attr_accessor :logger
+    end
+    extend Logger::Forward
+end
+

data/lib/roby/standard_errors.rb

@@ -0,0 +1,218 @@
+require 'pp'
+module Roby
+    # This kind of errors are generated during the plan execution, allowing to
+    # blame a fault on a plan object (#failure_point). The precise failure
+    # point is categorized in the #failed_event, #failed_generator and
+    # #failed_task. It is guaranteed that one of #failed_generator and
+    # #failed_task is non-nil.
+    class LocalizedError < RuntimeError
+        # The object describing the point of failure
+	attr_reader :failure_point
+        
+        # The objects of the given categories which are related to #failure_point
+        attr_reader :failed_event, :failed_generator, :failed_task
+
+        # Create a LocalizedError object with the given failure point
+        def initialize(failure_point)
+	    @failure_point = failure_point
+	    if failure_point.kind_of?(Event)
+		@failed_event = failure_point
+		@failed_generator = failure_point.generator
+	    elsif failure_point.kind_of?(EventGenerator)
+		@failed_generator = failure_point
+	    elsif failure_point.kind_of?(Task)
+		@failed_task = failure_point
+	    end
+
+	    if !@failed_task && @failed_generator && @failed_generator.respond_to?(:task)
+		@failed_task = failed_generator.task
+	    end
+	    if !@failed_task && !@failed_generator
+		raise ArgumentError, "cannot deduce a task and/or a generator from #{failure_point}"
+	    end
+
+            super("")
+	end
+
+        def pretty_print(pp)
+	    pp.text "#{self.class.name}"
+            if !message.empty?
+                pp.text ": #{message}"
+            end
+            pp.breakable
+            failure_point.pretty_print(pp)
+
+            if backtrace && !backtrace.empty?
+                Roby.pretty_print_backtrace(pp, backtrace)
+            end
+        end
+
+        # True if +obj+ is involved in this error
+        def involved_plan_object?(obj)
+            obj.kind_of?(PlanObject) && 
+                (obj == failed_event ||
+                 obj == failed_generator ||
+                 obj == failed_task)
+        end
+    end
+
+    # Raised during event propagation if a task event is called or emitted,
+    # while this task is not executable.
+    class TaskNotExecutable < LocalizedError; end
+    # Raised during event propagation if an event is called or emitted,
+    # while this event is not executable.
+    class EventNotExecutable < LocalizedError; end
+    # Raised during event propagation if an event is called, while this event
+    # is not controlable.
+    class EventNotControlable < LocalizedError; end
+
+    # Raised when an operation is attempted while the ownership does not allow
+    # it.
+    class OwnershipError < RuntimeError; end
+    class RemotePeerMismatch < RuntimeError; end
+
+    # Raised when a consistency check failed in the Roby internal code
+    class InternalError < RuntimeError; end
+    # Raised when a consistency check failed in the Roby propagation code
+    class PropagationError < InternalError; end
+
+    # Some operations need to be performed in the control thread, and some
+    # other (namely blocking operations) must not. This exception is raised
+    # when this constraint is not met.
+    class ThreadMismatch < RuntimeError; end
+
+    # Raised when a user-provided code block (i.e. a code block which is
+    # outside of Roby's plan management algorithms) has raised. This includes:
+    # event commands, event handlers, task polling blocks, ...
+    class CodeError < LocalizedError
+        # The original exception object
+	attr_reader :error
+        # Create a CodeError object from the given original exception object, and
+        # with the given failure point
+	def initialize(error, *args)
+	    if error && !error.kind_of?(Exception)
+		raise TypeError, "#{error} should be an exception"
+	    end
+	    super(*args)
+	    @error = error
+	end
+
+	def pretty_print(pp) # :nodoc:
+	    if error
+                pp.text "#{self.class.name}: user code raised an exception "
+                failure_point.pretty_print(pp)
+                pp.breakable
+                pp.breakable
+                error.pretty_print(pp)
+	    else
+		super
+	    end
+	end
+    end
+
+    # Raised if a command block has raised an exception
+    class CommandFailed < CodeError; end
+    # Raised when the call of an event has been canceled.
+    # See EventGenerator#cancel.
+    class EventCanceled < LocalizedError; end
+    # Raised when an event is called, but one of
+    # its precondition is not met. See EventGenerator#precondition
+    class EventPreconditionFailed < LocalizedError; end
+    # Raised when the emission of an event has failed.
+    # See EventGenerator#emit_failed.
+    class EmissionFailed < CodeError; end
+    # Raised when an event handler has raised.
+    class EventHandlerError < CodeError; end
+
+    # Raised when an exception handler has raised.
+    class FailedExceptionHandler < CodeError
+	attr_reader :handled_exception
+	def initialize(error, object, handled_exception)
+	    super(error, object)
+	    @handled_exception = handled_exception
+	end
+    end
+
+    # Raised when an event has become unreachable while other parts of the plan
+    # where waiting for its emission.
+    class UnreachableEvent < LocalizedError
+        # The generator which has become unreachable
+	attr_reader :generator
+        # Create an UnreachableEvent error for the given +generator+. +reason+
+        # is supposed to be either nil or a plan object which is the reason why
+        # +generator+ has become unreachable.
+	def initialize(generator, reason)
+	    @generator = generator
+	    super(reason || generator)
+	end
+
+	def pretty_print(pp) # :nodoc:
+            pp.text "#{generator} has become unreachable"
+	    if failure_point
+		pp.breakable ':'
+                failure_point.pretty_print(pp)
+            end
+	end
+    end
+    
+    # Exception raised when the event loop aborts because of an unhandled
+    # exception
+    class Aborting < RuntimeError
+	attr_reader :all_exceptions
+	def initialize(exceptions)
+            @all_exceptions = exceptions 
+            super("")
+        end
+        def pretty_print(pp) # :nodoc:
+            pp.text "control loop aborting because of unhandled exceptions"
+            pp.seplist(",") do
+                all_exceptions.pretty_print(pp)
+            end
+        end
+	def backtrace # :nodoc:
+            [] 
+        end
+    end
+
+    # Raised by Plan#replace when the new task cannot replace the older one.
+    class InvalidReplace < RuntimeError
+        # The task being replaced
+	attr_reader :from
+        # The task which should have replaced #from
+        attr_reader :to
+        # A description of the replacement failure
+        attr_reader :error
+
+        # Create a new InvalidReplace object
+	def initialize(from, to, error)
+	    @from, @to, @error = from, to, error
+	end
+        def pretty_print(pp) # :nodoc:
+            pp.text "invalid replacement: #{message}"
+            pp.breakable
+            pp.text "from "
+            from.pretty_print(pp)
+            pp.breakable
+            pp.text "to "
+            to.pretty_print(pp)
+        end
+    end
+    
+    # Exception raised when a mission has failed
+    class MissionFailedError < LocalizedError
+        # Create a new MissionFailedError for the given mission
+	def initialize(task)
+	    super(task.terminal_event)
+	end
+
+        def pretty_print(pp)
+            pp.text "mission failed: "
+            super
+        end
+    end
+
+    # Exception raised in threads which are waiting for the control thread
+    # See for instance Roby.execute
+    class ControlQuitError < RuntimeError; end
+end
+

data/lib/roby/state.rb

@@ -0,0 +1,5 @@
+require 'roby/state/state'
+require 'roby/state/events'
+require 'roby/state/pos'
+require 'roby/state/shapes'
+

data/lib/roby/state/events.rb

@@ -0,0 +1,221 @@
+
+module Roby
+    class StateSpace
+        # Create an event which will be emitted everytime some state parameters
+        # vary more than the given deltas. The following state parameters are
+        # available:
+        # +t+:: time in seconds
+        # +d+:: distance in meters
+        # +yaw+:: heading in radians
+        #
+        # For instance:
+        #   Roby.state.on_delta :d => 10, :t => 20
+        #
+        # will emit everytime the robot moves more than 10 meters AND more than
+        # 20 seconds have elapsed.
+        #
+        # If more than once specification is given, the resulting event is
+        # combined with the & operator. This can be changed by setting the :or
+        # option to 'true'.
+        #
+        #   Roby.state.on_delta :d => 10, :t => 20, :or => true
+        #
+        # See DeltaEvent and its subclasses.
+	def on_delta(spec)
+	    or_aggregate = spec.delete(:or)
+
+	    events = spec.map do |name, value|
+		unless klass = DeltaEvent.event_types[name]
+		    raise "unknown delta type #{name}. Known types are #{DeltaEvent.event_types.keys}"
+		end
+		
+		ev    = klass.new
+		ev.threshold = value
+		ev
+	    end
+
+	    if events.size > 1
+		result = if or_aggregate then OrGenerator.new
+			 else AndGenerator.new
+			 end
+
+		result.on { result.reset }
+		def result.or(spec); DeltaEvent.or(spec, self) end
+		events.each { |ev| result << ev }
+		result
+	    else
+		events.first
+	    end
+	end
+
+        # Returns an event which emits when the given state is reached.
+        # For now, the following state variables are available:
+        # +t+:: time as a Time object
+        #
+        # See TimePointEvent
+        def at(options)
+            options = validate_options options, :t => nil
+            if time = options[:t]
+                TimePointEvent.new(time)
+            end
+        end
+    end
+
+    # Registered on Control to call the #poll method of state events
+    def self.poll_state_events # :nodoc:
+        for ev in Roby.plan.free_events
+            if ev.kind_of?(StateEvent) && ev.enabled?
+                ev.poll
+            end
+        end
+    end
+    Roby::Control.each_cycle(&Roby.method(:poll_state_events))
+
+    # A state event is an event which emits when some parameters over the state
+    # are reached. See DeltaEvent and TimePointEvent.
+    class StateEvent < EventGenerator
+        # True if this event is currently active
+        def enabled?; !@disabled end
+        # True if this event is currently disabled
+        def disabled?; @disabled end
+        # Call to reenable this event. If +reset+ is true, the event is reset
+        # at the same time.
+        def enable(reset = true)
+            @disabled = false
+            self.reset if reset
+        end
+        # Call to disable this event. When the state events are disabled, they
+        # will no more emit.
+        def disable; @disabled = true end
+    end
+
+    # This event emits itself when the specified time is reached
+    class TimePointEvent < StateEvent
+        # Time at which this event should emit himself
+        attr_reader :time
+
+        # Creates an event which will emit when +time+ is reached
+        def initialize(time)
+            @time = time
+            super
+        end
+
+        # Called at each cycle by Roby.poll_state_events
+        def poll # :nodoc:
+            if !happened? && Time.now >= time
+                emit
+            end
+        end
+    end
+
+    # Generic implementation of events which emit when a given delta is reached
+    # in the state. Subclasses must implement the following methods:
+    #
+    # [<tt>#has_sample</tt>] 
+    #   must return true if the state variable can be read
+    # [<tt>#delta</tt>] 
+    #   must return the delta between the current value and the
+    #   value at the last emission (#last_value). The returned value
+    #   must be comparable with #threshold.
+    # [<tt>#read</tt>]
+    #   must return the current value.
+    class DeltaEvent < StateEvent
+	@@event_types = Hash.new
+        # The set of event types which 
+	def self.event_types; @@event_types end
+        # Declare that the currently defined delta event has to be registered
+        # as a +name+ option for StateSpace#on_delta. For instance, the TimeDeltaEvent
+        # is registered by using
+        # 
+        #   class TimeDeltaEvent < DeltaEvent
+        #     register_as :t
+        #   end
+        #
+        # which allows to use it with
+        #
+        #   Roby.state.on_delta :t => 10
+	def self.register_as(name)
+	    event_types[name] = self
+	end
+
+        # The last value for the considered state, the last time this event has
+        # been emitted
+	attr_reader   :last_value
+        # A value expressing the delta in state for which the event should be
+        # emitted.
+	attr_accessor :threshold
+
+        # Reset +last_value+ to the current value of the state variable,
+        # making the event emit at current_value + threshold
+	def reset
+	    @last_value = read
+	end
+
+	def self.or(spec, base_event)
+	    new = State.on_delta(spec)
+	    result = OrGenerator.new
+	    result << base_event
+	    result << new
+	    result.on { result.reset }
+	    def result.or(spec); DeltaEvent.or(spec, self) end
+	    result
+	end
+
+	def or(spec)
+	    DeltaEvent.or(spec, self)
+	end
+
+        # Called at each cycle by Roby.poll_state_events
+	def poll # :nodoc:
+	    if !has_sample?
+		return
+	    elsif !last_value
+		@last_value = read
+	    else
+		if delta.abs >= threshold
+		    reset
+		    emit(last_value)
+		end
+	    end
+	end
+    end
+
+    # An event which emits at a given period (delta in time)
+    class TimeDeltaEvent < DeltaEvent
+	register_as :t
+        # Always true, as we can always measure time
+	def has_sample?; true end
+        # Returns how much time elapsed since the last emission
+	def delta; Time.now - last_value end
+        # Returns the current time
+	def read;  Time.now end
+    end
+
+    # An event which emits everytime the robot heading moves more than a given
+    # angle (in radians)
+    class YawDeltaEvent < DeltaEvent
+	register_as :yaw
+        # True if State.pos is set
+	def has_sample?; State.pos? end
+        # Returns the variation in heading since the last emission (in radians)
+	def delta; State.pos.yaw - last_value end
+        # Returns the current heading position (in radians)
+	def read;  State.pos.yaw end
+    end
+
+    # An event which emits everytime the robot moves more than a given
+    # distance.
+    class PosDeltaEvent < DeltaEvent
+	register_as :d
+        # True if State.pos is set
+	def has_sample?; State.pos? end
+        # Returns the distance this the position at the last emission
+	def delta; State.pos.distance(last_value) end
+        # Returns the current position
+	def read;  State.pos.dup end
+    end
+end
+
+
+
+