SURF 2011: Receding Horizon Temporal Logic Planning Toolbox - Revision history

Necmiye at 14:54, 10 January 2011

2011-01-10T14:54:11Z

← Older revision		Revision as of 14:54, 10 January 2011
Line 3:		Line 3:
	* Co-Mentor: Ufuk Topcu		* Co-Mentor: Ufuk Topcu

	TuLiP (Receding Horizon Temporal Logic Planning Toolbox) is a collection of Python-based code for automatic synthesis of correct-by-construction embedded control software as discussed in [1, 2]. It combines ideas from control theory (reachability analysis, receding horizon control) and computer science (finite transition systems, linear temporal logic) to automatically synthesize a planner-controller hierarchy that guarantees to satisfy given linear temporal logic based specifications. TuLiP can be used in a wide range of applications such as autonomous driving, vehicle management systems in avionics and smart camera networks. Additional information and related references can be found at: www.cds.caltech.edu/tulip. However it is still in development stage and there is room for quite a bit of advancements. The goals of this project are:		TuLiP (Receding Horizon Temporal Logic Planning Toolbox) is a collection of Python-based code for automatic synthesis of correct-by-construction embedded control software as discussed in [1, 2]. It combines ideas from control theory (reachability analysis, receding horizon control) and computer science (finite transition systems, linear temporal logic) to automatically synthesize a planner-controller hierarchy that guarantees to satisfy given linear temporal logic based specifications. TuLiP can be used in a wide range of applications such as autonomous driving, vehicle management systems in avionics and smart camera networks. Additional information and related references can be found at: http://www.cds.caltech.edu/tulip/. However it is still in development stage and there is room for quite a bit of advancements. The goals of this project are:
	* To develop a visualization environment for simulating the results for application areas such as robot navigation and autonomous driving. It would be useful to have an interactive tool where the user can dynamically change the environment to see the response of the designed controller. One possibility for visualization is to integrate a tool like Player/Stage (available at http://playerstage.sourceforge. net/).		* To develop a visualization environment for simulating the results for application areas such as robot navigation and autonomous driving. It would be useful to have an interactive tool where the user can dynamically change the environment to see the response of the designed controller. One possibility for visualization is to integrate a tool like Player/Stage (available at http://playerstage.sourceforge.net/).
	* To develop a user interface to guide the designer in defining short horizon specifications. In particular, one should define a partial order among the sets of states based on their “closeness” to the goal state. Visualizing the finite state machine that models the system could help in finding such a partial order.		* To develop a user interface to guide the designer in defining short horizon specifications. In particular, one should define a partial order among the sets of states based on their “closeness” to the goal state. Visualizing the finite state machine that models the system could help in finding such a partial order.
	* To improve the discretization procedure used for abstraction. We would like to explore different possible representations of the regions in the partition (e.g. using zonotopes instead of polytopes).		* To improve the discretization procedure used for abstraction. We would like to explore different possible representations of the regions in the partition (e.g. using zonotopes instead of polytopes).
Line 12:		Line 12:

	'''References'''		'''References'''
	# T. Wongpiromsarn, U. Topcu, N. Ozay, H. Xu, and R. M. Murray, TuLiP: a software toolbox for receding horizon temporal logic planning, International Conference on ~~Hy- brid~~ Systems: Computation and Control, 2011 (to appear).		# T. Wongpiromsarn, U. Topcu, N. Ozay, H. Xu, and R. M. Murray, TuLiP: a software toolbox for receding horizon temporal logic planning, International Conference on Hybrid Systems: Computation and Control, 2011 (to appear).
	# T. Wongpiromsarn, U. Topcu, and R. M. Murray, Receding Horizon Temporal Logic Planning, IEEE Transactions on Automatic Control, 2010 (submitted).		# T. Wongpiromsarn, U. Topcu, and R. M. Murray, Receding Horizon Temporal Logic Planning, IEEE Transactions on Automatic Control, 2010 (submitted).

Utopcu at 06:34, 10 January 2011

2011-01-10T06:34:42Z

← Older revision		Revision as of 06:34, 10 January 2011
Line 3:		Line 3:
	* Co-Mentor: Ufuk Topcu		* Co-Mentor: Ufuk Topcu

	TuLiP (Receding Horizon Temporal Logic Planning Toolbox) is a collection of Python- based code for automatic synthesis of correct-by-construction embedded control software as discussed in [1, 2]. It combines ideas from control theory (reachability analysis, receding horizon control) and computer science (finite transition systems, linear temporal logic) to automatically synthesize a planner-controller hierarchy that guarantees to satisfy given linear temporal logic based specifications. TuLiP can be used in a wide range of applications such as autonomous driving, vehicle management systems in avionics and smart camera networks. Additional information and related references can be found at: www.cds.caltech.edu/tulip. However it is still in development stage and there is room for quite a bit of advancements. The goals of this project are:		TuLiP (Receding Horizon Temporal Logic Planning Toolbox) is a collection of Python-based code for automatic synthesis of correct-by-construction embedded control software as discussed in [1, 2]. It combines ideas from control theory (reachability analysis, receding horizon control) and computer science (finite transition systems, linear temporal logic) to automatically synthesize a planner-controller hierarchy that guarantees to satisfy given linear temporal logic based specifications. TuLiP can be used in a wide range of applications such as autonomous driving, vehicle management systems in avionics and smart camera networks. Additional information and related references can be found at: www.cds.caltech.edu/tulip. However it is still in development stage and there is room for quite a bit of advancements. The goals of this project are:
	* To develop a visualization environment for simulating the results for application ~~ar- eas~~ such as robot navigation and autonomous driving. It would be useful to have an interactive tool where the user can dynamically change the environment to see the response of the designed controller. One possibility for visualization is to integrate a tool like Player/Stage (available at http://playerstage.sourceforge. net/).		* To develop a visualization environment for simulating the results for application areas such as robot navigation and autonomous driving. It would be useful to have an interactive tool where the user can dynamically change the environment to see the response of the designed controller. One possibility for visualization is to integrate a tool like Player/Stage (available at http://playerstage.sourceforge. net/).
	* To develop a user interface to guide the designer ~~to define~~ short horizon ~~specifica- tions~~. In particular, one should define a partial order among the sets of states based on their “closeness” to the goal state. Visualizing the finite state machine that models the system could help in finding such a partial order.		* To develop a user interface to guide the designer in defining short horizon specifications. In particular, one should define a partial order among the sets of states based on their “closeness” to the goal state. Visualizing the finite state machine that models the system could help in finding such a partial order.
	* To improve the discretization procedure used for abstraction. We would like to ~~ex- plore~~ different possible representations of the regions in the partition (e.g. using zonotopes instead of polytopes).		* To improve the discretization procedure used for abstraction. We would like to explore different possible representations of the regions in the partition (e.g. using zonotopes instead of polytopes).
	* To explore/identify other possible extensions to TuLiP, its applications and ~~underly- ing~~ theory.		* To explore/identify other possible extensions to TuLiP, its applications and underlying theory.

	'''Required Skills:''' This project requires programming experience. The programming language underlying TuLiP is Python. The student is expected to know Python or to have enough programming experience to learn it in a short time.		'''Required Skills:''' This project requires programming experience. The programming language underlying TuLiP is Python. The student is expected to know Python or to have enough programming experience to learn it in a short time.

Utopcu at 06:32, 10 January 2011

2011-01-10T06:32:40Z

← Older revision		Revision as of 06:32, 10 January 2011
Line 3:		Line 3:
	* Co-Mentor: Ufuk Topcu		* Co-Mentor: Ufuk Topcu

	TuLiP (Receding Horizon Temporal Logic Planning Toolbox) is a collection of Python- based code for automatic synthesis of correct-by-construction embedded control software as discussed in [1, 2]. It combines ideas from control theory (reachability analysis, ~~re- ceding~~ horizon control) and computer science (finite transition systems, linear temporal logic) to automatically synthesize a planner-controller hierarchy that guarantees to satisfy given linear temporal logic based specifications. TuLiP can be used in a wide range of applications such as autonomous driving, vehicle management systems in avionics and smart camera networks. Additional information and related references can be found at: www.cds.caltech.edu/tulip. However it is still in development stage and there is room for quite a bit of advancements. The goals of this project are:		TuLiP (Receding Horizon Temporal Logic Planning Toolbox) is a collection of Python- based code for automatic synthesis of correct-by-construction embedded control software as discussed in [1, 2]. It combines ideas from control theory (reachability analysis, receding horizon control) and computer science (finite transition systems, linear temporal logic) to automatically synthesize a planner-controller hierarchy that guarantees to satisfy given linear temporal logic based specifications. TuLiP can be used in a wide range of applications such as autonomous driving, vehicle management systems in avionics and smart camera networks. Additional information and related references can be found at: www.cds.caltech.edu/tulip. However it is still in development stage and there is room for quite a bit of advancements. The goals of this project are:
	* To develop a visualization environment for simulating the results for application ar- eas such as robot navigation and autonomous driving. It would be useful to have an interactive tool where the user can dynamically change the environment to see the response of the designed controller. One possibility for visualization is to integrate a tool like Player/Stage (available at http://playerstage.sourceforge. net/).		* To develop a visualization environment for simulating the results for application ar- eas such as robot navigation and autonomous driving. It would be useful to have an interactive tool where the user can dynamically change the environment to see the response of the designed controller. One possibility for visualization is to integrate a tool like Player/Stage (available at http://playerstage.sourceforge. net/).
	* To develop a user interface to guide the designer to define short horizon specifica- tions. In particular, one should define a partial order among the sets of states based on their “closeness” to the goal state. Visualizing the finite state machine that models the system could help in finding such a partial order.		* To develop a user interface to guide the designer to define short horizon specifica- tions. In particular, one should define a partial order among the sets of states based on their “closeness” to the goal state. Visualizing the finite state machine that models the system could help in finding such a partial order.

Murray at 06:10, 10 January 2011

2011-01-10T06:10:55Z

@@ Line 1: / Line 1: @@
 TuLiP (Receding Horizon Temporal Logic Planning Toolbox) is a collection of Python- based code for automatic synthesis of correct-by-construction embedded control software as discussed in [1, 2]. It combines ideas from control theory (reachability analysis, re- ceding horizon control) and computer science (finite transition systems, linear temporal logic) to automatically synthesize a planner-controller hierarchy that guarantees to satisfy given linear temporal logic based specifications. TuLiP can be used in a wide range of applications such as autonomous driving, vehicle management systems in avionics and smart camera networks. Additional information and related references can be found at: www.cds.caltech.edu/tulip. However it is still in development stage and there is room for quite a bit of advancements. The goals of this project are:
 * To develop a visualization environment for simulating the results for application ar- eas such as robot navigation and autonomous driving. It would be useful to have an interactive tool where the user can dynamically change the environment to see the response of the designed controller. One possibility for visualization is to integrate a tool like Player/Stage (available at http://playerstage.sourceforge. net/).
@@ Line 6: / Line 10: @@
 '''Required Skills:'''	This project requires programming experience. The programming language underlying TuLiP is Python. The student is expected to know Python or to have enough programming experience to learn it in a short time.

Murray: Created page with 'TuLiP (Receding Horizon Temporal Logic Planning Toolbox) is a collection of Python- based code for automatic synthesis of correct-by-construction embedded control software as dis…'

2011-01-10T06:04:43Z

Created page with 'TuLiP (Receding Horizon Temporal Logic Planning Toolbox) is a collection of Python- based code for automatic synthesis of correct-by-construction embedded control software as dis…'

New page

TuLiP (Receding Horizon Temporal Logic Planning Toolbox) is a collection of Python- based code for automatic synthesis of correct-by-construction embedded control software as discussed in [1, 2]. It combines ideas from control theory (reachability analysis, re- ceding horizon control) and computer science (finite transition systems, linear temporal logic) to automatically synthesize a planner-controller hierarchy that guarantees to satisfy given linear temporal logic based specifications. TuLiP can be used in a wide range of applications such as autonomous driving, vehicle management systems in avionics and smart camera networks. Additional information and related references can be found at: www.cds.caltech.edu/tulip. However it is still in development stage and there is room for quite a bit of advancements. The goals of this project are:
* To develop a visualization environment for simulating the results for application ar- eas such as robot navigation and autonomous driving. It would be useful to have an interactive tool where the user can dynamically change the environment to see the response of the designed controller. One possibility for visualization is to integrate a tool like Player/Stage (available at http://playerstage.sourceforge. net/).
* To develop a user interface to guide the designer to define short horizon specifica- tions. In particular, one should define a partial order among the sets of states based on their “closeness” to the goal state. Visualizing the finite state machine that models the system could help in finding such a partial order.
* To improve the discretization procedure used for abstraction. We would like to ex- plore different possible representations of the regions in the partition (e.g. using zonotopes instead of polytopes).
* To explore/identify other possible extensions to TuLiP, its applications and underly- ing theory.

'''Required Skills:''' This project requires programming experience. The programming language underlying TuLiP is Python. The student is expected to know Python or to have enough programming experience to learn it in a short time.