GICLWiki - User contributions [en]

Bio-Robotics Lab (Fall 2007)

2007-12-14T17:08:10Z

Pwt23:

[[Category:Bio Robots (Fall 2007)]]
[[Category:Fall 2007 classes]]

==Announcements==
* Here is the 5x10 Map. It is oriented vertically: http://gicl.cs.drexel.edu/wiki/Image:Cs_final_map_5_10_rect.txt

* 2007-12-05: Assignment 4, the LAST assignment, will be due (and demoed) on Friday, December 14th in the Hill Conference Room (Lebow 240) at 12:00pm
* 2007-11-14: [[BioInspiredRobotDesignAssignment4|Assignment 4]] is up and '''due Friday November 30, no later than 5pm'''. A sample map is here [[media:CS485-Assignment4.zip]]
** Some sample code from Gary Flake's Computational Beauty of Nature [[media:cbn-java.zip]]
** The environment is [[media:environment.txt|here]]
* 2007-11-09: There is an EXTENSION on Assignment #3. It is now due on Monday Nov. 12th, no later than 5:00pm.
* 2007-11-07: [[Fall2007BioInspiredRobotDesignAssignment3|Assignment 3]] is due at the end of this week 11/09
* 2007-10-23: Some sample code for XPM format is [[XPMSample|here]]. For more in-depth, you can read about it from [http://www.cs.drexel.edu/%7Edavid/Classes/CS430/HWs/Assignment1.html CS430/536 Graphics Assignment 1].
* 2007-10-15: [[Fall2007BioInspiredRobotDesignAssignment2|Assignment 2]] is up it is due anytime the week of '''October 22nd.'''
* 2007-10-15: Thanks to Brian Lutz for writing up some instructions for setting up [[Connecting_Roomba_to_Your_Computer#Linux|Bluetooth with Linux]]
* 2007-10-01: There is a small bug in roombacomm.jar where goBackward(dist) did not go backward. It is fixed in the jar file included in this '''[[Media:RoombaComm.zip |Roombacomm.zip file]]'''.

==Course Logistics==

Prerequisites: Permission of instructor. 
Class Time: M-W-F 14:00->14:50 
Class Location: UCross Rm 149 
Office Hours: UCROSS147 Wed and Fri 12-2pm and by appointment 
Course Instructor: [[William C. Regli]], Ph.D. 
Teaching Assistants: Peter Thai <pwt23@drexel.edu> and Duc Nguyen <dn53@drexel.edu> 
Instructor Contact: Email regli (at) drexel (DOT) edu (not that this will help keep the spammers away) 
Phone 215.895.6827; Office: UC 143

==Course Objectives and Outcomes==

The goal of this class is to learn how to create software to interact with devices embodied in the physical world. Students successfully completing this class will:
#understand the basic concepts of robotics (from a computer-science point of view), including kinematics, dynamics, actuators, controllers, etc;
#perform software development to control mobile robots (specifically iRobot Roombas);
#design experiments for robotic platforms;
#measure the effectiveness of a robotic system on a given problem;
#gain experience with biologically-inspired robotics techniques (swarming, biologically inspired design, etc)
#employ cyber-infrastructure (wikis, web, etc) and engineering informatics tools (CAD, simulation, MATLAB, Maple, Pro/E, SolidWorks, ACIS, etc) to better understand the relationship between virtual models and the real world

==Lectures==

{| border="1" cellpadding="2"
!width="75"|Date
!width="150"|Assignment
!width="150"|Topic
!width="150"|Summary Notes
!width="500"|Links and References
|-
|September 24
|
|
Intro to Robot Lab
|
[[Media:CS-Robot-Lab-Spring2007-Lec-1.ppt]]
|
|-
|
|
|Introduction to Robotics
|[[Media:Introduction_to_Robotics.ppt]]
|
|-
|September 26
|
|Simulation
|[[Media:Simulation_of_Robotic_Systems.ppt]]
|
|-
|September 26
|
|Simulation
|[[Media:Simulation_of_Robotic_Systems.ppt]]
|
|-
|Week of October 8th
|[http://gicl.cs.drexel.edu/wiki/Fall2007BioInspiredRobotDesignAssignment1 Assignment 1] due
|
|[[Robotics Videos]]
|
|-
|Week of October 15th
|
|SLAM
|[[Media:SLAM.ppt]]
|

|-
|October 22
|[http://gicl.cs.drexel.edu/wiki/Fall2007BioInspiredRobotDesignAssignment2 Assignment 2] due
|Grading Assignment 2
|
|
|-
|October 29
|
|Path Planning
|[[Media:Robot-Lab-Path-Planning.ppt]]
|
|-
|November 12
|[http://gicl.cs.drexel.edu/wiki/Fall2007BioInspiredRobotDesignAssignment3 Assignment 3] due
|
|
|
|-
|November 19
|
|
|Thanksgiving holiday, no class Wed 11/21 or Friday 11/23
|
|
|-
|November 26
|[[BioInspiredRobotDesignAssignment4]] is due 11/30 by 5pm
|
|
|}


==Text==

Required texts and readings: 
# [http://gicl.cs.drexel.edu/wiki-data/images/a/af/Brooks-representation.pdf Intelligence without Representation], Rodney Brooks.
# Flesh and Machines: How Robots Will Change Us (Paperback) by Rodney Brooks, Publisher: Vintage (February 4, 2003); ISBN-10: 037572527X.
# [http://www.cs.unc.edu/~welch/media/pdf/kalman_intro.pdf Introduction to the Kalman Filter] from UNC.
# [http://ocw.mit.edu/NR/rdonlyres/Aeronautics-and-Astronautics/16-412JSpring-2005/9D8DB59F-24EC-4B75-BA7A-F0916BAB2440/0/1aslam_blas_repo.pdf SLAM for Dummies]

Interested students may wish to examine the following textbooks:
*J.J. Craig. Introduction to Robotics: Mechanics and Control. Prentice Hall; 3rd edition, 2003.
*Kiyoshi Toko. Biomimetic Sensor Technology. Cambridge University Press, 2000.
*Karl Williams. Amphibionics: Build Your Own Biologically Inspired Reptilian Robot. McGraw-Hill/TAB Electronics, 2003.
*David Cook. Robot Building for Beginners. Apress, 2002.

==Grading==

The due dates are listed on the week by week breakdown of the course below. When an assignment is due on a particular date, that means the assignment is really due that week. You must arrange a time one of the TAs for this class, during the week the assignment is due in order to have your assignment evaluated and graded. As there are limited slots per TA session, it is best to schedule a time slot sooner rather than later. You also will have the opportunity to have your work graded after the lecture during the due week.

==Software==
Depending on the evolution of the class, students may have an opportunity to gain experience with a variety of computational tools, including MATLAB, SolidWorks, Pro/ENGINEER, ACIS, MAPLE, etc. Several research prototype tools may also be introduced for physics-based modeling, kinematics, etc.

[[Processing]] Setup

* A skeleton [[Media:CS511.zip|Eclipse Project]] to write full-fledged Java instead of Processing. Some directions [[Roomba/Eclipse|here]]
* [[Media:RoombaProject.zip |Another Eclipse Project]] - includes some classes from Lego Mindstorms [http://lejos.sourceforge.net Lejos Project] concerning subsumption architecture.
* Download Eclipse [http://www.eclipse.org here]

==Miscellaneous Resources==

Wiki page for Winter 2007 Roomba Lab:
[http://gicl.cs.drexel.edu/wiki/Category:Roomba_Design_Lab_%28Winter_2007%29]

Page from Spring 2007 Robotics Lab:
[http://gicl.cs.drexel.edu/wiki/Category:Roomba_Design_Lab_%28Winter_2007%29]

iRobot Create Forums: [http://createforums.irobot.com/]

Robotics Primer Workbook based around the Create [http://roboticsprimer.sourceforge.net/workbook/Main_Page]

Bio-Robotics Lab (Fall 2007)

2007-12-14T17:03:28Z

Pwt23:

[[Category:Bio Robots (Fall 2007)]]
[[Category:Fall 2007 classes]]

==Announcements==
* HERE IS THE 5x10 Map: http://gicl.cs.drexel.edu/wiki/Image:Cs_final_map_5_10_rect.txt

* 2007-12-05: Assignment 4, the LAST assignment, will be due (and demoed) on Friday, December 14th in the Hill Conference Room (Lebow 240) at 12:00pm
* 2007-11-14: [[BioInspiredRobotDesignAssignment4|Assignment 4]] is up and '''due Friday November 30, no later than 5pm'''. A sample map is here [[media:CS485-Assignment4.zip]]
** Some sample code from Gary Flake's Computational Beauty of Nature [[media:cbn-java.zip]]
** The environment is [[media:environment.txt|here]]
* 2007-11-09: There is an EXTENSION on Assignment #3. It is now due on Monday Nov. 12th, no later than 5:00pm.
* 2007-11-07: [[Fall2007BioInspiredRobotDesignAssignment3|Assignment 3]] is due at the end of this week 11/09
* 2007-10-23: Some sample code for XPM format is [[XPMSample|here]]. For more in-depth, you can read about it from [http://www.cs.drexel.edu/%7Edavid/Classes/CS430/HWs/Assignment1.html CS430/536 Graphics Assignment 1].
* 2007-10-15: [[Fall2007BioInspiredRobotDesignAssignment2|Assignment 2]] is up it is due anytime the week of '''October 22nd.'''
* 2007-10-15: Thanks to Brian Lutz for writing up some instructions for setting up [[Connecting_Roomba_to_Your_Computer#Linux|Bluetooth with Linux]]
* 2007-10-01: There is a small bug in roombacomm.jar where goBackward(dist) did not go backward. It is fixed in the jar file included in this '''[[Media:RoombaComm.zip |Roombacomm.zip file]]'''.

==Course Logistics==

Prerequisites: Permission of instructor. 
Class Time: M-W-F 14:00->14:50 
Class Location: UCross Rm 149 
Office Hours: UCROSS147 Wed and Fri 12-2pm and by appointment 
Course Instructor: [[William C. Regli]], Ph.D. 
Teaching Assistants: Peter Thai <pwt23@drexel.edu> and Duc Nguyen <dn53@drexel.edu> 
Instructor Contact: Email regli (at) drexel (DOT) edu (not that this will help keep the spammers away) 
Phone 215.895.6827; Office: UC 143

==Course Objectives and Outcomes==

The goal of this class is to learn how to create software to interact with devices embodied in the physical world. Students successfully completing this class will:
#understand the basic concepts of robotics (from a computer-science point of view), including kinematics, dynamics, actuators, controllers, etc;
#perform software development to control mobile robots (specifically iRobot Roombas);
#design experiments for robotic platforms;
#measure the effectiveness of a robotic system on a given problem;
#gain experience with biologically-inspired robotics techniques (swarming, biologically inspired design, etc)
#employ cyber-infrastructure (wikis, web, etc) and engineering informatics tools (CAD, simulation, MATLAB, Maple, Pro/E, SolidWorks, ACIS, etc) to better understand the relationship between virtual models and the real world

==Lectures==

{| border="1" cellpadding="2"
!width="75"|Date
!width="150"|Assignment
!width="150"|Topic
!width="150"|Summary Notes
!width="500"|Links and References
|-
|September 24
|
|
Intro to Robot Lab
|
[[Media:CS-Robot-Lab-Spring2007-Lec-1.ppt]]
|
|-
|
|
|Introduction to Robotics
|[[Media:Introduction_to_Robotics.ppt]]
|
|-
|September 26
|
|Simulation
|[[Media:Simulation_of_Robotic_Systems.ppt]]
|
|-
|September 26
|
|Simulation
|[[Media:Simulation_of_Robotic_Systems.ppt]]
|
|-
|Week of October 8th
|[http://gicl.cs.drexel.edu/wiki/Fall2007BioInspiredRobotDesignAssignment1 Assignment 1] due
|
|[[Robotics Videos]]
|
|-
|Week of October 15th
|
|SLAM
|[[Media:SLAM.ppt]]
|

|-
|October 22
|[http://gicl.cs.drexel.edu/wiki/Fall2007BioInspiredRobotDesignAssignment2 Assignment 2] due
|Grading Assignment 2
|
|
|-
|October 29
|
|Path Planning
|[[Media:Robot-Lab-Path-Planning.ppt]]
|
|-
|November 12
|[http://gicl.cs.drexel.edu/wiki/Fall2007BioInspiredRobotDesignAssignment3 Assignment 3] due
|
|
|
|-
|November 19
|
|
|Thanksgiving holiday, no class Wed 11/21 or Friday 11/23
|
|
|-
|November 26
|[[BioInspiredRobotDesignAssignment4]] is due 11/30 by 5pm
|
|
|}


==Text==

Required texts and readings: 
# [http://gicl.cs.drexel.edu/wiki-data/images/a/af/Brooks-representation.pdf Intelligence without Representation], Rodney Brooks.
# Flesh and Machines: How Robots Will Change Us (Paperback) by Rodney Brooks, Publisher: Vintage (February 4, 2003); ISBN-10: 037572527X.
# [http://www.cs.unc.edu/~welch/media/pdf/kalman_intro.pdf Introduction to the Kalman Filter] from UNC.
# [http://ocw.mit.edu/NR/rdonlyres/Aeronautics-and-Astronautics/16-412JSpring-2005/9D8DB59F-24EC-4B75-BA7A-F0916BAB2440/0/1aslam_blas_repo.pdf SLAM for Dummies]

Interested students may wish to examine the following textbooks:
*J.J. Craig. Introduction to Robotics: Mechanics and Control. Prentice Hall; 3rd edition, 2003.
*Kiyoshi Toko. Biomimetic Sensor Technology. Cambridge University Press, 2000.
*Karl Williams. Amphibionics: Build Your Own Biologically Inspired Reptilian Robot. McGraw-Hill/TAB Electronics, 2003.
*David Cook. Robot Building for Beginners. Apress, 2002.

==Grading==

The due dates are listed on the week by week breakdown of the course below. When an assignment is due on a particular date, that means the assignment is really due that week. You must arrange a time one of the TAs for this class, during the week the assignment is due in order to have your assignment evaluated and graded. As there are limited slots per TA session, it is best to schedule a time slot sooner rather than later. You also will have the opportunity to have your work graded after the lecture during the due week.

==Software==
Depending on the evolution of the class, students may have an opportunity to gain experience with a variety of computational tools, including MATLAB, SolidWorks, Pro/ENGINEER, ACIS, MAPLE, etc. Several research prototype tools may also be introduced for physics-based modeling, kinematics, etc.

[[Processing]] Setup

* A skeleton [[Media:CS511.zip|Eclipse Project]] to write full-fledged Java instead of Processing. Some directions [[Roomba/Eclipse|here]]
* [[Media:RoombaProject.zip |Another Eclipse Project]] - includes some classes from Lego Mindstorms [http://lejos.sourceforge.net Lejos Project] concerning subsumption architecture.
* Download Eclipse [http://www.eclipse.org here]

==Miscellaneous Resources==

Wiki page for Winter 2007 Roomba Lab:
[http://gicl.cs.drexel.edu/wiki/Category:Roomba_Design_Lab_%28Winter_2007%29]

Page from Spring 2007 Robotics Lab:
[http://gicl.cs.drexel.edu/wiki/Category:Roomba_Design_Lab_%28Winter_2007%29]

iRobot Create Forums: [http://createforums.irobot.com/]

Robotics Primer Workbook based around the Create [http://roboticsprimer.sourceforge.net/workbook/Main_Page]

File:Cs final map 5 10 rect.txt

2007-12-14T17:03:19Z

Pwt23:

Bio-Robotics Lab (Fall 2007)

2007-12-05T08:46:42Z

Pwt23:

[[Category:Bio Robots (Fall 2007)]]
[[Category:Fall 2007 classes]]

==Announcements==
* 2007-12-05: Assignment 4, the LAST assignment, will be due (and demoed) on Friday, December 14th in the Hill Conference Room (Lebow 240) at 12:00pm
* 2007-11-14: [[BioInspiredRobotDesignAssignment4|Assignment 4]] is up and '''due Friday November 30, no later than 5pm'''. A sample map is here [[media:CS485-Assignment4.zip]]
** Some sample code from Gary Flake's Computational Beauty of Nature [[media:cbn-java.zip]]
** The environment is [[media:environment.txt|here]]
* 2007-11-09: There is an EXTENSION on Assignment #3. It is now due on Monday Nov. 12th, no later than 5:00pm.
* 2007-11-07: [[Fall2007BioInspiredRobotDesignAssignment3|Assignment 3]] is due at the end of this week 11/09
* 2007-10-23: Some sample code for XPM format is [[XPMSample|here]]. For more in-depth, you can read about it from [http://www.cs.drexel.edu/%7Edavid/Classes/CS430/HWs/Assignment1.html CS430/536 Graphics Assignment 1].
* 2007-10-15: [[Fall2007BioInspiredRobotDesignAssignment2|Assignment 2]] is up it is due anytime the week of '''October 22nd.'''
* 2007-10-15: Thanks to Brian Lutz for writing up some instructions for setting up [[Connecting_Roomba_to_Your_Computer#Linux|Bluetooth with Linux]]
* 2007-10-01: There is a small bug in roombacomm.jar where goBackward(dist) did not go backward. It is fixed in the jar file included in this '''[[Media:RoombaComm.zip |Roombacomm.zip file]]'''.

==Course Logistics==

Prerequisites: Permission of instructor. 
Class Time: M-W-F 14:00->14:50 
Class Location: UCross Rm 149 
Office Hours: UCROSS147 Wed and Fri 12-2pm and by appointment 
Course Instructor: [[William C. Regli]], Ph.D. 
Teaching Assistants: Peter Thai <pwt23@drexel.edu> and Duc Nguyen <dn53@drexel.edu> 
Instructor Contact: Email regli (at) drexel (DOT) edu (not that this will help keep the spammers away) 
Phone 215.895.6827; Office: UC 143

==Course Objectives and Outcomes==

The goal of this class is to learn how to create software to interact with devices embodied in the physical world. Students successfully completing this class will:
#understand the basic concepts of robotics (from a computer-science point of view), including kinematics, dynamics, actuators, controllers, etc;
#perform software development to control mobile robots (specifically iRobot Roombas);
#design experiments for robotic platforms;
#measure the effectiveness of a robotic system on a given problem;
#gain experience with biologically-inspired robotics techniques (swarming, biologically inspired design, etc)
#employ cyber-infrastructure (wikis, web, etc) and engineering informatics tools (CAD, simulation, MATLAB, Maple, Pro/E, SolidWorks, ACIS, etc) to better understand the relationship between virtual models and the real world

==Lectures==

{| border="1" cellpadding="2"
!width="75"|Date
!width="150"|Assignment
!width="150"|Topic
!width="150"|Summary Notes
!width="500"|Links and References
|-
|September 24
|
|
Intro to Robot Lab
|
[[Media:CS-Robot-Lab-Spring2007-Lec-1.ppt]]
|
|-
|
|
|Introduction to Robotics
|[[Media:Introduction_to_Robotics.ppt]]
|
|-
|September 26
|
|Simulation
|[[Media:Simulation_of_Robotic_Systems.ppt]]
|
|-
|September 26
|
|Simulation
|[[Media:Simulation_of_Robotic_Systems.ppt]]
|
|-
|Week of October 8th
|[http://gicl.cs.drexel.edu/wiki/Fall2007BioInspiredRobotDesignAssignment1 Assignment 1] due
|
|[[Robotics Videos]]
|
|-
|Week of October 15th
|
|SLAM
|[[Media:SLAM.ppt]]
|

|-
|October 22
|[http://gicl.cs.drexel.edu/wiki/Fall2007BioInspiredRobotDesignAssignment2 Assignment 2] due
|Grading Assignment 2
|
|
|-
|October 29
|
|Path Planning
|[[Media:Robot-Lab-Path-Planning.ppt]]
|
|-
|November 12
|[http://gicl.cs.drexel.edu/wiki/Fall2007BioInspiredRobotDesignAssignment3 Assignment 3] due
|
|
|
|-
|November 19
|
|
|Thanksgiving holiday, no class Wed 11/21 or Friday 11/23
|
|
|-
|November 26
|[[BioInspiredRobotDesignAssignment4]] is due 11/30 by 5pm
|
|
|}


==Text==

Required texts and readings: 
# [http://gicl.cs.drexel.edu/wiki-data/images/a/af/Brooks-representation.pdf Intelligence without Representation], Rodney Brooks.
# Flesh and Machines: How Robots Will Change Us (Paperback) by Rodney Brooks, Publisher: Vintage (February 4, 2003); ISBN-10: 037572527X.
# [http://www.cs.unc.edu/~welch/media/pdf/kalman_intro.pdf Introduction to the Kalman Filter] from UNC.
# [http://ocw.mit.edu/NR/rdonlyres/Aeronautics-and-Astronautics/16-412JSpring-2005/9D8DB59F-24EC-4B75-BA7A-F0916BAB2440/0/1aslam_blas_repo.pdf SLAM for Dummies]

Interested students may wish to examine the following textbooks:
*J.J. Craig. Introduction to Robotics: Mechanics and Control. Prentice Hall; 3rd edition, 2003.
*Kiyoshi Toko. Biomimetic Sensor Technology. Cambridge University Press, 2000.
*Karl Williams. Amphibionics: Build Your Own Biologically Inspired Reptilian Robot. McGraw-Hill/TAB Electronics, 2003.
*David Cook. Robot Building for Beginners. Apress, 2002.

==Grading==

The due dates are listed on the week by week breakdown of the course below. When an assignment is due on a particular date, that means the assignment is really due that week. You must arrange a time one of the TAs for this class, during the week the assignment is due in order to have your assignment evaluated and graded. As there are limited slots per TA session, it is best to schedule a time slot sooner rather than later. You also will have the opportunity to have your work graded after the lecture during the due week.

==Software==
Depending on the evolution of the class, students may have an opportunity to gain experience with a variety of computational tools, including MATLAB, SolidWorks, Pro/ENGINEER, ACIS, MAPLE, etc. Several research prototype tools may also be introduced for physics-based modeling, kinematics, etc.

[[Processing]] Setup

* A skeleton [[Media:CS511.zip|Eclipse Project]] to write full-fledged Java instead of Processing. Some directions [[Roomba/Eclipse|here]]
* [[Media:RoombaProject.zip |Another Eclipse Project]] - includes some classes from Lego Mindstorms [http://lejos.sourceforge.net Lejos Project] concerning subsumption architecture.
* Download Eclipse [http://www.eclipse.org here]

==Miscellaneous Resources==

Wiki page for Winter 2007 Roomba Lab:
[http://gicl.cs.drexel.edu/wiki/Category:Roomba_Design_Lab_%28Winter_2007%29]

Page from Spring 2007 Robotics Lab:
[http://gicl.cs.drexel.edu/wiki/Category:Roomba_Design_Lab_%28Winter_2007%29]

iRobot Create Forums: [http://createforums.irobot.com/]

Robotics Primer Workbook based around the Create [http://roboticsprimer.sourceforge.net/workbook/Main_Page]

Bio-Robotics Lab (Fall 2007)

2007-11-13T00:01:31Z

Pwt23:

[[Category:Bio Robots (Fall 2007)]]
[[Category:Fall 2007 classes]]

==Announcements==
* 2007-11-09: There is an EXTENSION on Assignment #3. It is now due on Monday Nov. 12th, no later than 5:00pm.
* 2007-11-07: [[Fall2007BioInspiredRobotDesignAssignment3|Assignment 3]] is due at the end of this week 11/09
* 2007-10-23: Some sample code for XPM format is [[XPMSample|here]]. For more in-depth, you can read about it from [http://www.cs.drexel.edu/%7Edavid/Classes/CS430/HWs/Assignment1.html CS430/536 Graphics Assignment 1].
* 2007-10-15: [[Fall2007BioInspiredRobotDesignAssignment2|Assignment 2]] is up it is due anytime the week of '''October 22nd.'''
* 2007-10-15: Thanks to Brian Lutz for writing up some instructions for setting up [[Connecting_Roomba_to_Your_Computer#Linux|Bluetooth with Linux]]
* 2007-10-01: There is a small bug in roombacomm.jar where goBackward(dist) did not go backward. It is fixed in the jar file included in this '''[[Media:RoombaComm.zip |Roombacomm.zip file]]'''.

==Course Logistics==

Prerequisites: Permission of instructor. 
Class Time: M-W-F 14:00->14:50 
Class Location: UCross Rm 149 
Office Hours: UCROSS147 Wed and Fri 12-2pm and by appointment 
Course Instructor: [[William C. Regli]], Ph.D. 
Teaching Assistants: Peter Thai <pwt23@drexel.edu> and Duc Nguyen <dn53@drexel.edu> 
Instructor Contact: Email regli (at) drexel (DOT) edu (not that this will help keep the spammers away) 
Phone 215.895.6827; Office: UC 143

==Course Objectives and Outcomes==

The goal of this class is to learn how to create software to interact with devices embodied in the physical world. Students successfully completing this class will:
#understand the basic concepts of robotics (from a computer-science point of view), including kinematics, dynamics, actuators, controllers, etc;
#perform software development to control mobile robots (specifically iRobot Roombas);
#design experiments for robotic platforms;
#measure the effectiveness of a robotic system on a given problem;
#gain experience with biologically-inspired robotics techniques (swarming, biologically inspired design, etc)
#employ cyber-infrastructure (wikis, web, etc) and engineering informatics tools (CAD, simulation, MATLAB, Maple, Pro/E, SolidWorks, ACIS, etc) to better understand the relationship between virtual models and the real world

==Lectures==

{| border="1" cellpadding="2"
!width="75"|Date
!width="150"|Assignment
!width="150"|Topic
!width="150"|Summary Notes
!width="500"|Links and References
|-
|September 24
|
|
Intro to Robot Lab
|
[[Media:CS-Robot-Lab-Spring2007-Lec-1.ppt]]
|
|-
|
|
|Introduction to Robotics
|[[Media:Introduction_to_Robotics.ppt]]
|
|-
|September 26
|
|Simulation
|[[Media:Simulation_of_Robotic_Systems.ppt]]
|
|-
|September 26
|
|Simulation
|[[Media:Simulation_of_Robotic_Systems.ppt]]
|
|-
|Week of October 8th
|[http://gicl.cs.drexel.edu/wiki/Fall2007BioInspiredRobotDesignAssignment1 Assignment 1] due
|
|[[Robotics Videos]]
|
|-
|Week of October 15th
|
|SLAM
|[[Media:SLAM.ppt]]
|

|-
|October 22
|[http://gicl.cs.drexel.edu/wiki/Fall2007BioInspiredRobotDesignAssignment2 Assignment 2] due
|Grading Assignment 2
|
|
|-
|October 29
|
|Path Planning
|[[Media:Robot-Lab-Path-Planning.ppt]]
|
|-
|November 12
|[http://gicl.cs.drexel.edu/wiki/Fall2007BioInspiredRobotDesignAssignment3 Assignment 3] due
|
|
|
|-
|November 19
|
|
|Thanksgiving holiday, no class Wed 11/21 or Friday 11/23
|
|
|-
|November 26
|[[BioInspiredRobotDesignAssignment4]] is due 11/30 by 5pm
|
|
|}


==Text==

Required texts and readings: 
# [http://gicl.cs.drexel.edu/wiki-data/images/a/af/Brooks-representation.pdf Intelligence without Representation], Rodney Brooks.
# Flesh and Machines: How Robots Will Change Us (Paperback) by Rodney Brooks, Publisher: Vintage (February 4, 2003); ISBN-10: 037572527X.
# [http://www.cs.unc.edu/~welch/media/pdf/kalman_intro.pdf Introduction to the Kalman Filter] from UNC.
# [http://ocw.mit.edu/NR/rdonlyres/Aeronautics-and-Astronautics/16-412JSpring-2005/9D8DB59F-24EC-4B75-BA7A-F0916BAB2440/0/1aslam_blas_repo.pdf SLAM for Dummies]

Interested students may wish to examine the following textbooks:
*J.J. Craig. Introduction to Robotics: Mechanics and Control. Prentice Hall; 3rd edition, 2003.
*Kiyoshi Toko. Biomimetic Sensor Technology. Cambridge University Press, 2000.
*Karl Williams. Amphibionics: Build Your Own Biologically Inspired Reptilian Robot. McGraw-Hill/TAB Electronics, 2003.
*David Cook. Robot Building for Beginners. Apress, 2002.

==Grading==

The due dates are listed on the week by week breakdown of the course below. When an assignment is due on a particular date, that means the assignment is really due that week. You must arrange a time one of the TAs for this class, during the week the assignment is due in order to have your assignment evaluated and graded. As there are limited slots per TA session, it is best to schedule a time slot sooner rather than later. You also will have the opportunity to have your work graded after the lecture during the due week.

==Software==
Depending on the evolution of the class, students may have an opportunity to gain experience with a variety of computational tools, including MATLAB, SolidWorks, Pro/ENGINEER, ACIS, MAPLE, etc. Several research prototype tools may also be introduced for physics-based modeling, kinematics, etc.

[[Processing]] Setup

* A skeleton [[Media:CS511.zip|Eclipse Project]] to write full-fledged Java instead of Processing. Some directions [[Roomba/Eclipse|here]]
* [[Media:RoombaProject.zip |Another Eclipse Project]] - includes some classes from Lego Mindstorms [http://lejos.sourceforge.net Lejos Project] concerning subsumption architecture.
* Download Eclipse [http://www.eclipse.org here]

==Miscellaneous Resources==

Wiki page for Winter 2007 Roomba Lab:
[http://gicl.cs.drexel.edu/wiki/Category:Roomba_Design_Lab_%28Winter_2007%29]

Page from Spring 2007 Robotics Lab:
[http://gicl.cs.drexel.edu/wiki/Category:Roomba_Design_Lab_%28Winter_2007%29]

iRobot Create Forums: [http://createforums.irobot.com/]

Robotics Primer Workbook based around the Create [http://roboticsprimer.sourceforge.net/workbook/Main_Page]

BioInspiredRobotDesignAssignment4

2007-11-12T23:57:24Z

Pwt23: /* Virtual Pheromone */

[[Category:Bio Robots (Fall 2007)]]

=Overview=
Using only simple behaviors, we want to program our Creates to seek out and bring food back to a home base. At the outset, your robot will begin its search for food by performing random movements and leaving a pheromone in each location visited. Your robot will be working alone and must perform 3 iterations of finding food then returning home.

[[Image:SystemArchitecture.png|robot find food... mmmm|center|500px]]

=Goal=
Program the Creates such that they can search and find virtual food using only simple behaviors such as:
* local movements
** limited memory (i.e. only know the current location and none of the previous locations). The robot will not be allowed to perform path planning or use any memory other than the virtual environment map.
** maintain current location in memory
* try to avoid walls using the virtual map (otherwise the internal odometry could be thrown off).
* read pheromone
* pick up food
* leave pheromone

=Details=
The robot will begin by searching for food. This will be done via some sort of searching algorithm. As the robot moves, it will leave pheromones at each spot it has visited. To model decay, these pheromones keep track of the elapsed time since since you left the pheromone.

Once food is found, the robot will return to its original place (the colony) by following the pheromones that are the oldest (why is that?).

When the robot has navigated back to the colony, it must again follow a pheromone back to the food (can you figure out which ones?) and return back to the colony.


==Food==
Virtual walls are what our ants will use as food. When our Create encounters a virtual wall, it will "pick up food", then return home by following it's original pheromone trail while leaving pheromones for the other robots to find. They will be positioned from above with the IR beam pointing downward to simulate the effect of a food source. There will be two virtual walls, symbolizing two food sources.

==Virtual Pheromone==
Once a robot encounters a virtual wall, it will begin its journey home leaving a pheromone trail in the virtual environment. Leaving a virtual pheromone in the environment is accomplished by sending a location to the Environment Java Class.

Your robot will determine the pheromone trail by querying the map for cells in close proximity with its current location. The pheromones will return values based on the last time you have visited the current location. For example, a pheromone on space X will return 999 if you have left a pheromone there 10 minutes ago while a pheromone will return 10 if you had just recently visited that location.

==Map==

We will be providing you an Environment Java class that the robot will use to represent the hallway. Do not edit this class. Your robot may use the following methods from <code>Environment</code>:

* Return a Pheromone value at this cell location.
:<code>long getPheromone(int x_, int y_)</code>
* Leaves a pheromone value at this cell location.
:<code>void leavePheromone(int x_, int y_);</code>
* Returns whether the cell location has a colony in it
: boolean isColony(int x_, int y_)
* Returns whether the cell location is an obstacle (ie. a wall)
: boolean isObstacle(int x_, int y_)

The map is also able to print the current state of the world in an XPM format. The pheromone trail is color coded where red spaces is where the robot has traveled most recently and blue is least recently. The following method will allow you to draw the map:

* <code>void drawEnvironment(String outputFileName);</code>


=Notes=
* You MUST use the pheromones to navigate your robot to the food source and back to the colony. Use of map probing or other god-like techniques will result in grade deduction. Remember, you are programming like you are the ant. Be like ant, my friend.

=Administrative=
* We will provide Java skeleton code as a framework for build the specific behaviors.

The students are responsible for turning in:
* A final environment map
* Source code
* A 2 page write up of the assignment
** Approach and implementation
** What worked/didn't work
** Possible other approaches
** References

=References=
* Dorigo, M. and Caro, G.D. and Gambardella, L.M., Ant Algorithms for Discrete Optimization, Artificial Life, 1999 vol 5 no. 2, pp 137-172.

BioInspiredRobotDesignAssignment4

2007-11-12T23:55:12Z

Pwt23:

[[Category:Bio Robots (Fall 2007)]]

=Overview=
Using only simple behaviors, we want to program our Creates to seek out and bring food back to a home base. At the outset, your robot will begin its search for food by performing random movements and leaving a pheromone in each location visited. Your robot will be working alone and must perform 3 iterations of finding food then returning home.

[[Image:SystemArchitecture.png|robot find food... mmmm|center|500px]]

=Goal=
Program the Creates such that they can search and find virtual food using only simple behaviors such as:
* local movements
** limited memory (i.e. only know the current location and none of the previous locations). The robot will not be allowed to perform path planning or use any memory other than the virtual environment map.
** maintain current location in memory
* try to avoid walls using the virtual map (otherwise the internal odometry could be thrown off).
* read pheromone
* pick up food
* leave pheromone

=Details=
The robot will begin by searching for food. This will be done via some sort of searching algorithm. As the robot moves, it will leave pheromones at each spot it has visited. To model decay, these pheromones keep track of the elapsed time since since you left the pheromone.

Once food is found, the robot will return to its original place (the colony) by following the pheromones that are the oldest (why is that?).

When the robot has navigated back to the colony, it must again follow a pheromone back to the food (can you figure out which ones?) and return back to the colony.


==Food==
Virtual walls are what our ants will use as food. When our Create encounters a virtual wall, it will "pick up food", then return home by following it's original pheromone trail while leaving pheromones for the other robots to find. They will be positioned from above with the IR beam pointing downward to simulate the effect of a food source. There will be two virtual walls, symbolizing two food sources.

==Virtual Pheromone==
Once a robot encounters a virtual wall, it will begin its journey home leaving a pheromone trail in the virtual environment. Leaving a virtual pheromone in the environment is accomplished by sending a location to the Environment Java Class.

Other robots will determine if there is a pheromone trail by querying the map with its current location. The pheromones will return values based on the last time you have visited the current location. For example, a pheromone on space X will return 999 if you have left a pheromone there 10 minutes ago while a pheromone will return 10 if you had just recently visited that location.

==Map==

We will be providing you an Environment Java class that the robot will use to represent the hallway. Do not edit this class. Your robot may use the following methods from <code>Environment</code>:

* Return a Pheromone value at this cell location.
:<code>long getPheromone(int x_, int y_)</code>
* Leaves a pheromone value at this cell location.
:<code>void leavePheromone(int x_, int y_);</code>
* Returns whether the cell location has a colony in it
: boolean isColony(int x_, int y_)
* Returns whether the cell location is an obstacle (ie. a wall)
: boolean isObstacle(int x_, int y_)

The map is also able to print the current state of the world in an XPM format. The pheromone trail is color coded where red spaces is where the robot has traveled most recently and blue is least recently. The following method will allow you to draw the map:

* <code>void drawEnvironment(String outputFileName);</code>


=Notes=
* You MUST use the pheromones to navigate your robot to the food source and back to the colony. Use of map probing or other god-like techniques will result in grade deduction. Remember, you are programming like you are the ant. Be like ant, my friend.

=Administrative=
* We will provide Java skeleton code as a framework for build the specific behaviors.

The students are responsible for turning in:
* A final environment map
* Source code
* A 2 page write up of the assignment
** Approach and implementation
** What worked/didn't work
** Possible other approaches
** References

=References=
* Dorigo, M. and Caro, G.D. and Gambardella, L.M., Ant Algorithms for Discrete Optimization, Artificial Life, 1999 vol 5 no. 2, pp 137-172.

BioInspiredRobotDesignAssignment4

2007-11-12T23:52:09Z

Pwt23: /* Map */

[[Category:Bio Robots (Fall 2007)]]

=Overview=
Using only simple behaviors, we want to program our Creates to seek out and bring food back to a home base. At the outset, your robot will begin its search for food by performing random movements and leaving a pheromone in each location visited. Your robot will be working alone and must perform 3 iterations of finding food then returning home.

[[Image:SystemArchitecture.png|robot find food... mmmm|center|500px]]

=Goal=
Program the Creates such that they can search and find virtual food using only simple behaviors such as:
* local movements
** limited memory (i.e. only know the current location and none of the previous locations). The robot will not be allowed to perform path planning or use any memory other than the virtual environment map.
** maintain current location in memory
* try to avoid walls using the virtual map (otherwise the internal odometry could be thrown off).
* read pheromone
* pick up food
* leave pheromone

=Details=
The robot will begin by searching for food. This will be done via some sort of searching algorithm. As the robot moves, it will leave pheromones at each spot it has visited. To model decay, these pheromones keep track of the elapsed time since since you left the pheromone.

Once food is found, the robot will return to its original place (the colony) by following the pheromones that are the oldest (why is that?).

When the robot has navigated back to the colony, it must again follow a pheromone back to the food (can you figure out which ones?) and return back to the colony.


==Food==
Virtual walls are what our ants will use as food. When our Create encounters a virtual wall, it will "pick up food", then return home by following it's original pheromone trail while leaving pheromones for the other robots to find. They will be positioned from above with the IR beam pointing downward to simulate the effect of a food source. There will be two virtual walls, symbolizing two food sources.

==Virtual Pheromone==
Once a robot encounters a virtual wall, it will begin its journey home leaving a pheromone trail in the virtual environment. Leaving a virtual pheromone in the environment is accomplished by sending a location to the Environment Java Class.

Other robots will determine if there is a pheromone trail by querying the map with its current location. The pheromones will return values based on the last time you have visited the current location. For example, a pheromone on space X will return 999 if you have left a pheromone there 10 minutes ago while a pheromone will return 10 if you had just recently visited that location.

==Map==

We will be providing you an Environment Java class that the robot will use to represent the hallway. Do not edit this class. Your robot may use the following methods from <code>Environment</code>:

* Return a Pheromone value at this cell location.
:<code>long getPheromone(int x_, int y_)</code>
* Leaves a pheromone value at this cell location.
:<code>void leavePheromone(int x_, int y_);</code>
* Returns whether the cell location has a colony in it
: boolean isColony(int x_, int y_)
* Returns whether the cell location is an obstacle (ie. a wall)
: boolean isObstacle(int x_, int y_)

The map is also able to print the current state of the world in an XPM format. The pheromone trail is color coded where red spaces is where the robot has traveled most recently and blue is least recently. The following method will allow you to draw the map:

* <code>void drawEnvironment(String outputFileName);</code>



=Administrative=
* We will provide Java skeleton code as a framework for build the specific behaviors.

The students are responsible for turning in:
* A final environment map
* Source code
* A 2 page write up of the assignment
** Approach and implementation
** What worked/didn't work
** Possible other approaches
** References

=References=
* Dorigo, M. and Caro, G.D. and Gambardella, L.M., Ant Algorithms for Discrete Optimization, Artificial Life, 1999 vol 5 no. 2, pp 137-172.

BioInspiredRobotDesignAssignment4

2007-11-12T23:45:23Z

Pwt23: /* Details */

[[Category:Bio Robots (Fall 2007)]]

=Overview=
Using only simple behaviors, we want to program our Creates to seek out and bring food back to a home base. At the outset, your robot will begin its search for food by performing random movements and leaving a pheromone in each location visited. Your robot will be working alone and must perform 3 iterations of finding food then returning home.

[[Image:SystemArchitecture.png|robot find food... mmmm|center|500px]]

=Goal=
Program the Creates such that they can search and find virtual food using only simple behaviors such as:
* local movements
** limited memory (i.e. only know the current location and none of the previous locations). The robot will not be allowed to perform path planning or use any memory other than the virtual environment map.
** maintain current location in memory
* try to avoid walls using the virtual map (otherwise the internal odometry could be thrown off).
* read pheromone
* pick up food
* leave pheromone

=Details=
The robot will begin by searching for food. This will be done via some sort of searching algorithm. As the robot moves, it will leave pheromones at each spot it has visited. To model decay, these pheromones keep track of the elapsed time since since you left the pheromone.

Once food is found, the robot will return to its original place (the colony) by following the pheromones that are the oldest (why is that?).

When the robot has navigated back to the colony, it must again follow a pheromone back to the food (can you figure out which ones?) and return back to the colony.


==Food==
Virtual walls are what our ants will use as food. When our Create encounters a virtual wall, it will "pick up food", then return home by following it's original pheromone trail while leaving pheromones for the other robots to find. They will be positioned from above with the IR beam pointing downward to simulate the effect of a food source. There will be two virtual walls, symbolizing two food sources.

==Virtual Pheromone==
Once a robot encounters a virtual wall, it will begin its journey home leaving a pheromone trail in the virtual environment. Leaving a virtual pheromone in the environment is accomplished by sending a location to the Environment Java Class.

Other robots will determine if there is a pheromone trail by querying the map with its current location. The pheromones will return values based on the last time you have visited the current location. For example, a pheromone on space X will return 999 if you have left a pheromone there 10 minutes ago while a pheromone will return 10 if you had just recently visited that location.

==Map==

We will be providing you an Environment Java class that the robot will use to represent the hallway. Do not edit this class. Your robot may use the following methods from <code>Environment</code>:

* Return a Pheromone value at this cell location.
:<code>long getPheromone(int x, int y)</code>
* Leaves a pheromone value at this cell location.
:<code>void leavePheromone(int x, int y);</code>

The map is also able to print the current state of the world in an XPM format. The pheromone trail is color coded where red spaces is where the robot has traveled most recently and blue is least recently. The following method will allow you to draw the map:

* <code>void drawEnvironment(String outputFileName);</code>



=Administrative=
* We will provide Java skeleton code as a framework for build the specific behaviors.

The students are responsible for turning in:
* A final environment map
* Source code
* A 2 page write up of the assignment
** Approach and implementation
** What worked/didn't work
** Possible other approaches
** References

=References=
* Dorigo, M. and Caro, G.D. and Gambardella, L.M., Ant Algorithms for Discrete Optimization, Artificial Life, 1999 vol 5 no. 2, pp 137-172.

BioInspiredRobotDesignAssignment4

2007-11-12T23:44:52Z

Pwt23: /* Details */

[[Category:Bio Robots (Fall 2007)]]

=Overview=
Using only simple behaviors, we want to program our Creates to seek out and bring food back to a home base. At the outset, your robot will begin its search for food by performing random movements and leaving a pheromone in each location visited. Your robot will be working alone and must perform 3 iterations of finding food then returning home.

[[Image:SystemArchitecture.png|robot find food... mmmm|center|500px]]

=Goal=
Program the Creates such that they can search and find virtual food using only simple behaviors such as:
* local movements
** limited memory (i.e. only know the current location and none of the previous locations). The robot will not be allowed to perform path planning or use any memory other than the virtual environment map.
** maintain current location in memory
* try to avoid walls using the virtual map (otherwise the internal odometry could be thrown off).
* read pheromone
* pick up food
* leave pheromone

=Details=
The robot will begin by searching for food. This will be done via some sort of searching algorithm. As the robot moves, it will leave pheromones at each spot it has visited. To model decay, these pheromones keep track of the elapsed time since since you left the pheromone.

Once food is found, the robot will return to its original place (the colony) by following the pheromones that are the oldest (why is that?).

When the robot has navigated back to the colony, it must again follow a pheromone back to the food (can you figure out which ones?) and return back to the colony.
<--!
The robot begin by executing a search for food. This is done by random movements until 1) food is found, or 2) a virtual pheromone is encountered. At each discrete location, the robot will leave a virtual pheromone in the virtual map. If food is found, return home while leaving a trail every 15cm. If a pheromone is found, then follow the pheromone trail until it can't find any more pheromones, or until it finds food.
-->
==Food==
Virtual walls are what our ants will use as food. When our Create encounters a virtual wall, it will "pick up food", then return home by following it's original pheromone trail while leaving pheromones for the other robots to find. They will be positioned from above with the IR beam pointing downward to simulate the effect of a food source. There will be two virtual walls, symbolizing two food sources.

==Virtual Pheromone==
Once a robot encounters a virtual wall, it will begin its journey home leaving a pheromone trail in the virtual environment. Leaving a virtual pheromone in the environment is accomplished by sending a location to the Environment Java Class.

Other robots will determine if there is a pheromone trail by querying the map with its current location. The pheromones will return values based on the last time you have visited the current location. For example, a pheromone on space X will return 999 if you have left a pheromone there 10 minutes ago while a pheromone will return 10 if you had just recently visited that location.

==Map==

We will be providing you an Environment Java class that the robot will use to represent the hallway. Do not edit this class. Your robot may use the following methods from <code>Environment</code>:

* Return a Pheromone value at this cell location.
:<code>long getPheromone(int x, int y)</code>
* Leaves a pheromone value at this cell location.
:<code>void leavePheromone(int x, int y);</code>

The map is also able to print the current state of the world in an XPM format. The pheromone trail is color coded where red spaces is where the robot has traveled most recently and blue is least recently. The following method will allow you to draw the map:

* <code>void drawEnvironment(String outputFileName);</code>



=Administrative=
* We will provide Java skeleton code as a framework for build the specific behaviors.

The students are responsible for turning in:
* A final environment map
* Source code
* A 2 page write up of the assignment
** Approach and implementation
** What worked/didn't work
** Possible other approaches
** References

=References=
* Dorigo, M. and Caro, G.D. and Gambardella, L.M., Ant Algorithms for Discrete Optimization, Artificial Life, 1999 vol 5 no. 2, pp 137-172.

BioInspiredRobotDesignAssignment4

2007-11-12T23:44:37Z

Pwt23: /* Details */

[[Category:Bio Robots (Fall 2007)]]

=Overview=
Using only simple behaviors, we want to program our Creates to seek out and bring food back to a home base. At the outset, your robot will begin its search for food by performing random movements and leaving a pheromone in each location visited. Your robot will be working alone and must perform 3 iterations of finding food then returning home.

[[Image:SystemArchitecture.png|robot find food... mmmm|center|500px]]

=Goal=
Program the Creates such that they can search and find virtual food using only simple behaviors such as:
* local movements
** limited memory (i.e. only know the current location and none of the previous locations). The robot will not be allowed to perform path planning or use any memory other than the virtual environment map.
** maintain current location in memory
* try to avoid walls using the virtual map (otherwise the internal odometry could be thrown off).
* read pheromone
* pick up food
* leave pheromone

=Details=
The robot will begin by searching for food. This will be done via some sort of searching algorithm. As the robot moves, it will leave pheromones at each spot it has visited. To model decay, these pheromones keep track of the elapsed time since since you left the pheromone.

Once food is found, the robot will return to its original place (the colony) by following the pheromones that are the oldest (why is that?).

When the robot has navigated back to the colony, it must again follow a pheromone back to the food (can you figure out which ones?) and return back to the colony.
<--
The robot begin by executing a search for food. This is done by random movements until 1) food is found, or 2) a virtual pheromone is encountered. At each discrete location, the robot will leave a virtual pheromone in the virtual map. If food is found, return home while leaving a trail every 15cm. If a pheromone is found, then follow the pheromone trail until it can't find any more pheromones, or until it finds food.
-->
==Food==
Virtual walls are what our ants will use as food. When our Create encounters a virtual wall, it will "pick up food", then return home by following it's original pheromone trail while leaving pheromones for the other robots to find. They will be positioned from above with the IR beam pointing downward to simulate the effect of a food source. There will be two virtual walls, symbolizing two food sources.

==Virtual Pheromone==
Once a robot encounters a virtual wall, it will begin its journey home leaving a pheromone trail in the virtual environment. Leaving a virtual pheromone in the environment is accomplished by sending a location to the Environment Java Class.

Other robots will determine if there is a pheromone trail by querying the map with its current location. The pheromones will return values based on the last time you have visited the current location. For example, a pheromone on space X will return 999 if you have left a pheromone there 10 minutes ago while a pheromone will return 10 if you had just recently visited that location.

==Map==

We will be providing you an Environment Java class that the robot will use to represent the hallway. Do not edit this class. Your robot may use the following methods from <code>Environment</code>:

* Return a Pheromone value at this cell location.
:<code>long getPheromone(int x, int y)</code>
* Leaves a pheromone value at this cell location.
:<code>void leavePheromone(int x, int y);</code>

The map is also able to print the current state of the world in an XPM format. The pheromone trail is color coded where red spaces is where the robot has traveled most recently and blue is least recently. The following method will allow you to draw the map:

* <code>void drawEnvironment(String outputFileName);</code>



=Administrative=
* We will provide Java skeleton code as a framework for build the specific behaviors.

The students are responsible for turning in:
* A final environment map
* Source code
* A 2 page write up of the assignment
** Approach and implementation
** What worked/didn't work
** Possible other approaches
** References

=References=
* Dorigo, M. and Caro, G.D. and Gambardella, L.M., Ant Algorithms for Discrete Optimization, Artificial Life, 1999 vol 5 no. 2, pp 137-172.

BioInspiredRobotDesignAssignment4

2007-11-12T23:39:06Z

Pwt23: /* Virtual Pheromone (VirP) */

[[Category:Bio Robots (Fall 2007)]]

=Overview=
Using only simple behaviors, we want to program our Creates to seek out and bring food back to a home base. At the outset, your robot will begin its search for food by performing random movements and leaving a pheromone in each location visited. Your robot will be working alone and must perform 3 iterations of finding food then returning home.

[[Image:SystemArchitecture.png|robot find food... mmmm|center|500px]]

=Goal=
Program the Creates such that they can search and find virtual food using only simple behaviors such as:
* local movements
** limited memory (i.e. only know the current location and none of the previous locations). The robot will not be allowed to perform path planning or use any memory other than the virtual environment map.
** maintain current location in memory
* try to avoid walls using the virtual map (otherwise the internal odometry could be thrown off).
* read pheromone
* pick up food
* leave pheromone

=Details=
The robot begin by executing a search for food. This is done by random movements until 1) food is found, or 2) a virtual pheromone is encountered. At each discrete location, the robot will leave a virtual pheromone in the virtual map. If food is found, return home while leaving a trail every 15cm. If a pheromone is found, then follow the pheromone trail until it can't find any more pheromones, or until it finds food.

==Food==
Virtual walls are what our ants will use as food. When our Create encounters a virtual wall, it will "pick up food", then return home by following it's original pheromone trail while leaving pheromones for the other robots to find. They will be positioned from above with the IR beam pointing downward to simulate the effect of a food source. There will be two virtual walls, symbolizing two food sources.

==Virtual Pheromone==
Once a robot encounters a virtual wall, it will begin its journey home leaving a pheromone trail in the virtual environment. Leaving a virtual pheromone in the environment is accomplished by sending a location to the Environment Java Class.

Other robots will determine if there is a pheromone trail by querying the map with its current location. The pheromones will return values based on the last time you have visited the current location. For example, a pheromone on space X will return 999 if you have left a pheromone there 10 minutes ago while a pheromone will return 10 if you had just recently visited that location.

==Map==

We will be providing you an Environment Java class that the robot will use to represent the hallway. Do not edit this class. Your robot may use the following methods from <code>Environment</code>:

* Return a Pheromone value at this cell location.
:<code>long getPheromone(int x, int y)</code>
* Leaves a pheromone value at this cell location.
:<code>void leavePheromone(int x, int y);</code>

The map is also able to print the current state of the world in an XPM format. The pheromone trail is color coded where red spaces is where the robot has traveled most recently and blue is least recently. The following method will allow you to draw the map:

* <code>void drawEnvironment(String outputFileName);</code>



=Administrative=
* We will provide Java skeleton code as a framework for build the specific behaviors.

The students are responsible for turning in:
* A final environment map
* Source code
* A 2 page write up of the assignment
** Approach and implementation
** What worked/didn't work
** Possible other approaches
** References

=References=
* Dorigo, M. and Caro, G.D. and Gambardella, L.M., Ant Algorithms for Discrete Optimization, Artificial Life, 1999 vol 5 no. 2, pp 137-172.

Bio-Robotics Lab (Fall 2007)

2007-11-09T20:53:12Z

Pwt23:

[[Category:Bio Robots (Fall 2007)]]
[[Category:Fall 2007 classes]]

==Announcements==
* 2007-11-09: There is an EXTENSION on Assignment #3. It is now due on Monday Nov. 12th, no later than 5:00pm.
* 2007-11-07: [[Fall2007BioInspiredRobotDesignAssignment3|Assignment 3]] is due at the end of this week 11/09
* 2007-10-23: Some sample code for XPM format is [[XPMSample|here]]. For more in-depth, you can read about it from [http://www.cs.drexel.edu/%7Edavid/Classes/CS430/HWs/Assignment1.html CS430/536 Graphics Assignment 1].
* 2007-10-15: [[Fall2007BioInspiredRobotDesignAssignment2|Assignment 2]] is up it is due anytime the week of '''October 22nd.'''
* 2007-10-15: Thanks to Brian Lutz for writing up some instructions for setting up [[Connecting_Roomba_to_Your_Computer#Linux|Bluetooth with Linux]]
* 2007-10-01: There is a small bug in roombacomm.jar where goBackward(dist) did not go backward. It is fixed in the jar file included in this '''[[Media:RoombaComm.zip |Roombacomm.zip file]]'''.

==Course Logistics==

Prerequisites: Permission of instructor. 
Class Time: M-W-F 14:00->14:50 
Class Location: UCross Rm 149 
Office Hours: UCROSS147 Wed and Fri 12-2pm and by appointment 
Course Instructor: [[William C. Regli]], Ph.D. 
Teaching Assistants: Peter Thai <pwt23@drexel.edu> and Duc Nguyen <dn53@drexel.edu> 
Instructor Contact: Email regli (at) drexel (DOT) edu (not that this will help keep the spammers away) 
Phone 215.895.6827; Office: UC 143

==Course Objectives and Outcomes==

The goal of this class is to learn how to create software to interact with devices embodied in the physical world. Students successfully completing this class will:
#understand the basic concepts of robotics (from a computer-science point of view), including kinematics, dynamics, actuators, controllers, etc;
#perform software development to control mobile robots (specifically iRobot Roombas);
#design experiments for robotic platforms;
#measure the effectiveness of a robotic system on a given problem;
#gain experience with biologically-inspired robotics techniques (swarming, biologically inspired design, etc)
#employ cyber-infrastructure (wikis, web, etc) and engineering informatics tools (CAD, simulation, MATLAB, Maple, Pro/E, SolidWorks, ACIS, etc) to better understand the relationship between virtual models and the real world

==Lectures==

{| border="1" cellpadding="2"
!width="75"|Date
!width="150"|Assignment
!width="150"|Topic
!width="150"|Summary Notes
!width="500"|Links and References
|-
|September 24
|
|
Intro to Robot Lab
|
[[Media:CS-Robot-Lab-Spring2007-Lec-1.ppt]]
|
|-
|
|
|Introduction to Robotics
|[[Media:Introduction_to_Robotics.ppt]]
|
|-
|September 26
|
|Simulation
|[[Media:Simulation_of_Robotic_Systems.ppt]]
|
|-
|September 26
|
|Simulation
|[[Media:Simulation_of_Robotic_Systems.ppt]]
|
|-
|Week of October 8th
|[http://gicl.cs.drexel.edu/wiki/Fall2007BioInspiredRobotDesignAssignment1 Assignment 1] due
|
|[[Robotics Videos]]
|
|-
|Week of October 15th
|
|SLAM
|[[Media:SLAM.ppt]]
|

|-
|October 22
|[http://gicl.cs.drexel.edu/wiki/Fall2007BioInspiredRobotDesignAssignment2 Assignment 2] due
|Grading Assignment 2
|
|
|-
|October 29
|
|Path Planning
|[[Media:Robot-Lab-Path-Planning.ppt]]
|
|-
|November 12
|[http://gicl.cs.drexel.edu/wiki/Fall2007BioInspiredRobotDesignAssignment3 Assignment 3] due
|
|
|
|}


==Text==

Required texts and readings: 
# [http://gicl.cs.drexel.edu/wiki-data/images/a/af/Brooks-representation.pdf Intelligence without Representation], Rodney Brooks.
# Flesh and Machines: How Robots Will Change Us (Paperback) by Rodney Brooks, Publisher: Vintage (February 4, 2003); ISBN-10: 037572527X.
# [http://www.cs.unc.edu/~welch/media/pdf/kalman_intro.pdf Introduction to the Kalman Filter] from UNC.
# [http://ocw.mit.edu/NR/rdonlyres/Aeronautics-and-Astronautics/16-412JSpring-2005/9D8DB59F-24EC-4B75-BA7A-F0916BAB2440/0/1aslam_blas_repo.pdf SLAM for Dummies]

Interested students may wish to examine the following textbooks:
*J.J. Craig. Introduction to Robotics: Mechanics and Control. Prentice Hall; 3rd edition, 2003.
*Kiyoshi Toko. Biomimetic Sensor Technology. Cambridge University Press, 2000.
*Karl Williams. Amphibionics: Build Your Own Biologically Inspired Reptilian Robot. McGraw-Hill/TAB Electronics, 2003.
*David Cook. Robot Building for Beginners. Apress, 2002.

==Grading==

The due dates are listed on the week by week breakdown of the course below. When an assignment is due on a particular date, that means the assignment is really due that week. You must arrange a time one of the TAs for this class, during the week the assignment is due in order to have your assignment evaluated and graded. As there are limited slots per TA session, it is best to schedule a time slot sooner rather than later. You also will have the opportunity to have your work graded after the lecture during the due week.

==Software==
Depending on the evolution of the class, students may have an opportunity to gain experience with a variety of computational tools, including MATLAB, SolidWorks, Pro/ENGINEER, ACIS, MAPLE, etc. Several research prototype tools may also be introduced for physics-based modeling, kinematics, etc.

[[Processing]] Setup

* A skeleton [[Media:CS511.zip|Eclipse Project]] to write full-fledged Java instead of Processing. Some directions [[Roomba/Eclipse|here]]
* [[Media:RoombaProject.zip |Another Eclipse Project]] - includes some classes from Lego Mindstorms [http://lejos.sourceforge.net Lejos Project] concerning subsumption architecture.
* Download Eclipse [http://www.eclipse.org here]

==Miscellaneous Resources==

Wiki page for Winter 2007 Roomba Lab:
[http://gicl.cs.drexel.edu/wiki/Category:Roomba_Design_Lab_%28Winter_2007%29]

Page from Spring 2007 Robotics Lab:
[http://gicl.cs.drexel.edu/wiki/Category:Roomba_Design_Lab_%28Winter_2007%29]

iRobot Create Forums: [http://createforums.irobot.com/]

Robotics Primer Workbook based around the Create [http://roboticsprimer.sourceforge.net/workbook/Main_Page]

Fall2007BioInspiredRobotDesignAssignment3

2007-11-09T20:35:20Z

Pwt23:

[[Category:Robot Lab (Spring 2007)]]

=== Assignment 3: Path Planning Basics===

We will not be using Roombas in this first part; rather, we will simulate a point robot. You will write a program to calculate a path through an occupancy map using the Wavefront algorithm, a breadth first search. Once the path has been planned, this turns into a dead reckoning problem, which we have already seen, and since we know how temperamental dead reckoning is, this will introduce a wrinkle. We know with dead reckoning the path your robot takes is not exactly the path you specify, and over the course of the path your robot's error grows. If your robot hits an obstacle, this will throw off the path that you had told your robot to execute and your robot may not finish the course. Before creating the path, your program must first adapt the map so that your robot will not come close to any obstacle or any wall except for the start and end positions. Then you should calculate the possible paths in the map using the Wavefront algorithm, and finally calculate a best path for your robot given the Wavefront map.

==== Updates ====
* 2007-11-09: Here is the original map before it was scaled up [[Image:InitialMap.txt]]
*rows and columns were written backwards, the first number is columns, the second number is rows
*All parts of the assignment should be done in your code, your code can be whatever language you like
*The number of rows and columns start from 1, so if rows = 9, then there are 9 rows
*For lettering your path, rather than A-Z,AA-AZ you can just start over at A again.

==== Description ====

Your program should take in a text file called path_input.txt which will look like:

[[Media:Path input.txt]]

'''Note''' that this is an example input, which will be followed in the assignment. The actual input file will be provided below.

The first line tells how many columns (9), the second line tells how many rows (8) the map has. The starting point for the path will have an S, and the ending point will have an E. All obstacles will have a 1, and open cells will have a 0.

We will assume that your robot can move one square at a time in any direction (up, down, left, right, all four diagonals), as long as it does not go off the map or into an occupied cell. We also assume that your robot takes up 1 cell. To provide your robot with a buffer so that it does not run into an obstacle or a wall given the error in its path, you will add extra occupied cells to the map. You should first increase the size of all obstacles by the size of your robot in all directions by adding a 1 in all directions around all obstacles.

You will not turn this step in, but here is a representation so that you can see what the input map would look like after your program expands the obstacles:

[[Media:Expanded_obstacles.txt]]

Next you will expand all walls by adding a 1 above the lower wall, to the right of the left wall, below the upper wall, and to the left of the right wall, do this for all cells that are not currently occupied and are not the start and end positions (i.e. for any cell that has a 0).

You will not turn this step in, but here is a representation so that you can see what the input map would look like after your program expands the walls:

[[Media:Expanded_walls.txt]]

Now we perform the Wavefront algorithm. This is a breadth first search that starts at the end position, and expands out from there, noting how far every other cell is from the end position. You should replace the E (end position) with a 2, then until your algorithm encounters the S (but will not replace the S), you will expand out in a wave from the end position, setting all adjacent cells to 3, then the adjacent cells of the 3's to 4, etc.

You will turn this step in, so your program should output a file named wavefront_path_map.txt that looks like the following:

[[Media:Wavefront_path_map.txt]]

Finally you will calculate the shortest path from the S to the 2. Note that this minimal distance path may not be unique. Your path will replace the S with an A, then increment through alphabet (B..Z, then AA, AB, AC..AZ if needed) with one letter per cell to indicate your path. Since some environments don't allow more than one character in a position, you may start your path over at A, i.e. A-Z, then A-Z again.

You will turn this step in, so your program should output a file named wavefront_path_plan.txt that looks like the following:

[[Media:Wavefront_path_plan.txt]]

Note that there is an alternative path with F the cell below the displayed F, and then another choice for G, as all of these paths will have the same length.

==== Deliverables ====

You will be given the  [[Image:Hallway path input.txt]] file (and change the name to path_input.txt), and your code should execute on that input file, producing the two output files.

'''NOTE''' Each character in the input file represents a 3x3 inch square, so a 16 character square represents 1 tile in the floor.

You should turn in:

*your code
*hallway_path_map.txt
*hallway_path_plan.txt



=== Assignment 3 Part B: Path Planning Execution===
While you used simulated robots in the first part, you will use real robots in this section. In this section, you will be provided with an initial text file that represents part of the hallway on which you will perform path planning techniques you learned in the first section, but taking into account the challenges of executing the path with a real robot.

==== Description ====

*Perform path planning techniques from section A onto the provided text document of the hallway (below). Each character represents a forth of a foot.

*Take in account the diameter of the robot in the path planning. The path planning algorithms in part 1 may return paths that a point robot may travers, but not a real robot. For example, some paths might bring your robot through a 1 foot passage, but your robot's diameter is more than 1 foot. You might want iterate through potential paths returned by your path planning algorithm and discard ones that would not work for a real robot.

*Write code that would allow your robot to follow the calculated path. The robot will start facing any direction you please.

==== Notes ====
* The initial map (not expanded) can be found here: [[Image:InitialMap.txt]]
* This assignment should be included all in one program (ie your program should calculate a path, perform corrections on the path, and then move the robot without user assistance between stages).

==== Deliverables ====

*your code
*wavefront_path_map.txt
*wavefront_path_plan.txt

Bio-Robotics Lab (Fall 2007)

2007-11-09T20:34:29Z

Pwt23:

[[Category:Bio Robots (Fall 2007)]]
[[Category:Fall 2007 classes]]

==Announcements==
* 2007-11-07: [[Fall2007BioInspiredRobotDesignAssignment3|Assignment 3]] is due at the end of this week 11/09
* 2007-10-23: Some sample code for XPM format is [[XPMSample|here]]. For more in-depth, you can read about it from [http://www.cs.drexel.edu/%7Edavid/Classes/CS430/HWs/Assignment1.html CS430/536 Graphics Assignment 1].
* 2007-10-15: [[Fall2007BioInspiredRobotDesignAssignment2|Assignment 2]] is up it is due anytime the week of '''October 22nd.'''
* 2007-10-15: Thanks to Brian Lutz for writing up some instructions for setting up [[Connecting_Roomba_to_Your_Computer#Linux|Bluetooth with Linux]]
* 2007-10-01: There is a small bug in roombacomm.jar where goBackward(dist) did not go backward. It is fixed in the jar file included in this '''[[Media:RoombaComm.zip |Roombacomm.zip file]]'''.

==Course Logistics==

Prerequisites: Permission of instructor. 
Class Time: M-W-F 14:00->14:50 
Class Location: UCross Rm 149 
Office Hours: UCROSS147 Wed and Fri 12-2pm and by appointment 
Course Instructor: [[William C. Regli]], Ph.D. 
Teaching Assistants: Peter Thai <pwt23@drexel.edu> and Duc Nguyen <dn53@drexel.edu> 
Instructor Contact: Email regli (at) drexel (DOT) edu (not that this will help keep the spammers away) 
Phone 215.895.6827; Office: UC 143

==Course Objectives and Outcomes==

The goal of this class is to learn how to create software to interact with devices embodied in the physical world. Students successfully completing this class will:
#understand the basic concepts of robotics (from a computer-science point of view), including kinematics, dynamics, actuators, controllers, etc;
#perform software development to control mobile robots (specifically iRobot Roombas);
#design experiments for robotic platforms;
#measure the effectiveness of a robotic system on a given problem;
#gain experience with biologically-inspired robotics techniques (swarming, biologically inspired design, etc)
#employ cyber-infrastructure (wikis, web, etc) and engineering informatics tools (CAD, simulation, MATLAB, Maple, Pro/E, SolidWorks, ACIS, etc) to better understand the relationship between virtual models and the real world

==Lectures==

{| border="1" cellpadding="2"
!width="75"|Date
!width="150"|Assignment
!width="150"|Topic
!width="150"|Summary Notes
!width="500"|Links and References
|-
|September 24
|
|
Intro to Robot Lab
|
[[Media:CS-Robot-Lab-Spring2007-Lec-1.ppt]]
|
|-
|
|
|Introduction to Robotics
|[[Media:Introduction_to_Robotics.ppt]]
|
|-
|September 26
|
|Simulation
|[[Media:Simulation_of_Robotic_Systems.ppt]]
|
|-
|September 26
|
|Simulation
|[[Media:Simulation_of_Robotic_Systems.ppt]]
|
|-
|Week of October 8th
|[http://gicl.cs.drexel.edu/wiki/Fall2007BioInspiredRobotDesignAssignment1 Assignment 1] due
|
|[[Robotics Videos]]
|
|-
|Week of October 15th
|
|SLAM
|[[Media:SLAM.ppt]]
|

|-
|October 22
|[http://gicl.cs.drexel.edu/wiki/Fall2007BioInspiredRobotDesignAssignment2 Assignment 2] due
|Grading Assignment 2
|
|
|-
|October 29
|
|Path Planning
|[[Media:Robot-Lab-Path-Planning.ppt]]
|
|-
|November 5
|[http://gicl.cs.drexel.edu/wiki/Fall2007BioInspiredRobotDesignAssignment3 Assignment 3] due
|
|
|
|}


==Text==

Required texts and readings: 
# [http://gicl.cs.drexel.edu/wiki-data/images/a/af/Brooks-representation.pdf Intelligence without Representation], Rodney Brooks.
# Flesh and Machines: How Robots Will Change Us (Paperback) by Rodney Brooks, Publisher: Vintage (February 4, 2003); ISBN-10: 037572527X.
# [http://www.cs.unc.edu/~welch/media/pdf/kalman_intro.pdf Introduction to the Kalman Filter] from UNC.
# [http://ocw.mit.edu/NR/rdonlyres/Aeronautics-and-Astronautics/16-412JSpring-2005/9D8DB59F-24EC-4B75-BA7A-F0916BAB2440/0/1aslam_blas_repo.pdf SLAM for Dummies]

Interested students may wish to examine the following textbooks:
*J.J. Craig. Introduction to Robotics: Mechanics and Control. Prentice Hall; 3rd edition, 2003.
*Kiyoshi Toko. Biomimetic Sensor Technology. Cambridge University Press, 2000.
*Karl Williams. Amphibionics: Build Your Own Biologically Inspired Reptilian Robot. McGraw-Hill/TAB Electronics, 2003.
*David Cook. Robot Building for Beginners. Apress, 2002.

==Grading==

The due dates are listed on the week by week breakdown of the course below. When an assignment is due on a particular date, that means the assignment is really due that week. You must arrange a time one of the TAs for this class, during the week the assignment is due in order to have your assignment evaluated and graded. As there are limited slots per TA session, it is best to schedule a time slot sooner rather than later. You also will have the opportunity to have your work graded after the lecture during the due week.

==Software==
Depending on the evolution of the class, students may have an opportunity to gain experience with a variety of computational tools, including MATLAB, SolidWorks, Pro/ENGINEER, ACIS, MAPLE, etc. Several research prototype tools may also be introduced for physics-based modeling, kinematics, etc.

[[Processing]] Setup

* A skeleton [[Media:CS511.zip|Eclipse Project]] to write full-fledged Java instead of Processing. Some directions [[Roomba/Eclipse|here]]
* [[Media:RoombaProject.zip |Another Eclipse Project]] - includes some classes from Lego Mindstorms [http://lejos.sourceforge.net Lejos Project] concerning subsumption architecture.
* Download Eclipse [http://www.eclipse.org here]

==Miscellaneous Resources==

Wiki page for Winter 2007 Roomba Lab:
[http://gicl.cs.drexel.edu/wiki/Category:Roomba_Design_Lab_%28Winter_2007%29]

Page from Spring 2007 Robotics Lab:
[http://gicl.cs.drexel.edu/wiki/Category:Roomba_Design_Lab_%28Winter_2007%29]

iRobot Create Forums: [http://createforums.irobot.com/]

Robotics Primer Workbook based around the Create [http://roboticsprimer.sourceforge.net/workbook/Main_Page]

Bio-Robotics Lab (Fall 2007)

2007-11-09T19:51:19Z

Pwt23:

[[Category:Bio Robots (Fall 2007)]]
[[Category:Fall 2007 classes]]

==Announcements==
* 2007-11-09: Here is the original map before it was scaled up [[Image:InitialMap.txt]]
* 2007-11-07: [[Fall2007BioInspiredRobotDesignAssignment3|Assignment 3]] is due at the end of this week 11/09
* 2007-10-23: Some sample code for XPM format is [[XPMSample|here]]. For more in-depth, you can read about it from [http://www.cs.drexel.edu/%7Edavid/Classes/CS430/HWs/Assignment1.html CS430/536 Graphics Assignment 1].
* 2007-10-15: [[Fall2007BioInspiredRobotDesignAssignment2|Assignment 2]] is up it is due anytime the week of '''October 22nd.'''
* 2007-10-15: Thanks to Brian Lutz for writing up some instructions for setting up [[Connecting_Roomba_to_Your_Computer#Linux|Bluetooth with Linux]]
* 2007-10-01: There is a small bug in roombacomm.jar where goBackward(dist) did not go backward. It is fixed in the jar file included in this '''[[Media:RoombaComm.zip |Roombacomm.zip file]]'''.

==Course Logistics==

Prerequisites: Permission of instructor. 
Class Time: M-W-F 14:00->14:50 
Class Location: UCross Rm 149 
Office Hours: UCROSS147 Wed and Fri 12-2pm and by appointment 
Course Instructor: [[William C. Regli]], Ph.D. 
Teaching Assistants: Peter Thai <pwt23@drexel.edu> and Duc Nguyen <dn53@drexel.edu> 
Instructor Contact: Email regli (at) drexel (DOT) edu (not that this will help keep the spammers away) 
Phone 215.895.6827; Office: UC 143

==Course Objectives and Outcomes==

The goal of this class is to learn how to create software to interact with devices embodied in the physical world. Students successfully completing this class will:
#understand the basic concepts of robotics (from a computer-science point of view), including kinematics, dynamics, actuators, controllers, etc;
#perform software development to control mobile robots (specifically iRobot Roombas);
#design experiments for robotic platforms;
#measure the effectiveness of a robotic system on a given problem;
#gain experience with biologically-inspired robotics techniques (swarming, biologically inspired design, etc)
#employ cyber-infrastructure (wikis, web, etc) and engineering informatics tools (CAD, simulation, MATLAB, Maple, Pro/E, SolidWorks, ACIS, etc) to better understand the relationship between virtual models and the real world

==Lectures==

{| border="1" cellpadding="2"
!width="75"|Date
!width="150"|Assignment
!width="150"|Topic
!width="150"|Summary Notes
!width="500"|Links and References
|-
|September 24
|
|
Intro to Robot Lab
|
[[Media:CS-Robot-Lab-Spring2007-Lec-1.ppt]]
|
|-
|
|
|Introduction to Robotics
|[[Media:Introduction_to_Robotics.ppt]]
|
|-
|September 26
|
|Simulation
|[[Media:Simulation_of_Robotic_Systems.ppt]]
|
|-
|September 26
|
|Simulation
|[[Media:Simulation_of_Robotic_Systems.ppt]]
|
|-
|Week of October 8th
|[http://gicl.cs.drexel.edu/wiki/Fall2007BioInspiredRobotDesignAssignment1 Assignment 1] due
|
|[[Robotics Videos]]
|
|-
|Week of October 15th
|
|SLAM
|[[Media:SLAM.ppt]]
|

|-
|October 22
|[http://gicl.cs.drexel.edu/wiki/Fall2007BioInspiredRobotDesignAssignment2 Assignment 2] due
|Grading Assignment 2
|
|
|-
|October 29
|
|Path Planning
|[[Media:Robot-Lab-Path-Planning.ppt]]
|
|-
|November 5
|[http://gicl.cs.drexel.edu/wiki/Fall2007BioInspiredRobotDesignAssignment3 Assignment 3] due
|
|
|
|}


==Text==

Required texts and readings: 
# [http://gicl.cs.drexel.edu/wiki-data/images/a/af/Brooks-representation.pdf Intelligence without Representation], Rodney Brooks.
# Flesh and Machines: How Robots Will Change Us (Paperback) by Rodney Brooks, Publisher: Vintage (February 4, 2003); ISBN-10: 037572527X.
# [http://www.cs.unc.edu/~welch/media/pdf/kalman_intro.pdf Introduction to the Kalman Filter] from UNC.
# [http://ocw.mit.edu/NR/rdonlyres/Aeronautics-and-Astronautics/16-412JSpring-2005/9D8DB59F-24EC-4B75-BA7A-F0916BAB2440/0/1aslam_blas_repo.pdf SLAM for Dummies]

Interested students may wish to examine the following textbooks:
*J.J. Craig. Introduction to Robotics: Mechanics and Control. Prentice Hall; 3rd edition, 2003.
*Kiyoshi Toko. Biomimetic Sensor Technology. Cambridge University Press, 2000.
*Karl Williams. Amphibionics: Build Your Own Biologically Inspired Reptilian Robot. McGraw-Hill/TAB Electronics, 2003.
*David Cook. Robot Building for Beginners. Apress, 2002.

==Grading==

The due dates are listed on the week by week breakdown of the course below. When an assignment is due on a particular date, that means the assignment is really due that week. You must arrange a time one of the TAs for this class, during the week the assignment is due in order to have your assignment evaluated and graded. As there are limited slots per TA session, it is best to schedule a time slot sooner rather than later. You also will have the opportunity to have your work graded after the lecture during the due week.

==Software==
Depending on the evolution of the class, students may have an opportunity to gain experience with a variety of computational tools, including MATLAB, SolidWorks, Pro/ENGINEER, ACIS, MAPLE, etc. Several research prototype tools may also be introduced for physics-based modeling, kinematics, etc.

[[Processing]] Setup

* A skeleton [[Media:CS511.zip|Eclipse Project]] to write full-fledged Java instead of Processing. Some directions [[Roomba/Eclipse|here]]
* [[Media:RoombaProject.zip |Another Eclipse Project]] - includes some classes from Lego Mindstorms [http://lejos.sourceforge.net Lejos Project] concerning subsumption architecture.
* Download Eclipse [http://www.eclipse.org here]

==Miscellaneous Resources==

Wiki page for Winter 2007 Roomba Lab:
[http://gicl.cs.drexel.edu/wiki/Category:Roomba_Design_Lab_%28Winter_2007%29]

Page from Spring 2007 Robotics Lab:
[http://gicl.cs.drexel.edu/wiki/Category:Roomba_Design_Lab_%28Winter_2007%29]

iRobot Create Forums: [http://createforums.irobot.com/]

Robotics Primer Workbook based around the Create [http://roboticsprimer.sourceforge.net/workbook/Main_Page]

File:InitialMap.txt

2007-11-09T19:49:54Z

Pwt23:

Fall2007BioInspiredRobotDesignAssignment3

2007-11-01T16:28:47Z

Pwt23:

[[Category:Robot Lab (Spring 2007)]]

=== Assignment 3: Path Planning Basics===

We will not be using Roombas in this first part; rather, we will simulate a point robot. You will write a program to calculate a path through an occupancy map using the Wavefront algorithm, a breadth first search. Once the path has been planned, this turns into a dead reckoning problem, which we have already seen, and since we know how temperamental dead reckoning is, this will introduce a wrinkle. We know with dead reckoning the path your robot takes is not exactly the path you specify, and over the course of the path your robot's error grows. If your robot hits an obstacle, this will throw off the path that you had told your robot to execute and your robot may not finish the course. Before creating the path, your program must first adapt the map so that your robot will not come close to any obstacle or any wall except for the start and end positions. Then you should calculate the possible paths in the map using the Wavefront algorithm, and finally calculate a best path for your robot given the Wavefront map.

==== Updates ====
*
*rows and columns were written backwards, the first number is columns, the second number is rows
*All parts of the assignment should be done in your code, your code can be whatever language you like
*The number of rows and columns start from 1, so if rows = 9, then there are 9 rows
*For lettering your path, rather than A-Z,AA-AZ you can just start over at A again.

==== Description ====

Your program should take in a text file called path_input.txt which will look like:

[[Media:Path input.txt]]

Note that this is an example input, which will be followed in the assignment. The actual input file will be provided below.

The first line tells how many columns (9), the second line tells how many rows (8) the map has. The starting point for the path will have an S, and the ending point will have an E. All obstacles will have a 1, and open cells will have a 0.

We will assume that your robot can move one square at a time in any direction (up, down, left, right, all four diagonals), as long as it does not go off the map or into an occupied cell. We also assume that your robot takes up 1 cell. To provide your robot with a buffer so that it does not run into an obstacle or a wall given the error in its path, you will add extra occupied cells to the map. You should first increase the size of all obstacles by the size of your robot in all directions by adding a 1 in all directions around all obstacles.

You will not turn this step in, but here is a representation so that you can see what the input map would look like after your program expands the obstacles:

[[Media:Expanded_obstacles.txt]]

Next you will expand all walls by adding a 1 above the lower wall, to the right of the left wall, below the upper wall, and to the left of the right wall, do this for all cells that are not currently occupied and are not the start and end positions (i.e. for any cell that has a 0).

You will not turn this step in, but here is a representation so that you can see what the input map would look like after your program expands the walls:

[[Media:Expanded_walls.txt]]

Now we perform the Wavefront algorithm. This is a breadth first search that starts at the end position, and expands out from there, noting how far every other cell is from the end position. You should replace the E (end position) with a 2, then until your algorithm encounters the S (but will not replace the S), you will expand out in a wave from the end position, setting all adjacent cells to 3, then the adjacent cells of the 3's to 4, etc.

You will turn this step in, so your program should output a file named wavefront_path_map.txt that looks like the following:

[[Media:Wavefront_path_map.txt]]

Finally you will calculate the shortest path from the S to the 2. Note that this minimal distance path may not be unique. Your path will replace the S with an A, then increment through alphabet (B..Z, then AA, AB, AC..AZ if needed) with one letter per cell to indicate your path. Since some environments don't allow more than one character in a position, you may start your path over at A, i.e. A-Z, then A-Z again.

You will turn this step in, so your program should output a file named wavefront_path_plan.txt that looks like the following:

[[Media:Wavefront_path_plan.txt]]

Note that there is an alternative path with F the cell below the displayed F, and then another choice for G, as all of these paths will have the same length.

==== Deliverables ====

You will be given the  [[Image:Hallway path input.txt]] file (and change the name to path_input.txt), and your code should execute on that input file, producing the two output files.

You should turn in:

*your code
*hallway_path_map.txt
*hallway_path_plan.txt

File:Hallway path input.txt

2007-11-01T16:27:56Z

Pwt23:

Fall2007BioInspiredRobotDesignAssignment3

2007-10-31T19:44:03Z

Pwt23:

[[Category:Robot Lab (Spring 2007)]]

=== Assignment 3: Path Planning Basics===

We will not be using Roombas in this first part; rather, we will simulate a point robot. You will write a program to calculate a path through an occupancy map using the Wavefront algorithm, a breadth first search. Once the path has been planned, this turns into a dead reckoning problem, which we have already seen, and since we know how temperamental dead reckoning is, this will introduce a wrinkle. We know with dead reckoning the path your robot takes is not exactly the path you specify, and over the course of the path your robot's error grows. If your robot hits an obstacle, this will throw off the path that you had told your robot to execute and your robot may not finish the course. Before creating the path, your program must first adapt the map so that your robot will not come close to any obstacle or any wall except for the start and end positions. Then you should calculate the possible paths in the map using the Wavefront algorithm, and finally calculate a best path for your robot given the Wavefront map.

==== Updates ====
*
*rows and columns were written backwards, the first number is columns, the second number is rows
*All parts of the assignment should be done in your code, your code can be whatever language you like
*The number of rows and columns start from 1, so if rows = 9, then there are 9 rows
*For lettering your path, rather than A-Z,AA-AZ you can just start over at A again.

==== Description ====

Your program should take in a text file called path_input.txt which will look like:

[[Media:Path input.txt]]

Note that this is an example input, which will be followed in the assignment. The actual input file will be provided below.

The first line tells how many columns (9), the second line tells how many rows (8) the map has. The starting point for the path will have an S, and the ending point will have an E. All obstacles will have a 1, and open cells will have a 0.

We will assume that your robot can move one square at a time in any direction (up, down, left, right, all four diagonals), as long as it does not go off the map or into an occupied cell. We also assume that your robot takes up 1 cell. To provide your robot with a buffer so that it does not run into an obstacle or a wall given the error in its path, you will add extra occupied cells to the map. You should first increase the size of all obstacles by the size of your robot in all directions by adding a 1 in all directions around all obstacles.

You will not turn this step in, but here is a representation so that you can see what the input map would look like after your program expands the obstacles:

[[Media:Expanded_obstacles.txt]]

Next you will expand all walls by adding a 1 above the lower wall, to the right of the left wall, below the upper wall, and to the left of the right wall, do this for all cells that are not currently occupied and are not the start and end positions (i.e. for any cell that has a 0).

You will not turn this step in, but here is a representation so that you can see what the input map would look like after your program expands the walls:

[[Media:Expanded_walls.txt]]

Now we perform the Wavefront algorithm. This is a breadth first search that starts at the end position, and expands out from there, noting how far every other cell is from the end position. You should replace the E (end position) with a 2, then until your algorithm encounters the S (but will not replace the S), you will expand out in a wave from the end position, setting all adjacent cells to 3, then the adjacent cells of the 3's to 4, etc.

You will turn this step in, so your program should output a file named wavefront_path_map.txt that looks like the following:

[[Media:Wavefront_path_map.txt]]

Finally you will calculate the shortest path from the S to the 2. Note that this minimal distance path may not be unique. Your path will replace the S with an A, then increment through alphabet (B..Z, then AA, AB, AC..AZ if needed) with one letter per cell to indicate your path. Since some environments don't allow more than one character in a position, you may start your path over at A, i.e. A-Z, then A-Z again.

You will turn this step in, so your program should output a file named wavefront_path_plan.txt that looks like the following:

[[Media:Wavefront_path_plan.txt]]

Note that there is an alternative path with F the cell below the displayed F, and then another choice for G, as all of these paths will have the same length.

==== Deliverables ====

You will be given the  [[Media:hallway_path_input.txt]] file (and change the name to path_input.txt), and your code should execute on that input file, producing the two output files.

You should turn in:

*your code
*hallway_path_map.txt
*hallway_path_plan.txt

Fall2007BioInspiredRobotDesignAssignment3

2007-10-31T19:38:59Z

Pwt23:

[[Category:Robot Lab (Spring 2007)]]

=== Assignment 3 Part A: Path Planning Basics===

We will not be using Roombas in this first part; rather, we will simulate a point robot. You will write a program to calculate a path through an occupancy map using the Wavefront algorithm, a breadth first search. Once the path has been planned, this turns into a dead reckoning problem, which we have already seen, and since we know how temperamental dead reckoning is, this will introduce a wrinkle. We know with dead reckoning the path your robot takes is not exactly the path you specify, and over the course of the path your robot's error grows. If your robot hits an obstacle, this will throw off the path that you had told your robot to execute and your robot may not finish the course. Before creating the path, your program must first adapt the map so that your robot will not come close to any obstacle or any wall except for the start and end positions. Then you should calculate the possible paths in the map using the Wavefront algorithm, and finally calculate a best path for your robot given the Wavefront map.

==== Updates ====
*
*rows and columns were written backwards, the first number is columns, the second number is rows
*All parts of the assignment should be done in your code, your code can be whatever language you like
*The number of rows and columns start from 1, so if rows = 9, then there are 9 rows
*For lettering your path, rather than A-Z,AA-AZ you can just start over at A again.

==== Description ====

Your program should take in a text file called path_input.txt which will look like:

[[Media:Path input.txt]]

Note that this is an example input, which will be followed in the assignment. The actual input file will be provided below.

The first line tells how many columns (9), the second line tells how many rows (8) the map has. The starting point for the path will have an S, and the ending point will have an E. All obstacles will have a 1, and open cells will have a 0.

We will assume that your robot can move one square at a time in any direction (up, down, left, right, all four diagonals), as long as it does not go off the map or into an occupied cell. We also assume that your robot takes up 1 cell. To provide your robot with a buffer so that it does not run into an obstacle or a wall given the error in its path, you will add extra occupied cells to the map. You should first increase the size of all obstacles by the size of your robot in all directions by adding a 1 in all directions around all obstacles.

You will not turn this step in, but here is a representation so that you can see what the input map would look like after your program expands the obstacles:

[[Media:Expanded_obstacles.txt]]

Next you will expand all walls by adding a 1 above the lower wall, to the right of the left wall, below the upper wall, and to the left of the right wall, do this for all cells that are not currently occupied and are not the start and end positions (i.e. for any cell that has a 0).

You will not turn this step in, but here is a representation so that you can see what the input map would look like after your program expands the walls:

[[Media:Expanded_walls.txt]]

Now we perform the Wavefront algorithm. This is a breadth first search that starts at the end position, and expands out from there, noting how far every other cell is from the end position. You should replace the E (end position) with a 2, then until your algorithm encounters the S (but will not replace the S), you will expand out in a wave from the end position, setting all adjacent cells to 3, then the adjacent cells of the 3's to 4, etc.

You will turn this step in, so your program should output a file named wavefront_path_map.txt that looks like the following:

[[Media:Wavefront_path_map.txt]]

Finally you will calculate the shortest path from the S to the 2. Note that this minimal distance path may not be unique. Your path will replace the S with an A, then increment through alphabet (B..Z, then AA, AB, AC..AZ if needed) with one letter per cell to indicate your path. Since some environments don't allow more than one character in a position, you may start your path over at A, i.e. A-Z, then A-Z again.

You will turn this step in, so your program should output a file named wavefront_path_plan.txt that looks like the following:

[[Media:Wavefront_path_plan.txt]]

Note that there is an alternative path with F the cell below the displayed F, and then another choice for G, as all of these paths will have the same length.

==== Deliverables ====

You will be given the  [[Media:hallway_path_input.txt]] file (and change the name to path_input.txt), and your code should execute on that input file, producing the two output files.

You should turn in:

*your code
*hallway_path_map.txt
*hallway_path_plan.txt

Fall2007BioInspiredRobotDesignAssignment3

2007-10-31T19:28:33Z

Pwt23:

[[Category:Robot Lab (Spring 2007)]]

=== Assignment 3 Part A: Path Planning Basics===

We will not be using Roombas in this first part; rather, we will simulate a point robot. You will write a program to calculate a path through an occupancy map using the Wavefront algorithm, a breadth first search. Once the path has been planned, this turns into a dead reckoning problem, which we have already seen, and since we know how temperamental dead reckoning is, this will introduce a wrinkle. We know with dead reckoning the path your robot takes is not exactly the path you specify, and over the course of the path your robot's error grows. If your robot hits an obstacle, this will throw off the path that you had told your robot to execute and your robot may not finish the course. Before creating the path, your program must first adapt the map so that your robot will not come close to any obstacle or any wall except for the start and end positions. Then you should calculate the possible paths in the map using the Wavefront algorithm, and finally calculate a best path for your robot given the Wavefront map.

==== Updates ====

*rows and columns were written backwards, the first number is columns, the second number is rows
*All parts of the assignment should be done in your code, your code can be whatever language you like
*The number of rows and columns start from 1, so if rows = 9, then there are 9 rows
*For lettering your path, rather than A-Z,AA-AZ you can just start over at A again.

==== Description ====

Your program should take in a text file called path_input.txt which will look like:

[[Media:Path input.txt]]

Note that this is an example input, which will be followed in the assignment. The actual input file will be provided below.

The first line tells how many columns (9), the second line tells how many rows (8) the map has. The starting point for the path will have an S, and the ending point will have an E. All obstacles will have a 1, and open cells will have a 0.

We will assume that your robot can move one square at a time in any direction (up, down, left, right, all four diagonals), as long as it does not go off the map or into an occupied cell. We also assume that your robot takes up 1 cell. To provide your robot with a buffer so that it does not run into an obstacle or a wall given the error in its path, you will add extra occupied cells to the map. You should first increase the size of all obstacles by the size of your robot in all directions by adding a 1 in all directions around all obstacles.

You will not turn this step in, but here is a representation so that you can see what the input map would look like after your program expands the obstacles:

[[Media:Expanded_obstacles.txt]]

Next you will expand all walls by adding a 1 above the lower wall, to the right of the left wall, below the upper wall, and to the left of the right wall, do this for all cells that are not currently occupied and are not the start and end positions (i.e. for any cell that has a 0).

You will not turn this step in, but here is a representation so that you can see what the input map would look like after your program expands the walls:

[[Media:Expanded_walls.txt]]

Now we perform the Wavefront algorithm. This is a breadth first search that starts at the end position, and expands out from there, noting how far every other cell is from the end position. You should replace the E (end position) with a 2, then until your algorithm encounters the S (but will not replace the S), you will expand out in a wave from the end position, setting all adjacent cells to 3, then the adjacent cells of the 3's to 4, etc.

You will turn this step in, so your program should output a file named wavefront_path_map.txt that looks like the following:

[[Media:Wavefront_path_map.txt]]

Finally you will calculate the shortest path from the S to the 2. Note that this minimal distance path may not be unique. Your path will replace the S with an A, then increment through alphabet (B..Z, then AA, AB, AC..AZ if needed) with one letter per cell to indicate your path. Since some environments don't allow more than one character in a position, you may start your path over at A, i.e. A-Z, then A-Z again.

You will turn this step in, so your program should output a file named wavefront_path_plan.txt that looks like the following:

[[Media:Wavefront_path_plan.txt]]

Note that there is an alternative path with F the cell below the displayed F, and then another choice for G, as all of these paths will have the same length.

==== Deliverables ====

You will be given the [[Media:A3_path_input.txt ]] file (and change the name to path_input.txt), and your code should execute on that input file, producing the two output files.

You should turn in:

*your code
*wavefront_path_map.txt
*wavefront_path_plan.txt



=== Assignment 3 Part B: Path Planning Execution===
While you used simulated robots in the first part, you will use real robots in this section. In this section, you will be provided with an initial text file that represents part of the hallway on which you will perform path planning techniques you learned in the first section, but taking into account the challenges of executing the path with a real robot.

==== Description ====

*Perform path planning techniques from section A onto the provided text document of the hallway (below). Each character represents a forth of a foot.

[[Initial Text Document]]

*Take in account the diameter of the robot in the path planning. The path planning algorithms in part 1 may return paths that a point robot may travers, but not a real robot. For example, some paths might bring your robot through a 1 foot passage, but your robot's diameter is more than 1 foot. You might want iterate through potential paths returned by your path planning algorithm and discard ones that would not work for a real robot.

*Write code that would allow your robot to follow the calculated path. The robot will start facing any direction you please.

==== Notes ====

* This assignment should be included all in one program (ie your program should calculate a path, perform corrections on the path, and then move the robot without user assistance between stages).

==== Deliverables ====

*your code
*wavefront_path_map.txt
*wavefront_path_plan.txt

Connecting Roomba to Your Computer

2007-10-05T18:52:42Z

Pwt23:

[[Category:Roomba Design Lab (Winter 2007)]]
This page covers the various ways that the roomba can be connected to the computer -- namely by Bluetooth (RooTooth) and Serial (RooStick). In this lab, you should have been given a 7-pin serial cable and a Roostick (a USB to serial converter).
==Serial & RooStick==
===Windows===
#Connect the computer to the '''internet'''
#Plug the '''RooStick''' into the computer
#A '''"Found New Hardware"''' bubble should appear and install the necessary drivers
##If this does not happen, the drivers can be found by allowing Windows to search for them on the internet
##They can also be found here: http://www.silabs.com/tgwWebApp/public/web_content/products/Microcontrollers/USB/en/mcu_vcp.htm

#When the USB (CP2103) to Serial (UART) Converter is '''installed''', you can now connect your Roomba to your computer via the '''serial cable'''.
#This next step is important. You must now find the '''Serial Port Number''', a.k.a. '''Roomba Port'''. The serial port number is used to tell applications through which port must be used to talk to your Roomba. This can be found by accessing '''Device Manager''', which is Window's interface for managing hardware communicating with Windows. To access Device Manager, follow these steps:
##Right-click on '''"My Computer"''' and select '''Properties''' (you can also open My Computer Right-click somewhere in the folder, then Properties)
##A dialogue box should now appear. Click on the '''"Hardware"''' tab near the center top of the dialogue box.
##Select '''"Device Manager"'''
##If the Converter was installed correctly, in the list of devices, there should be a '''"Ports (COM & LPT)"''' Expand this menu
##Once exanded, there should be a device called '''"CP210x USB to UART Bridge Controller"''' Next to this is your Serial Port Number; Example: (COM3), (COM4), (COM6)
#'''Remember''' this port for Future reference. This is your '''Roomba Port'''.

==BlueTooth & RooTooth==
===Windows===
Run Bluetooth Setup Wizard
# Select 2nd Option ("I want to find a specific Bluetooth device and configure how this computer will use its services")
# Windows Searches for BT devices in Neighborhood (have rootooth plugged into roomba and powered on)
# Select RooTooth
# Use "default" or "1234"for the pincode
# Click Initiate Pairing
# Select COM0 Service (check mark)
# Click Configure (windows will install drivers)
# Windows Selected COM6 as the Virtual Serial Port
# Click Finish
# In "My Bluetooth Places", right-click on "Rootooth COM0" and click Connect
# open cmd.exe and run 'java -Djava.library.path=rxtxlib -classpath ".;rxtxlib/RXTXcomm.jar" roombacomm.RoombaCommTest' from the roombacomm directory
# Select "COM6" at the top and hit connect
# Have fun (you might have to use reset to get it going)
===OSX===
#Plug the RooTooth into Roomba
#Go into your Mac System Preferences.
#Under the Hardware category, select Bluetooth.
#There should be three tabs that appear at the lower top center of the box, "Settings," "Devices,", and "Sharing." Select "Devices."
# Now, click on the "Setup New Device" on the lower right of the box.
#Great, you have located the new-bluetooth-setup wizard... and it welcomes you. [[Image:Rootooth 1.png|The logo for this Wiki]] 
#Go ahead and select "Any device," because no other option is for programming robot vacuum cleaners (why, Apple, why!?) [[Image:Rootooth 2.png|The logo for this Wiki]] 
#The wizard now searches for the RooTooth. Depending on your RooTooth, it may say "RooTooth," as it appears in this screen-shot, or it may say "BlueRadios," which is the bluetooth chip used in the newer RooTooths (RooTeeth?). There will be many other bluetooth devices that appear, but just fish through the options, find RooTooth, and continue. [[Image:Rootooth 3.png|The logo for this Wiki]] 
#So the wizard finishes gathering information on the RooTooth device. Yay. Continue. [[Image:Rootooth 4.png|The logo for this Wiki]] 
#In order to "pair" RooTooth with your computer (connect RooTooth with only your computer), you must enter its password. This password may be different for each RooTooth, so consult your instructor about the matter. The password is either 'default' or '1234' [[Image:Rootooth 5.png|The logo for this Wiki]]
#Great, you are now paired. There are no services found -- this is normal. [[Image:Rootooth 6.png|The logo for this Wiki]] 
#Congratulations! You have finished with the wizard...! But you are not quite finished :( [[Image:Rootooth 7.png|The logo for this Wiki]] 
#This next step is important. Now you must find your '''Roomba Port'''. The Roomba Port is used to tell applications through which port must be used to talk to your Roomba. The Roomba Port can be found through several methods... which will now be covered here:
##'''Commnand Line''' This is probably the easiest way of finding the Roomba Port, but many people are intimidated by command-lines or do not know how they work. If this is you, skip to "Mac BlueTooth Preferences." If you choose to take this method, take note that you have gained cool-points (you are that much more 1337), which can be used to buy approving head-nods from certain peers, but are otherwise worth nothing.
###Open up Terminal.app from the Utilities folder in the Applications folder (*The terminal provided as an example here may be different colors than yours)
###Type into the prompt, "cd /dev" and hit enter
###Type into the prompt, "ls". [[Image:Rootooth 8.png|The logo for this Wiki]] 
###A long list of stuff will appear. Scroll up until you see lines of stuff that say something like "cu.something"
###Your incomplete Roomba Port is the one that says "cu.RooTooth-COM0-1," for example. Again, this depends on your RooTooth and can be something else, such as Blueradios. [[Image:Rootooth 9.png|The logo for this Wiki]] 
###Your complete Roomba Port is this cu.something text with the text "/dev/" appended onto the front of it. So if you see "cu.something," than your complete Roomba Port is "/dev/cu.something"
###Copy they port down for future reference.
##'''Mac BlueTooth Preferences'''
###Go into your Mac System Preferences.
###Under the Hardware category, select Bluetooth.
###There should be three tabs that appear at the lower top center of the box, "Settings," "Devices,", and "Sharing." Select "Devices."
### There should be an option such as "RooTooth" or "Blueradios (depending on your RooTooth)
###Highlight this option and click on "Edit Serial ports"
###Your incomplete Roomba Port is listed as the "Port Name."
###Your complete Roomba Port is that "Port Name" with "/dev/cu." appended onto the front of it. So if the "Port Name" is "RooTooth-COM0-1," than your complete Roomba Port is "/dev/cu.RooTooth-COM0-1"
###Copy they port down for future reference.

Bio-Robotics Lab (Fall 2007)

2007-09-28T19:27:01Z

Pwt23:

[[Category:Bio Robots (Fall 2007)]]
[[Category:Fall 2007 classes]]

==Course Logistics==

Prerequisites: Permission of instructor. 
Class Time: M-W-F 14:00->14:50 
Class Location: UCross Rm 149 
Office Hours: UCROSS147 Wed and Fri 12-2pm and by appointment 
Course Instructor: [[William C. Regli]], Ph.D. 
Teaching Assistants: Peter Thai <pwt23@drexel.edu> and Duc Nguyen <dn53@drexel.edu> 
Instructor Contact: Email regli (at) drexel (DOT) edu (not that this will help keep the spammers away) 
Phone 215.895.6827; Office: UC 143

==Course Objectives and Outcomes==

The goal of this class is to learn how to create software to interact with devices embodied in the physical world. Students successfully completing this class will:
#understand the basic concepts of robotics (from a computer-science point of view), including kinematics, dynamics, actuators, controllers, etc;
#perform software development to control mobile robots (specifically iRobot Roombas);
#design experiments for robotic platforms;
#measure the effectiveness of a robotic system on a given problem;
#gain experience with biologically-inspired robotics techniques (swarming, biologically inspired design, etc)
#employ cyber-infrastructure (wikis, web, etc) and engineering informatics tools (CAD, simulation, MATLAB, Maple, Pro/E, SolidWorks, ACIS, etc) to better understand the relationship between virtual models and the real world

==Lectures==

{| border="1" cellpadding="2"
!width="75"|Date
!width="150"|Assignment
!width="150"|Topic
!width="150"|Summary Notes
!width="500"|Links and References
|-
|September 24
|
|
Intro to Robot Lab
|
[[Media:CS-Robot-Lab-Spring2007-Lec-1.ppt]]
|
|-
|
|
|Introduction to Robotics
|[[Media:Introduction_to_Robotics.ppt]]
|
|-
|September 26
|
|Simulation
|[[Media:Simulation_of_Robotic_Systems.ppt]]
|
|-
|September 26
|
|Simulation
|[[Media:Simulation_of_Robotic_Systems.ppt]]
|
|-
|Week of October 8th
|[http://gicl.cs.drexel.edu/wiki/Fall2007BioInspiredRobotDesignAssignment1 Assignment 1] due
|
|[[Robotics Videos]]
|
|}


==Text==

Required texts and readings: 
# [http://gicl.cs.drexel.edu/wiki-data/images/a/af/Brooks-representation.pdf Intelligence without Representation], Rodney Brooks.
# Flesh and Machines: How Robots Will Change Us (Paperback) by Rodney Brooks, Publisher: Vintage (February 4, 2003); ISBN-10: 037572527X.
# [http://www.cs.unc.edu/~welch/media/pdf/kalman_intro.pdf Introduction to the Kalman Filter]
# [http://ocw.mit.edu/NR/rdonlyres/Aeronautics-and-Astronautics/16-412JSpring-2005/9D8DB59F-24EC-4B75-BA7A-F0916BAB2440/0/1aslam_blas_repo.pdf SLAM for Dummies]

Interested students may wish to examine the following textbooks:
*J.J. Craig. Introduction to Robotics: Mechanics and Control. Prentice Hall; 3rd edition, 2003.
*Kiyoshi Toko. Biomimetic Sensor Technology. Cambridge University Press, 2000.
*Karl Williams. Amphibionics: Build Your Own Biologically Inspired Reptilian Robot. McGraw-Hill/TAB Electronics, 2003.
*David Cook. Robot Building for Beginners. Apress, 2002.

==Grading==

The due dates are listed on the week by week breakdown of the course below. When an assignment is due on a particular date, that means the assignment is really due that week. You must arrange a time one of the TAs for this class, during the week the assignment is due in order to have your assignment evaluated and graded. As there are limited slots per TA session, it is best to schedule a time slot sooner rather than later. You also will have the opportunity to have your work graded after the lecture during the due week.

==Software==
Depending on the evolution of the class, students may have an opportunity to gain experience with a variety of computational tools, including MATLAB, SolidWorks, Pro/ENGINEER, ACIS, MAPLE, etc. Several research prototype tools may also be introduced for physics-based modeling, kinematics, etc.

[[Processing]] Setup

A skeleton [[Media:CS511.zip|Eclipse Project]] to write full-fledged Java instead of Processing. Some directions [[Roomba/Eclipse|here]]

Download Eclipse here [http://www.eclipse.org]

==Miscellaneous Resources==

Wiki page for Winter 2007 Roomba Lab:
[http://gicl.cs.drexel.edu/wiki/Category:Roomba_Design_Lab_%28Winter_2007%29]

Page from Spring 2007 Robotics Lab:
[http://gicl.cs.drexel.edu/wiki/Category:Roomba_Design_Lab_%28Winter_2007%29]

iRobot Create Forums: [http://createforums.irobot.com/]

Robotics Primer Workbook based around the Create [http://roboticsprimer.sourceforge.net/workbook/Main_Page]

Fall2007BioInspiredRobotDesignAssignment2

2007-09-24T05:09:30Z

Pwt23:

[[Category:Robot Lab (Spring 2007)]]
== Assignment 2: Robotic SLAM (Simultaneous Localization and Mapping) ==

==== Description of Assignment ====

Your Roomba will be placed in a random location in a rectangular arena of unknown dimension. The arena will have an unknown number of Roomba invisible walls (IR walls projecting a cone) pointing into the arena. Your Roomba must explore the arena and provide a map of the arena including an estimate of the dimensions of the arena, the location of the invisible walls, and an estimate of the number of invisible walls. In order to allow all students to get time in the arena, your Roomba must do this in 10 minutes, and your procedure must terminate.

Your source code will need to output the dimensions of the arena and have one of the TAs check this at the end of the execution (physically show the printout to the TA).

Your source code will also need to generate an xpm file (see [http://en.wikipedia.org/wiki/XPM_%28image_format%29]
) and a printout of the mapping from X and Y pixel dimensions to real world dimensions (e.g. each pixel represents an area of 6 inches by 6 inches) which must also be shown to the TA upon completion. The xpm file "wallmap.xpm" will contain your automated mapping of the arena, and will plot the locations of the invisible wall fields in the arena (display everywhere in the arena that your Roomba encountered the presence of an invisible wall). You should use white for the arena background and black for the locations of the invisible wall fields.

You should create a short writeup of this lab (2 pages at most) which details your strategies/algorithms/ideas for performing this lab, and references or other resources you used, any problems you encountered and how you overcame them. If you tried multiple different strategies before your final one then describe the progression of ideas, and why you gave up on earlier ideas. Your writeup should also include your estimate for how many invisible walls there were, the dimensions of the arena, and the scale of your xpm file and directionally mapping, basically everything you showed to the TA upon completion of your execution. Finally, include any conclusions that you have from this lab, analysis of your strategies and estimates of error would be appropriate here, along with anything else you feel is relevant.

==== Information about Roomba Virtual Walls ====

RoombaComm provides a method to access whether your Roomba can detect a virtual wall, which returns a boolean value. You must refresh the sensors before checking for a virtual wall.

The following information is from Dan Lofaro:

The Virtual Wall projects an IR cone because it is simply emitting IR light out from the IR LED. This light goes in all directions if there was nothing to block it. The intensity of the light is the same whenever you are a distance 'x' from the LED. this means that you can sweep an arc or radius 'x' in all directions, up down left and right, that has the same IR intensity on the given surface. the roomba's IR sensor picks up this signal and will trigger at a specific intensity. Thus the area that the roomba will pickup that there is a virtual wall looks like a cone.

[[Image:roomba_Vwall.JPG|center|thumb|450px]]

==== Deliverables for this Assignment ====

*Have a TA watch your execution, the TA will place your Roomba in a random location
*The TA must see that your program terminates
*Upon termination, the TA must see that your program outputs the xpm file (and checks what it displays as your estimates for the invisible wall maps), the printout of the mapping between the xpms and real world dimensions, the printout of the dimensions of the arena, and the printout of the estimate for the number of invisible walls
*You must include a directional mapping of your bitmap file to the arena, see below for more information
*You must then turn in a writeup of the assignment, your source code, and your xpm file

Notes:
*you may assume that your Roomba is facing one of the four walls if you want, please note this and any other assumptions in your report

==== Arena for this Assignment ====

This picture presents the dimensions of the arena, and the number and placement of the invisible walls for this assignment. You can use this info to construct a test arena and to estimate your error.

North and East are indicated on the arena picture, these are not real directions, just reference directions for this arena, with SouthWest in the corner with the virtual wall. You must indicate the mapping from your bitmap file of the arena to the arena directions using two directions. In other words, something like "in my bitmap file, left maps to west and up maps to north" or "in my bitmap file, left maps to north and up maps to east".

[[Image:Arena.JPG |center|thumb|600px]]

Fall2007BioInspiredRobotDesignAssignment1

2007-09-24T05:08:20Z

Pwt23:

[[Category:Robot Lab (Spring 2007)]]
==Assignment 1: Robotic Control and Dead-reckoning==
The three parts of this assignment basically amount to the Freshman [[Roomba Design Lab (Winter 2007)]]. The purpose of this assignment is to familiarize you with controlling the Robot using a computer while introducing some basic algorithms for movement.
== Part 1 ==
===Objective===
Roomba Challenge #1 is a set of "cattle chutes", i.e. a maze with 1 path and no detours. The maze requires the Roomba to make several turns to reach the end. The maze can be "short cut" for a faster time via some measurements and sensing.
===Implementation Challenges===
Though the first maze is relatively easy, setting up the environment will provide that extra bit of frustration that puts it on par with the other mazes. The challenges you can hope to face are as such (maybe more?):
#Getting Roomba and your computer interacting
#Understanding how to communicate with Roomba via your computer
#Developing an algorithm/solution to solve the maze
#Implementing and testing the said algorithm
#Compensating for the error introduced by controlling a physical entity through digital means
While setting up and learning how to send Roomba commands is a pretty straightforward task (the only pitfalls will be troubleshooting situations), the task of designing a solution for the maze is a much more involved process. There are many ways to implement the same behavior, but some ways work better with the rest of your code. This is just the first maze, so creating an elegant algorithm is not yet necessary, but come later assignments (or even the second maze), you will have to make conscious decisions on what types of programming structures to use. The main concern here is the disparity between what your code does and how your Roomba acts. Your Roomba's strange behavior that deviates from what you perceive your algorithm to be can be attributed to external forces affecting the Roomba; this includes movement of the vehicle, friction, uncertainty in orientation, and, of course, human error. Programming and programming robots is different in this respect -- the environment is not ideal, the robot's shortcomings must be accounted for, and your code must compensate for the less than perfect conditions the surface while controlling a non-virtual entity.

The actual maze will be the hallway of University Commons. Below is a map of the
hallway in University Crossings between room 147 and room
151. You will start at room 147 and follow the path indicated by the
yellow arrows towards 151. You should avoid all of the colored
squares in the hall. Each tile in the hallway is 1 sq. ft.

[[Image:Hallway Map.gif]]

== Part 2 ==
===Objective===
Now that you have become more familiar with the Roomba programming environment, you should now be able to develop more complex uses of the senors, as well as implement more advanced algorithms to aid you in exploring a richer worlds...!

The Roomba must navigate a similar set of pathways as in Part 1. While most of the maze can be navigated via dead reckoning (like Part 1), use of additional sensors will be required to find the exit the Maze. Sensors that the teams may want to explore how to use include the wall sensor and other bump sensors. You may want to implement a general maze exiting strategy (such as DFS/wall following).

You will not be graded on the time it takes your Roomba to exit the maze, only that it succeeds in exiting the maze.

===Implementation Challenges===
The primary areas of concern in this challenge are as such:
#More complex usages of Roomba Sensors
#Developing behaviors that handle dead-ends, diagonal turns, curves, etc...
#Detecting short-cuts that may be harder to 'sense' with basic algorithms
Because the layout of this maze will be provided for you, this maze allows you to use a combination of dead-reckoning and autonomy. You should already have a good feel of what needs to be done to move the Roomba in whichever direction you need, so the challenge here is to exercise some insight into what will allow Roomba to see what you see if you were the one walking through the maze, and then translate such a thought process into a behavior. This maze differs from the first maze in that some degree of autonomy must be achieved in order for Roomba to find its way through. However, you, Roomba's all-knowledgeable, omnipotent deity, knows the layout of the maze... so a good approach would be to guide Roomba through the certain parts of the maze that can be easily traversed via conventional dead-reckoning, and then write a behavior to sense its way through a specific obstacle, whether that be a short-cut or a traffic circle (a.k.a. roundabout, as they call them in the UK).
 [[Image:Maze 2.png|Maze 2]]

== Part 3 ==

Part 3 is intended to be a fun one: get the Roomba to play a tune. Four suggestions are given.

There are many sources of information about this problem on the Internet. Apple Mac users may have a slightly easier time, however ultimately you need to send a sequence of notes to the Roomba for it to play automatically. This can be done from MAC, Windows or Linux.

It may indeed be possible to write a direct interface (i.e. a program) that takes a MIDI file and "pipes" it directly to the Roomba. For example:
[[http://www.midisite.co.uk/midi_search/star_wars_imperial_march.html http://www.midisite.co.uk/midi_search/star_wars_imperial_march.html]] has about 20 versions of the Star Wars Imperial March. The Roomba's MIDI palette is more limited than a musical keyboard, hence you may need to remove or truncate notes outside of the Roomba's audio range.

Fall2007BioInspiredRobotDesignAssignment2

2007-09-24T05:02:32Z

Pwt23:

[[Category:Robot Lab (Spring 2007)]]

== Assignment 2: robotic SLAM (simultaneous localization and mapping) ==

==== Description of Assignment ====

Your Roomba will be placed in a random location in a rectangular arena of unknown dimension. The arena will have an unknown number of Roomba invisible walls (IR walls projecting a cone) pointing into the arena. Your Roomba must explore the arena and provide a map of the arena including an estimate of the dimensions of the arena, the location of the invisible walls, and an estimate of the number of invisible walls. In order to allow all students to get time in the arena, your Roomba must do this in 10 minutes, and your procedure must terminate.

Your source code will need to output the dimensions of the arena and have one of the TAs check this at the end of the execution (physically show the printout to the TA).

Your source code will also need to generate an xpm file (see [http://en.wikipedia.org/wiki/XPM_%28image_format%29]
) and a printout of the mapping from X and Y pixel dimensions to real world dimensions (e.g. each pixel represents an area of 6 inches by 6 inches) which must also be shown to the TA upon completion. The xpm file "wallmap.xpm" will contain your automated mapping of the arena, and will plot the locations of the invisible wall fields in the arena (display everywhere in the arena that your Roomba encountered the presence of an invisible wall). You should use white for the arena background and black for the locations of the invisible wall fields.

You should create a short writeup of this lab (2 pages at most) which details your strategies/algorithms/ideas for performing this lab, and references or other resources you used, any problems you encountered and how you overcame them. If you tried multiple different strategies before your final one then describe the progression of ideas, and why you gave up on earlier ideas. Your writeup should also include your estimate for how many invisible walls there were, the dimensions of the arena, and the scale of your xpm file and directionally mapping, basically everything you showed to the TA upon completion of your execution. Finally, include any conclusions that you have from this lab, analysis of your strategies and estimates of error would be appropriate here, along with anything else you feel is relevant.

==== Information about Roomba Virtual Walls ====

RoombaComm provides a method to access whether your Roomba can detect a virtual wall, which returns a boolean value. You must refresh the sensors before checking for a virtual wall.

The following information is from Dan Lofaro:

The Virtual Wall projects an IR cone because it is simply emitting IR light out from the IR LED. This light goes in all directions if there was nothing to block it. The intensity of the light is the same whenever you are a distance 'x' from the LED. this means that you can sweep an arc or radius 'x' in all directions, up down left and right, that has the same IR intensity on the given surface. the roomba's IR sensor picks up this signal and will trigger at a specific intensity. Thus the area that the roomba will pickup that there is a virtual wall looks like a cone.

[[Image:roomba_Vwall.JPG|center|thumb|450px]]

==== Deliverables for this Assignment ====

*Have a TA watch your execution, the TA will place your Roomba in a random location
*The TA must see that your program terminates
*Upon termination, the TA must see that your program outputs the xpm file (and checks what it displays as your estimates for the invisible wall maps), the printout of the mapping between the xpms and real world dimensions, the printout of the dimensions of the arena, and the printout of the estimate for the number of invisible walls
*You must include a directional mapping of your bitmap file to the arena, see below for more information
*You must then turn in a writeup of the assignment, your source code, and your xpm file

Notes:
*you may assume that your Roomba is facing one of the four walls if you want, please note this and any other assumptions in your report

==== Arena for this Assignment ====

This picture presents the dimensions of the arena, and the number and placement of the invisible walls for this assignment. You can use this info to construct a test arena and to estimate your error.

North and East are indicated on the arena picture, these are not real directions, just reference directions for this arena, with SouthWest in the corner with the virtual wall. You must indicate the mapping from your bitmap file of the arena to the arena directions using 2 directions. In other words, something like "in my bitmap file, left maps to west and up maps to north" or "in my bitmap file, left maps to north and up maps to east".

[[Image:Arena.JPG |center|thumb|600px]]

Fall2007BioInspiredRobotDesignAssignment1

2007-09-24T04:50:29Z

Pwt23:

[[Category:Robot Lab (Spring 2007)]]
The three parts of this assignment basically amount to the Freshman [[Roomba Design Lab (Winter 2007)]]. The purpose of this assignment is to familiarize you with controlling the Robot using a computer while introducing some basic algorithms for movement.

== Part 1 ==
===Objective===
Roomba Challenge #1 is a set of "cattle chutes", i.e. a maze with 1 path and no detours. The maze requires the Roomba to make several turns to reach the end. The maze can be "short cut" for a faster time via some measurements and sensing.
===Implementation Challenges===
Though the first maze is relatively easy, setting up the environment will provide that extra bit of frustration that puts it on par with the other mazes. The challenges you can hope to face are as such (maybe more?):
#Getting Roomba and your computer interacting
#Understanding how to communicate with Roomba via your computer
#Developing an algorithm/solution to solve the maze
#Implementing and testing the said algorithm
#Compensating for the error introduced by controlling a physical entity through digital means
While setting up and learning how to send Roomba commands is a pretty straightforward task (the only pitfalls will be troubleshooting situations), the task of designing a solution for the maze is a much more involved process. There are many ways to implement the same behavior, but some ways work better with the rest of your code. This is just the first maze, so creating an elegant algorithm is not yet necessary, but come later assignments (or even the second maze), you will have to make conscious decisions on what types of programming structures to use. The main concern here is the disparity between what your code does and how your Roomba acts. Your Roomba's strange behavior that deviates from what you perceive your algorithm to be can be attributed to external forces affecting the Roomba; this includes movement of the vehicle, friction, uncertainty in orientation, and, of course, human error. Programming and programming robots is different in this respect -- the environment is not ideal, the robot's shortcomings must be accounted for, and your code must compensate for the less than perfect conditions the surface while controlling a non-virtual entity.

The actual maze will be the hallway of University Commons. Below is a map of the
hallway in University Crossings between room 147 and room
151. You will start at room 147 and follow the path indicated by the
yellow arrows towards 151. You should avoid all of the colored
squares in the hall. Each tile in the hallway is 1 sq. ft.

[[Image:Hallway Map.gif]]

== Part 2 ==
===Objective===
Now that you have become more familiar with the Roomba programming environment, you should now be able to develop more complex uses of the senors, as well as implement more advanced algorithms to aid you in exploring a richer worlds...!

The Roomba must navigate a similar set of pathways as in Part 1. While most of the maze can be navigated via dead reckoning (like Part 1), use of additional sensors will be required to find the exit the Maze. Sensors that the teams may want to explore how to use include the wall sensor and other bump sensors. You may want to implement a general maze exiting strategy (such as DFS/wall following).

You will not be graded on the time it takes your Roomba to exit the maze, only that it succeeds in exiting the maze.

===Implementation Challenges===
The primary areas of concern in this challenge are as such:
#More complex usages of Roomba Sensors
#Developing behaviors that handle dead-ends, diagonal turns, curves, etc...
#Detecting short-cuts that may be harder to 'sense' with basic algorithms
Because the layout of this maze will be provided for you, this maze allows you to use a combination of dead-reckoning and autonomy. You should already have a good feel of what needs to be done to move the Roomba in whichever direction you need, so the challenge here is to exercise some insight into what will allow Roomba to see what you see if you were the one walking through the maze, and then translate such a thought process into a behavior. This maze differs from the first maze in that some degree of autonomy must be achieved in order for Roomba to find its way through. However, you, Roomba's all-knowledgeable, omnipotent deity, knows the layout of the maze... so a good approach would be to guide Roomba through the certain parts of the maze that can be easily traversed via conventional dead-reckoning, and then write a behavior to sense its way through a specific obstacle, whether that be a short-cut or a traffic circle (a.k.a. roundabout, as they call them in the UK).
 [[Image:Maze 2.png|Maze 2]]

== Part 3 ==

Part 3 is intended to be a fun one: get the Roomba to play a tune. Four suggestions are given.

There are many sources of information about this problem on the Internet. Apple Mac users may have a slightly easier time, however ultimately you need to send a sequence of notes to the Roomba for it to play automatically. This can be done from MAC, Windows or Linux.

It may indeed be possible to write a direct interface (i.e. a program) that takes a MIDI file and "pipes" it directly to the Roomba. For example:
[[http://www.midisite.co.uk/midi_search/star_wars_imperial_march.html http://www.midisite.co.uk/midi_search/star_wars_imperial_march.html]] has about 20 versions of the Star Wars Imperial March. The Roomba's MIDI palette is more limited than a musical keyboard, hence you may need to remove or truncate notes outside of the Roomba's audio range.

Fall2007BioInspiredRobotDesignAssignment1

2007-09-24T04:48:38Z

Pwt23:

[[Category:Robot Lab (Spring 2007)]]
The three parts of this assignment basically amount to the Freshman [[Roomba Design Lab (Winter 2007)]]. The purpose of this assignment is to familiarize you with controlling the Robot using a computer while introducing some basic algorithms for movement.

== Part 1 ==
===Objective===
Roomba Challenge #1 is a set of "cattle chutes", i.e. a maze with 1 path and no detours. The maze requires the Roomba to make several turns to reach the end. The maze can be "short cut" for a faster time via some measurements and sensing.
===Implementation Challenges===
Though the first maze is relatively easy, setting up the environment will provide that extra bit of frustration that puts it on par with the other mazes. The challenges you can hope to face are as such (maybe more?):
#Getting Roomba and your computer interacting
#Understanding how to communicate with Roomba via your computer
#Developing an algorithm/solution to solve the maze
#Implementing and testing the said algorithm
#Compensating for the error introduced by controlling a physical entity through digital means
While setting up and learning how to send Roomba commands is a pretty straightforward task (the only pitfalls will be troubleshooting situations), the task of designing a solution for the maze is a much more involved process. There are many ways to implement the same behavior, but some ways work better with the rest of your code. This is just the first maze, so creating an elegant algorithm is not yet necessary, but come later assignments (or even the second maze), you will have to make conscious decisions on what types of programming structures to use. The main concern here is the disparity between what your code does and how your Roomba acts. Your Roomba's strange behavior that deviates from what you perceive your algorithm to be can be attributed to external forces affecting the Roomba; this includes movement of the vehicle, friction, uncertainty in orientation, and, of course, human error. Programming and programming robots is different in this respect -- the environment is not ideal, the robot's shortcomings must be accounted for, and your code must compensate for the less than perfect conditions the surface while controlling a non-virtual entity.

The actual maze will be the hallway of University Commons. Below is a map of the
hallway in University Crossings between room 147 and room
151. You will start at room 147 and follow the path indicated by the
yellow arrows towards 151. You should avoid all of the colored
squares in the hall. Each tile in the hallway is 1 sq. ft.

[[Image:Hallway Map.gif]]

== Part 2 ==
===Objective===
Now that you have become more familiar with the Roomba programming environment, you should now be able to develop more complex uses of the senors, as well as implement more advanced algorithms to aid you in exploring a richer worlds...!

The Roomba must navigate a similar set of pathways as in Part 1. While most of the maze can be navigated via dead reckoning (like Part 1), use of additional sensors will be required to find the exit the Maze. Sensors that the teams may want to explore how to use include the wall sensor and other bump sensors. You may want to implement a general maze exiting strategy (such as DFS/wall following).

You will not be graded on the time it takes your Roomba to exit the maze, only that it succeeds in exiting the maze.

===Implementation Challenges===
The primary areas of concern in this challenge are as such:
#More complex usages of Roomba Sensors
#Developing behaviors that handle dead-ends, diagonal turns, curves, etc...
#Detecting short-cuts that may be harder to 'sense' with basic algorithms
Because the layout of this maze will be provided for you, this maze allows you to use a combination of dead-reckoning and autonomy. You should already have a good feel of what needs to be done to move the Roomba in whichever direction you need, so the challenge here is to exercise some insight into what will allow Roomba to see what you see if you were the one walking through the maze, and then translate such a thought process into a behavior. This maze differs from the first maze in that some degree of autonomy must be achieved in order for Roomba to find its way through. However, you, Roomba's all-knowledgeable, omnipotent deity, knows the layout of the maze... so a good approach would be to guide Roomba through the certain parts of the maze that can be easily traversed via conventional dead-reckoning, and then write a behavior to sense its way through a specific obstacle, whether that be a short-cut or a traffic circle (a.k.a. roundabout, as they call them in the UK).
 [[Image:Maze 2.png|Maze 2]]

== Part 3 ==

Have the Roomba sing a song.

see [http://gicl.cs.drexel.edu/wiki/Challenge_4 Winter 2007 Challenge 4]

Fall2007BioInspiredRobotDesignAssignment1

2007-09-24T04:40:30Z

Pwt23:

Fall2007BioInspiredRobotDesignAssignment3

2007-09-24T04:14:39Z

Pwt23:

[[Category:Robot Lab (Spring 2007)]]

=== Assignment 3: Path Planning ===

We will not be using Roombas in this assignment, rather we will simulate a point robot. In this assignment you will write a program to calculate a path through an occupancy map using the Wavefront algorithm, a breadth first search. Once the path has been planned, this turns into a dead reckoning problem, which we have already seen, and since we know how temperamental dead reckoning is, this will introduce a wrinkle. We know with dead reckoning the path your robot takes is not exactly the path you specify, and over the course of the path your robot's error grows. If your robot hits an obstacle, this will throw off the path that you had told your robot to execute and your robot may not finish the course. Before creating the path, your program must first adapt the map so that your robot will not come close to any obstacle or any wall except for the start and end positions. Then you should calculate the possible paths in the map using the Wavefront algorithm, and finally calculate a best path for your robot given the Wavefront map.

==== Updates ====

*rows and columns were written backwards, the first number is columns, the second number is rows
*All parts of the assignment should be done in your code, your code can be whatever language you like
*The number of rows and columns start from 1, so if rows = 9, then there are 9 rows
*For lettering your path, rather than A-Z,AA-AZ you can just start over at A again.

==== Description of Assignment ====

Your program should take in a text file called path_input.txt which will look like:

[[Media:Path input.txt]]

Note that this is an example input, which will be followed in the assignment. The actual input file will be provided below.

The first line tells how many columns (9), the second line tells how many rows (8) the map has. The starting point for the path will have an S, and the ending point will have an E. All obstacles will have a 1, and open cells will have a 0.

We will assume that your robot can move one square at a time in any direction (up, down, left, right, all four diagonals), as long as it does not go off the map or into an occupied cell. We also assume that your robot takes up 1 cell. To provide your robot with a buffer so that it does not run into an obstacle or a wall given the error in its path, you will add extra occupied cells to the map. You should first increase the size of all obstacles by the size of your robot in all directions by adding a 1 in all directions around all obstacles.

You will not turn this step in, but here is a representation so that you can see what the input map would look like after your program expands the obstacles:

[[Media:Expanded_obstacles.txt]]

Next you will expand all walls by adding a 1 above the lower wall, to the right of the left wall, below the upper wall, and to the left of the right wall, do this for all cells that are not currently occupied and are not the start and end positions (i.e. for any cell that has a 0).

You will not turn this step in, but here is a representation so that you can see what the input map would look like after your program expands the walls:

[[Media:Expanded_walls.txt]]

Now we perform the Wavefront algorithm. This is a breadth first search that starts at the end position, and expands out from there, noting how far every other cell is from the end position. You should replace the E (end position) with a 2, then until your algorithm encounters the S (but will not replace the S), you will expand out in a wave from the end position, setting all adjacent cells to 3, then the adjacent cells of the 3's to 4, etc.

You will turn this step in, so your program should output a file named wavefront_path_map.txt that looks like the following:

[[Media:Wavefront_path_map.txt]]

Finally you will calculate the shortest path from the S to the 2. Note that this minimal distance path may not be unique. Your path will replace the S with an A, then increment through alphabet (B..Z, then AA, AB, AC..AZ if needed) with one letter per cell to indicate your path. Since some environments don't allow more than one character in a position, you may start your path over at A, i.e. A-Z, then A-Z again.

You will turn this step in, so your program should output a file named wavefront_path_plan.txt that looks like the following:

[[Media:Wavefront_path_plan.txt]]

Note that there is an alternative path with F the cell below the displayed F, and then another choice for G, as all of these paths will have the same length.

==== Deliverables ====

You will be given the [[Media:A3_path_input.txt ]] file (and change the name to path_input.txt), and your code should execute on that input file, producing the two output files.

You should turn in:

*your code
*wavefront_path_map.txt
*wavefront_path_plan.txt

For gradudate students, you must implement the Wavefront algorithm in addition to one other path-planning algorithm that you find (other than a Random Walk). For some examples, see chapter 2 of Steven LaValle's Planning Algorithms book at http://planning.cs.uiuc.edu/. Please provide a short description of what other algorithm you choose and how it works. Graduate students must then turn in:

*your code
*wavefront_path_map.txt
*wavefront_path_plan.txt
*the output file of your additional algorithm
*any other support files for your additional algorithm
*README file, containing a short description of your additional algorithm and how it works, and an explanation of what additional files you are turning in

Fall2007BioInspiredRobotDesignAssignment2

2007-09-24T04:13:59Z

Pwt23:

[[Category:Robot Lab (Spring 2007)]]

=== Assignment 2: robotic SLAM (simultaneous localization and mapping) ===

Updates:
*note the change from bmp to xpm
*after some discussion, reporting your original location has been removed from the assignment
*you may assume that your Roomba is facing one of the four walls if you want, please note this and any other assumptions in your report

==== Description of Assignment ====

Your Roomba will be placed in a random location in a rectangular arena of unknown dimension. The arena will have an unknown number of Roomba invisible walls (IR walls projecting a cone) pointing into the arena. Your Roomba must explore the arena and provide a map of the arena including an estimate of the dimensions of the arena, the location of the invisible walls, and an estimate of the number of invisible walls. In order to allow all students to get time in the arena, your Roomba must do this in 10 minutes, and your procedure must terminate.

Your source code will need to output the dimensions of the arena and have one of the TAs check this at the end of the execution (physically show the printout to the TA).

Your source code will also need to generate an xpm file (see [http://en.wikipedia.org/wiki/XPM_%28image_format%29]
) and a printout of the mapping from X and Y pixel dimensions to real world dimensions (e.g. each pixel represents an area of 6 inches by 6 inches) which must also be shown to the TA upon completion. The xpm file "wallmap.xpm" will contain your automated mapping of the arena, and will plot the locations of the invisible wall fields in the arena (display everywhere in the arena that your Roomba encountered the presence of an invisible wall). You should use white for the arena background and black for the locations of the invisible wall fields.

You should create a short writeup of this lab (2 pages at most) which details your strategies/algorithms/ideas for performing this lab, and references or other resources you used, any problems you encountered and how you overcame them. If you tried multiple different strategies before your final one then describe the progression of ideas, and why you gave up on earlier ideas. Your writeup should also include your estimate for how many invisible walls there were, the dimensions of the arena, and the scale of your xpm file and directionally mapping, basically everything you showed to the TA upon completion of your execution. Finally, include any conclusions that you have from this lab, analysis of your strategies and estimates of error would be appropriate here, along with anything else you feel is relevant.

==== Information about Roomba Virtual Walls ====

RoombaComm provides a method to access whether your Roomba can detect a virtual wall, which returns a boolean value. You must refresh the sensors before checking for a virtual wall.

The following information is from Dan Lofaro:

The Virtual Wall projects an IR cone because it is simply emitting IR light out from the IR LED. This light goes in all directions if there was nothing to block it. The intensity of the light is the same whenever you are a distance 'x' from the LED. this means that you can sweep an arc or radius 'x' in all directions, up down left and right, that has the same IR intensity on the given surface. the roomba's IR sensor picks up this signal and will trigger at a specific intensity. Thus the area that the roomba will pickup that there is a virtual wall looks like a cone.

[[Image:roomba_Vwall.JPG|center|thumb|450px]]

==== Deliverables for this Assignment ====

*have a TA watch your execution, the TA will place your Roomba in a random location
*the TA must see that your program terminates
*upon termination, the TA must see that your program outputs the xpm file (and checks what it displays as your estimates for the invisible wall maps), the printout of the mapping between the xpms and real world dimensions, the printout of the dimensions of the arena, and the printout of the estimate for the number of invisible walls
*you must include a directional mapping of your bitmap file to the arena, see below for more information
*you must then turn in a writeup of the assignment, your source code, and your xpm file

==== Arena for this Assignment ====

This picture presents the dimensions of the arena, and the number and placement of the invisible walls for this assignment. You can use this info to construct a test arena and to estimate your error.

North and East are indicated on the arena picture, these are not real directions, just reference directions for this arena, with SouthWest in the corner with the virtual wall. You must indicate the mapping from your bitmap file of the arena to the arena directions using 2 directions. In other words, something like "in my bitmap file, left maps to west and up maps to north" or "in my bitmap file, left maps to north and up maps to east".

[[Image:Arena.JPG |center|thumb|600px]]

Fall2007BioInspiredRobotDesignAssignment1

2007-09-24T04:13:24Z

Pwt23:

[[Category:Robot Lab (Spring 2007)]]

Assignment 1 consists of 3 parts, which basically amount to the Freshman robot design lab course.

Assignment 1 will be further refined, but this is a good starting point for you to work towards.

=== Part 1 ===

Have the Roomba exit a predefined maze (this may not be the exact maze, we will update this) by dead reckoning.

see [http://gicl.cs.drexel.edu/wiki/Challenge_1 Winter 2007 Challenge 1] for more information about the task, but note that this is not the actual maze.

The actual maze will be the hallway of University Commons. Below is a map of the
hallway in University Crossings between room 147 and room
151. You will start at room 147 and follow the path indicated by the
yellow arrows towards 151. You should avoid all of the colored
squares in the hall. Each tile in the hallway is 1 sq. ft.

[[Image:Hallway Map.gif]]

=== Part 2 ===

Implement a general maze exiting strategy (such as DFS/wall following) for the Roomba to exit a maze.

see [http://gicl.cs.drexel.edu/wiki/Challenge_2 Winter 2007 Challenge 2] for more information.

You will not be graded on the time it takes your Roomba to exit the maze, only that it succeeds in exiting the maze.

=== Part 3 ===

Have the Roomba sing a song.

see [http://gicl.cs.drexel.edu/wiki/Challenge_4 Winter 2007 Challenge 4]

Challenge 1

2007-09-20T23:21:53Z

Pwt23:

[[Category:Roomba Design Lab (Winter 2007)]]
==Objective==
Roomba Challenge #1 is a set of "cattle chutes", i.e. a maze with 1 path and no detours. The maze is 6ft by 12ft and requires the Roomba to make several turns to reach the end. The maze can be "short cut" for a faster time via some measurements and sensing.
==Implementation Challenges==
Though the first maze is relatively easy compared to the other two, setting up the environment will provide that extra bit of frustration that makes it on par with the other mazes. The challenges that you will will be exposed to in this first maze are as such (maybe more?):
#Getting Roomba and your computer interacting
#Understanding how to communicate with Roomba via your computer
#Developing an algorithm/solution to solve the maze
#Implementing and testing the said algorithm
#Compensating for the error introduced by controlling a physical entity through digital means
While setting up and learning how to send Roomba commands is a pretty straightforward task (the only pitfalls will be troubleshooting sitations), the task of designing a solution for the maze is a much more involved process. There are many ways to implement the same behavior, but some ways work better with the rest of your code. This is just the first maze, so creating an elegant algorithm is not yet necessary, but come the third and even the second maze, you will have to make conscious decisions on what types of programming structures to use. The main concern here is the disparity between what your code does and how your Roomba acts. Your Roomba's strange behavior that deviates from what you perceive your algorithm to be can be attributed to external forces affecting the Roomba; this includes movement of the vehicle, friction, uncertainty in orientation, and, of course, human error. Programming and programming robots is different in this respect -- the environment is not ideal, the robot's shortcomings must be accounted for, and your code must compensate for the less than perfect conditions the surface while controlling a non-virtual entity.
 [[Image:Maze 1.png|Maze 1]]

Challenge 2

2007-02-19T00:27:02Z

Pwt23:

[[Category:Roomba Design Lab (Winter 2007)]]
==Objective==
In Roomba Challenge #2, The Maze, the Roomba must navigate a similar set of pathways as in Challenge #1. While most of the maze can be navigated via dead reckoning (like Challenge #1), use of additional sensors will be required to find the exit the Maze. Sensors that the teams may want to explore how to use include the wall sensor and other bump sensors.

The Maze will start off somewhat like that of Challenge #1, however it will be 12x12 and require additional smarts to get out of. It will be set up for practice by the Feb 11 (location TBA).

==Implementation Challenges==
Now that you have become more familiar with the Roomba programming environment, you should now be able to develop more complex uses of the senors, as well as implement more advanced algorithms to aid you in exploring a richer worlds...! Program your Roomba from one end to other and, if you are smart, discover well hidden pathways to hasten your endeavor! The primary areas of concern in this challenge are such:
#More complex usages of Roomba Sensors
#Developing behaviors that handle dead-ends, diagonal turns, curves, etc...
#Detecting short-cuts that may be harder to 'sense' with basic algorithms
Because the layout of this maze will be provided for you (though with less time than the first maze), this maze allows you to use a combination of dead-reckoning and autonomy. You should already have a good feel of what needs to be done to move the Roomba in whichever direction you need, so the challenge here is to exersize some insight into what will allow Roomba to see what you see if you were the one walking through the maze, and then translate such a thought process into a behavior. This maze differs from the first maze in that some degree of autonomy must be achieved in order for Roomba to find its way through the maze. However, you, Roomba's all-knowledgeable, omnipotent deity, knows the layout of the maze... so a good approach would be to guide Roomba through the certain parts of the maze that can be easily traversed via conventional dead-reckoning, and then write a behavior to sense its way through a specific obstacle, whether that be a short-cut or a traffic circle (a.k.a. roundabout, as they call them in the UK).
 [[Image:Maze 2.png|Maze 2]]

Challenge 1

2007-02-19T00:26:32Z

Pwt23:

[[Category:Roomba Design Lab (Winter 2007)]]
==Objective==
Roomba Challenge #1 is a set of "cattle chutes", i.e. a maze with 1 path and no detours. The maze is 6ft by 12ft and requires the Roomba to make several turns to reach the end. The maze can be "short cut" for a faster time via some measurements and sensing.
==Implementation Challenges==
Though the first maze is relatively easy compared to the other two, setting up the environment will provide that extra bit of frustration that makes it on par with the other mazes. The challenges that you will will be exposed to in this first maze are as such (maybe more?):
#Getting Roomba and your computer interacting
#Understanding how to communicate with Roomba via the Processing language, which is actually something like Java
#Developing an algorithm/solution to solve the maze
#Implementing and testing the said algorithm
#Compensating for the error introduced by controlling a physical entity through digital means
While setting up and learning how to send Roomba commands is a pretty straightforward task (the only pitfalls will be troubleshooting sitations), the task of designing a solution for the maze is a much more involved process. There are many ways to implement the same behavior, but some ways work better with the rest of your code. This is just the first maze, so creating an elegant algorithm is not yet necessary, but come the third and even the second maze, you will have to make conscious decisions on what types of programming structures to use. The main concern here is the disparity between what your code does and how your Roomba acts. Your Roomba's strange behavior that deviates from what you perceive your algorithm to be can be attributed to external forces affecting the Roomba; this includes movement of the vehicle, friction, uncertainty in orientation, and, of course, human error. Programming and programming robots is different in this respect -- the environment is not ideal, the robot's shortcomings must be accounted for, and your code must compensate for the less than perfect conditions the surface while controlling a non-virtual entity.
 [[Image:Maze 1.png|Maze 1]]

Challenge 1

2007-02-19T00:26:21Z

Pwt23:

[[Category:Roomba Design Lab (Winter 2007)]]
==Objective==
Roomba Challenge #1 is a set of "cattle chutes", i.e. a maze with 1 path and no detours. The maze is 6ft by 12ft and requires the Roomba to make several turns to reach the end. The maze can be "short cut" for a faster time via some measurements and sensing.
==Implementation Challenges==
Though the first maze is relatively easy compared to the other two, setting up the environment will provide that extra bit of frustration that makes it on par with the other mazes. The challenges that you will will be exposed to in this first maze are as such (maybe more?):
#Getting Roomba and your computer interacting
#Understanding how to communicate with Roomba via the Processing language, which is actually something like Java
#Developing an algorithm/solution to solve the maze
#Implementing and testing the said algorithm
#Compensating for the error introduced by controlling a physical entity through digital means
While setting up and learning how to send Roomba commands is a pretty straightforward task (the only pitfalls will be troubleshooting sitations), the task of designing a solution for the maze is a much more involved process. There are many ways to implement the same behavior, but some ways work better with the rest of your code. This is just the first maze, so creating an elegant algorithm is not yet necessary, but come the third and even the second maze, you will have to make conscious decisions on what types of programming structures to use. The main concern here is the disparity between what your code does and how your Roomba acts. Your Roomba's strange behavior that deviates from what you perceive your algorithm to be can be attributed to external forces affecting the Roomba; this includes movement of the vehicle, friction, uncertainty in orientation, and, of course, human error. Programming and programming robots is different in this respect -- the environment is not ideal, the robot's shortcomings must be accounted for, and your code must compensate for the less than perfect conditions the surface while controlling a non-virtual entity.
[[Image:Maze 1.png|Maze 1]]

File:Maze 2.png

2007-02-19T00:24:50Z

Pwt23:

File:Maze 1.png

2007-02-19T00:24:36Z

Pwt23:

Category:Roomba Design Lab (Winter 2007)

2007-02-14T05:58:17Z

Pwt23:

==Updates==
#Drivers for the RooStick can be found here: http://www.silabs.com/tgwWebApp/public/web_content/products/Microcontrollers/USB/en/mcu_vcp.htm

#The bulletin board system is temporarily out of service...
#The code on the [http://gicl.cs.drexel.edu/people/regli/tmp/roomba-module-v5.ppt Roomba Module powerpoint] is more or less outdated.
==Goal==
This page and those in his category are to support students in Freshman Design Lab, Winter 2007.

The goal of the "Roomba Module" is to identify and encode a set of behaviors to control a Roomba Robot, enabling it to perform a series of challenges (beyond the typical vacuuming of the floor). In this lab, you will encounter the interdisciplinary realities of the real world. A Roomba robot is a electro-mechanical system, control by software, that senses and acts in the world.

In this set of assignments, you are the creator of its behavior. You must deal with the limitations and inaccuracies of the Roomba platform and its sensors by designing software that can effectively use these flawed senses to successfully carry out a set of tasks.
==Where to begin==
In order to start programming Roomba, you need to set up your environment for Roomba Development; that is, you must make the connection between your Roomba and your computer, then make sure your programming software, which is called Processing, is working properly. In order to do this, you should read these pages:
#[[Connecting Roomba to Your Computer]] - This will get Roomba configured to your computer
#[[Processing]] - This will get the programming environment Processing running on your computer
#[[RoombaComm]] - This will provide the basic commands to communicate with Roomba
#[[Roomba Program 1]] - This provides a tutorial of what your first Roomba program might look like
#[[Roomba Template]] - Download the template from this page and start writing your own program
==TheChallenge==
There are three tasks that you must be able to preform with your Roomba. The tasks and their descriptions are listed below as a quick reference. More detailed descriptions can be found at their respective pages.
===Challenge #1: The Chutes===
For more information, go to [[Challenge 1]]
===Challenge #2: The Maze===
For more information, go to [[Challenge 2]]
===Challenge #3: The Great Escape===
For more information, go to [[Challenge 3]]
===Challenge #4: Name that Tune===
For more information, go to [[Challenge 4]]
==Materials Provided==
There are two easy ways to connect Roomba to your Computer:
#7-pin Serial Cable with RooStick (CP2103 USB to UART converter)
#Rootooth (Bluetooth connector)
Both methods will be available in the labs for you to experiment with, but if I were, I would go Rootooth any chance I get. While RooStick still provides a solid interface, RooTooth provides untethered flexibility that allows you to not follow your Roomba around, program Roomba from the comfort of your seat (and not in awkward places where Roomba has wondered to), and eliminate the chance that Roomba pulls your laptop off your desk or snap the RooStick in half.

Category:Roomba Design Lab (Winter 2007)

2007-02-12T15:36:14Z

Pwt23:

==Updates==
#Drivers for the RooStick can be found here: http://www.silabs.com/tgwWebApp/public/web_content/products/Microcontrollers/USB/en/mcu_vcp.htm
#A bulletin board system has been set up by one of your peers for your benefit. It can be found at: http://pages.pgsit.org/2005/petert/phpBB2
#The code on the [http://gicl.cs.drexel.edu/people/regli/tmp/roomba-module-v5.ppt Roomba Module powerpoint] is more or less outdated.
==Goal==
This page and those in his category are to support students in Freshman Design Lab, Winter 2007.

The goal of the "Roomba Module" is to identify and encode a set of behaviors to control a Roomba Robot, enabling it to perform a series of challenges (beyond the typical vacuuming of the floor). In this lab, you will encounter the interdisciplinary realities of the real world. A Roomba robot is a electro-mechanical system, control by software, that senses and acts in the world.

In this set of assignments, you are the creator of its behavior. You must deal with the limitations and inaccuracies of the Roomba platform and its sensors by designing software that can effectively use these flawed senses to successfully carry out a set of tasks.
==Where to begin==
In order to start programming Roomba, you need to set up your environment for Roomba Development; that is, you must make the connection between your Roomba and your computer, then make sure your programming software, which is called Processing, is working properly. In order to do this, you should read these pages:
#[[Connecting Roomba to Your Computer]] - This will get Roomba configured to your computer
#[[Processing]] - This will get the programming environment Processing running on your computer
#[[RoombaComm]] - This will provide the basic commands to communicate with Roomba
#[[Roomba Program 1]] - This provides a tutorial of what your first Roomba program might look like
#[[Roomba Template]] - Download the template from this page and start writing your own program
==TheChallenge==
There are three tasks that you must be able to preform with your Roomba. The tasks and their descriptions are listed below as a quick reference. More detailed descriptions can be found at their respective pages.
===Challenge #1: The Chutes===
For more information, go to [[Challenge 1]]
===Challenge #2: The Maze===
For more information, go to [[Challenge 2]]
===Challenge #3: The Great Escape===
For more information, go to [[Challenge 3]]
===Challenge #4: Name that Tune===
For more information, go to [[Challenge 4]]
==Materials Provided==
There are two easy ways to connect Roomba to your Computer:
#7-pin Serial Cable with RooStick (CP2103 USB to UART converter)
#Rootooth (Bluetooth connector)
Both methods will be available in the labs for you to experiment with, but if I were, I would go Rootooth any chance I get. While RooStick still provides a solid interface, RooTooth provides untethered flexibility that allows you to not follow your Roomba around, program Roomba from the comfort of your seat (and not in awkward places where Roomba has wondered to), and eliminate the chance that Roomba pulls your laptop off your desk or snap the RooStick in half.

Category:Roomba Design Lab (Winter 2007)

2007-02-07T06:03:27Z

Pwt23:

==Updates==
#Drivers for the RooStick can be found here: http://www.silabs.com/tgwWebApp/public/web_content/products/Microcontrollers/USB/en/mcu_vcp.htm
#A bulletin board system has been set up by one of your peers for your benefit. It can be found at: pages.pgsit.org/2005/petert/phpBB2
#The code on the [http://gicl.cs.drexel.edu/people/regli/tmp/roomba-module-v5.ppt Roomba Module powerpoint] is more or less outdated.
==Goal==
This page and those in his category are to support students in Freshman Design Lab, Winter 2007.

The goal of the "Roomba Module" is to identify and encode a set of behaviors to control a Roomba Robot, enabling it to perform a series of challenges (beyond the typical vacuuming of the floor). In this lab, you will encounter the interdisciplinary realities of the real world. A Roomba robot is a electro-mechanical system, control by software, that senses and acts in the world.

In this set of assignments, you are the creator of its behavior. You must deal with the limitations and inaccuracies of the Roomba platform and its sensors by designing software that can effectively use these flawed senses to successfully carry out a set of tasks.
==Where to begin==
In order to start programming Roomba, you need to set up your environment for Roomba Development; that is, you must make the connection between your Roomba and your computer, then make sure your programming software, which is called Processing, is working properly. In order to do this, you should read these pages:
#[[Connecting Roomba to Your Computer]] - This will get Roomba configured to your computer
#[[Processing]] - This will get the programming environment Processing running on your computer
#[[RoombaComm]] - This will provide the basic commands to communicate with Roomba
#[[Roomba Program 1]] - This provides a tutorial of what your first Roomba program might look like
#[[Roomba Template]] - Download the template from this page and start writing your own program
==TheChallenge==
There are three tasks that you must be able to preform with your Roomba. The tasks and their descriptions are listed below as a quick reference. More detailed descriptions can be found at their respective pages.
===Challenge #1: The Chutes===
For more information, go to [[Challenge 1]]
===Challenge #2: The Maze===
For more information, go to [[Challenge 2]]
===Challenge #3: The Great Escape===
For more information, go to [[Challenge 3]]
===Challenge #4: Name that Tune===
For more information, go to [[Challenge 4]]
==Materials Provided==
There are two easy ways to connect Roomba to your Computer:
#7-pin Serial Cable with RooStick (CP2103 USB to UART converter)
#Rootooth (Bluetooth connector)
Both methods will be available in the labs for you to experiment with, but if I were, I would go Rootooth any chance I get. While RooStick still provides a solid interface, RooTooth provides untethered flexibility that allows you to not follow your Roomba around, program Roomba from the comfort of your seat (and not in awkward places where Roomba has wondered to), and eliminate the chance that Roomba pulls your laptop off your desk or snap the RooStick in half.

Category:Roomba Design Lab (Winter 2007)

2007-02-07T05:54:39Z

Pwt23:

==Updates==
#Drivers for the RooStick can be found here: http://www.silabs.com/tgwWebApp/public/web_content/products/Microcontrollers/USB/en/mcu_vcp.htm
#A bulletin board system has been set up by one of your peers for your benefit. It can be found at: pages.pgsit.org/2005/petert/phpBB2
#The information on the [http://gicl.cs.drexel.edu/people/regli/tmp/roomba-module-v5.ppt Roomba Module powerpoint] is more or less outdated.
==Goal==
This page and those in his category are to support students in Freshman Design Lab, Winter 2007.

The goal of the "Roomba Module" is to identify and encode a set of behaviors to control a Roomba Robot, enabling it to perform a series of challenges (beyond the typical vacuuming of the floor). In this lab, you will encounter the interdisciplinary realities of the real world. A Roomba robot is a electro-mechanical system, control by software, that senses and acts in the world.

In this set of assignments, you are the creator of its behavior. You must deal with the limitations and inaccuracies of the Roomba platform and its sensors by designing software that can effectively use these flawed senses to successfully carry out a set of tasks.
==Where to begin==
In order to start programming Roomba, you need to set up your environment for Roomba Development; that is, you must make the connection between your Roomba and your computer, then make sure your programming software, which is called Processing, is working properly. In order to do this, you should read these pages:
#[[Connecting Roomba to Your Computer]] - This will get Roomba configured to your computer
#[[Processing]] - This will get the programming environment Processing running on your computer
#[[RoombaComm]] - This will provide the basic commands to communicate with Roomba
#[[Roomba Program 1]] - This provides a tutorial of what your first Roomba program might look like
#[[Roomba Template]] - Download the template from this page and start writing your own program
==TheChallenge==
There are three tasks that you must be able to preform with your Roomba. The tasks and their descriptions are listed below as a quick reference. More detailed descriptions can be found at their respective pages.
===Challenge #1: The Chutes===
For more information, go to [[Challenge 1]]
===Challenge #2: The Maze===
For more information, go to [[Challenge 2]]
===Challenge #3: The Great Escape===
For more information, go to [[Challenge 3]]
===Challenge #4: Name that Tune===
For more information, go to [[Challenge 4]]
==Materials Provided==
There are two easy ways to connect Roomba to your Computer:
#7-pin Serial Cable with RooStick (CP2103 USB to UART converter)
#Rootooth (Bluetooth connector)
Both methods will be available in the labs for you to experiment with, but if I were, I would go Rootooth any chance I get. While RooStick still provides a solid interface, RooTooth provides untethered flexibility that allows you to not follow your Roomba around, program Roomba from the comfort of your seat (and not in awkward places where Roomba has wondered to), and eliminate the chance that Roomba pulls your laptop off your desk or snap the RooStick in half.

Connecting Roomba to Your Computer

2007-02-07T05:54:20Z

Pwt23:

[[Category:Roomba Design Lab (Winter 2007)]]
This page covers the various ways that the roomba can be connected to the computer -- namely by Bluetooth (RooTooth) and Serial (RooStick). In this lab, you should have been given a 7-pin serial cable and a Roostick (a USB to serial converter).
==Serial & RooStick==
===Windows===
#Connect the computer to the '''internet'''
#Plug the '''RooStick''' into the computer
#A '''"Found New Hardware"''' bubble should appear and install the necessary drivers
##If this does not happen, the drivers can be found by allowing Windows to search for them on the internet
##They can also be found here: http://www.silabs.com/tgwWebApp/public/web_content/products/Microcontrollers/USB/en/mcu_vcp.htm

#When the USB (CP2103) to Serial (UART) Converter is '''installed''', you can now connect your Roomba to your computer via the '''serial cable'''.
#This next step is important. You must now find the '''Serial Port Number''', a.k.a. '''Roomba Port'''. The serial port number is used to tell applications through which port must be used to talk to your Roomba. This can be found by accessing '''Device Manager''', which is Window's interface for managing hardware communicating with Windows. To access Device Manager, follow these steps:
##Right-click on '''"My Computer"''' and select '''Properties''' (you can also open My Computer Right-click somewhere in the folder, then Properties)
##A dialogue box should now appear. Click on the '''"Hardware"''' tab near the center top of the dialogue box.
##Select '''"Device Manager"'''
##If the Converter was installed correctly, in the list of devices, there should be a '''"Ports (COM & LPT)"''' Expand this menu
##Once exanded, there should be a device called '''"CP210x USB to UART Bridge Controller"''' Next to this is your Serial Port Number; Example: (COM3), (COM4), (COM6)
##'''Remember''' this port for Future reference. This is your '''Roomba Port'''.
===OSX===
As of now, there is no driver for Intel-Macs, only Power PC based Macs. However, Intel-Macs have blutooth and can be used with RooTooth.
==BlueTooth & RooTooth==
===Windows===
Run Bluetooth Setup Wizard
# Select 2nd Option ("I want to find a specific Bluetooth device and configure how this computer will use its services")
# Windows Searches for BT devices in Neighborhood (have rootooth plugged into roomba and powered on)
# Select RooTooth
# Use "default" for pincode
# Click Initiate Pairing
# Select COM0 Service (check mark)
# Click Configure (windows will install drivers)
# Windows Selected COM6 as the Virtual Serial Port
# Click Finish
# In "My Bluetooth Places", right-click on "Rootooth COM0" and click Connect
# open cmd.exe and run 'java -Djava.library.path=rxtxlib -classpath ".;rxtxlib/RXTXcomm.jar" roombacomm.RoombaCommTest' from the roombacomm directory
# Select "COM6" at the top and hit connect
# Have fun (you might have to use reset to get it going)
===OSX===
#Plug the RooTooth into Roomba
#Go into your Mac System Preferences.
#Under the Hardware category, select Bluetooth.
#There should be three tabs that appear at the lower top center of the box, "Settings," "Devices,", and "Sharing." Select "Devices."
# Now, click on the "Setup New Device" on the lower right of the box.
#Great, you have located the new-bluetooth-setup wizard... and it welcomes you. [[Image:Rootooth 1.png|The logo for this Wiki]] 
#Go ahead and select "Any device," because no other option is for programming robot vacuum cleaners (why, Apple, why!?) [[Image:Rootooth 2.png|The logo for this Wiki]] 
#The wizard now searches for the RooTooth. Depending on your RooTooth, it may say "RooTooth," as it appears in this screen-shot, or it may say "BlueRadios," which is the bluetooth chip used in the newer RooTooths (RooTeeth?). There will be many other bluetooth devices that appear, but just fish through the options, find RooTooth, and continue. [[Image:Rootooth 3.png|The logo for this Wiki]] 
#So the wizard finishes gathering information on the RooTooth device. Yay. Continue. [[Image:Rootooth 4.png|The logo for this Wiki]] 
#In order to "pair" RooTooth with your computer (connect RooTooth with only your computer), you must enter its password. This password may be different for each RooTooth, so consult your instructor about the matter. [[Image:Rootooth 5.png|The logo for this Wiki]]
#Great, you are now paired. There are no services found -- this is normal. [[Image:Rootooth 6.png|The logo for this Wiki]] 
#Congratulations! You have finished with the wizard...! But you are not quite finished :( [[Image:Rootooth 7.png|The logo for this Wiki]] 
#This next step is important. Now you must find your '''Roomba Port'''. The Roomba Port is used to tell applications through which port must be used to talk to your Roomba. The Roomba Port can be found through several methods... which will now be covered here:
##'''Commnand Line''' This is probably the easiest way of finding the Roomba Port, but many people are intimidated by command-lines or do not know how they work. If this is you, skip to "Mac BlueTooth Preferences." If you choose to take this method, take note that you have gained cool-points (you are that much more 1337), which can be used to buy approving head-nods from certain peers, but are otherwise worth nothing.
###Open up Terminal.app from the Utilities folder in the Applications folder (*The terminal provided as an example here may be different colors than yours)
###Type into the prompt, "cd /dev" and hit enter
###Type into the prompt, "ls". [[Image:Rootooth 8.png|The logo for this Wiki]] 
###A long list of stuff will appear. Scroll up until you see lines of stuff that say something like "cu.something"
###Your incomplete Roomba Port is the one that says "cu.RooTooth-COM0-1," for example. Again, this depends on your RooTooth and can be something else, such as Blueradios. [[Image:Rootooth 9.png|The logo for this Wiki]] 
###Your complete Roomba Port is this cu.something text with the text "/dev/" appended onto the front of it. So if you see "cu.something," than your complete Roomba Port is "/dev/cu.something"
###Copy they port down for future reference.
##'''Mac BlueTooth Preferences'''
###Go into your Mac System Preferences.
###Under the Hardware category, select Bluetooth.
###There should be three tabs that appear at the lower top center of the box, "Settings," "Devices,", and "Sharing." Select "Devices."
### There should be an option such as "RooTooth" or "Blueradios (depending on your RooTooth)
###Highlight this option and click on "Edit Serial ports"
###Your incomplete Roomba Port is listed as the "Port Name."
###Your complete Roomba Port is that "Port Name" with "/dev/cu." appended onto the front of it. So if the "Port Name" is "RooTooth-COM0-1," than your complete Roomba Port is "/dev/cu.RooTooth-COM0-1"
###Copy they port down for future reference.

Category:Roomba Design Lab (Winter 2007)

2007-02-07T05:53:37Z

Pwt23:

==Notes==
#Drivers for the RooStick can be found here: http://www.silabs.com/tgwWebApp/public/web_content/products/Microcontrollers/USB/en/mcu_vcp.htm
#A bulletin board system has been set up by one of your peers for your benefit. It can be found at: pages.pgsit.org/2005/petert/phpBB2
#The information on the [http://gicl.cs.drexel.edu/people/regli/tmp/roomba-module-v5.ppt Roomba Module powerpoint] is more or less outdated.
==Goal==
This page and those in his category are to support students in Freshman Design Lab, Winter 2007.

The goal of the "Roomba Module" is to identify and encode a set of behaviors to control a Roomba Robot, enabling it to perform a series of challenges (beyond the typical vacuuming of the floor). In this lab, you will encounter the interdisciplinary realities of the real world. A Roomba robot is a electro-mechanical system, control by software, that senses and acts in the world.

In this set of assignments, you are the creator of its behavior. You must deal with the limitations and inaccuracies of the Roomba platform and its sensors by designing software that can effectively use these flawed senses to successfully carry out a set of tasks.
==Where to begin==
In order to start programming Roomba, you need to set up your environment for Roomba Development; that is, you must make the connection between your Roomba and your computer, then make sure your programming software, which is called Processing, is working properly. In order to do this, you should read these pages:
#[[Connecting Roomba to Your Computer]] - This will get Roomba configured to your computer
#[[Processing]] - This will get the programming environment Processing running on your computer
#[[RoombaComm]] - This will provide the basic commands to communicate with Roomba
#[[Roomba Program 1]] - This provides a tutorial of what your first Roomba program might look like
#[[Roomba Template]] - Download the template from this page and start writing your own program
==TheChallenge==
There are three tasks that you must be able to preform with your Roomba. The tasks and their descriptions are listed below as a quick reference. More detailed descriptions can be found at their respective pages.
===Challenge #1: The Chutes===
For more information, go to [[Challenge 1]]
===Challenge #2: The Maze===
For more information, go to [[Challenge 2]]
===Challenge #3: The Great Escape===
For more information, go to [[Challenge 3]]
===Challenge #4: Name that Tune===
For more information, go to [[Challenge 4]]
==Materials Provided==
There are two easy ways to connect Roomba to your Computer:
#7-pin Serial Cable with RooStick (CP2103 USB to UART converter)
#Rootooth (Bluetooth connector)
Both methods will be available in the labs for you to experiment with, but if I were, I would go Rootooth any chance I get. While RooStick still provides a solid interface, RooTooth provides untethered flexibility that allows you to not follow your Roomba around, program Roomba from the comfort of your seat (and not in awkward places where Roomba has wondered to), and eliminate the chance that Roomba pulls your laptop off your desk or snap the RooStick in half.

Category:Roomba Design Lab (Winter 2007)

2007-02-05T17:05:28Z

Pwt23:

==Goal==
This page and those in his category are to support students in Freshman Design Lab, Winter 2007.

The goal of the "Roomba Module" is to identify and encode a set of behaviors to control a Roomba Robot, enabling it to perform a series of challenges (beyond the typical vacuuming of the floor). In this lab, you will encounter the interdisciplinary realities of the real world. A Roomba robot is a electro-mechanical system, control by software, that senses and acts in the world.

In this set of assignments, you are the creator of its behavior. You must deal with the limitations and inaccuracies of the Roomba platform and its sensors by designing software that can effectively use these flawed senses to successfully carry out a set of tasks.
==Where to begin==
In order to start programming Roomba, you need to set up your environment for Roomba Development; that is, you must make the connection between your Roomba and your computer, then make sure your programming software, which is called Processing, is working properly. In order to do this, you should read these pages:
#[[Connecting Roomba to Your Computer]] - This will get Roomba configured to your computer
#[[Processing]] - This will get the programming environment Processing running on your computer
#[[RoombaComm]] - This will provide the basic commands to communicate with Roomba
#[[Roomba Program 1]] - This provides a tutorial of what your first Roomba program might look like
#[[Roomba Template]] - Download the template from this page and start writing your own program
==TheChallenge==
There are three tasks that you must be able to preform with your Roomba. The tasks and their descriptions are listed below as a quick reference. More detailed descriptions can be found at their respective pages.
===Challenge #1: The Chutes===
For more information, go to [[Challenge 1]]
===Challenge #2: The Maze===
For more information, go to [[Challenge 2]]
===Challenge #3: The Great Escape===
For more information, go to [[Challenge 3]]
===Challenge #4: Name that Tune===
For more information, go to [[Challenge 4]]
==Materials Provided==
There are two easy ways to connect Roomba to your Computer:
#7-pin Serial Cable with RooStick (CP2103 USB to UART converter)
#Rootooth (Bluetooth connector)
Both methods will be available in the labs for you to experiment with, but if I were, I would go Rootooth any chance I get. While RooStick still provides a solid interface, RooTooth provides untethered flexibility that allows you to not follow your Roomba around, program Roomba from the comfort of your seat (and not in awkward places where Roomba has wondered to), and eliminate the chance that Roomba pulls your laptop off your desk or snap the RooStick in half.
==Notes==
#A bulletin board system has been set up by one of your peers for your benefit. It can be found at: pages.pgsit.org/2005/petert/phpBB2
#The information on the Roomba Module powerpoint is more or less outdated.

Category:Roomba Design Lab (Winter 2007)

2007-02-05T17:05:13Z

Pwt23:

==Goal==
This page and those in his category are to support students in Freshman Design Lab, Winter 2007.

The goal of the "Roomba Module" is to identify and encode a set of behaviors to control a Roomba Robot, enabling it to perform a series of challenges (beyond the typical vacuuming of the floor). In this lab, you will encounter the interdisciplinary realities of the real world. A Roomba robot is a electro-mechanical system, control by software, that senses and acts in the world.

In this set of assignments, you are the creator of its behavior. You must deal with the limitations and inaccuracies of the Roomba platform and its sensors by designing software that can effectively use these flawed senses to successfully carry out a set of tasks.
==Where to begin==
In order to start programming Roomba, you need to set up your environment for Roomba Development; that is, you must make the connection between your Roomba and your computer, then make sure your programming software, which is called Processing, is working properly. In order to do this, you should read these pages:
#[[Connecting Roomba to Your Computer]] - This will get Roomba configured to your computer
#[[Processing]] - This will get the programming environment Processing running on your computer
#[[RoombaComm]] - This will provide the basic commands to communicate with Roomba
#[[Roomba Program 1]] - This provides a tutorial of what your first Roomba program might look like
#[[Roomba Template]] - Download the template from this page and start writing your own program
==TheChallenge==
There are three tasks that you must be able to preform with your Roomba. The tasks and their descriptions are listed below as a quick reference. More detailed descriptions can be found at their respective pages.
===Challenge #1: The Chutes===
For more information, go to [[Challenge 1]]
===Challenge #2: The Maze===
For more information, go to [[Challenge 2]]
===Challenge #3: The Great Escape===
For more information, go to [[Challenge 3]]
===Challenge #4: Name that Tune===
For more information, go to [[Challenge 4]]
==Materials Provided==
There are two easy ways to connect Roomba to your Computer:
#7-pin Serial Cable with RooStick (CP2103 USB to UART converter)
#Rootooth (Bluetooth connector)
Both methods will be available in the labs for you to experiment with, but if I were, I would go Rootooth any chance I get. While RooStick still provides a solid interface, RooTooth provides untethered flexibility that allows you to not follow your Roomba around, program Roomba from the comfort of your seat (and not in awkward places where Roomba has wondered to), and eliminate the chance that Roomba pulls your laptop off your desk or snap the RooStick in half.

Roomba Program 1

2007-02-05T15:46:40Z

Pwt23:

This program is a basic autonomous behavior for Roomba and can be used as a starting place. In essence, the Roomba turns right 45 degrees when the left bump sensor is triggered, and 45 degrees left when the right bump sensor is triggered.

The source file can be found here: http://gicl.cs.drexel.edu/wiki-data/images/0/03/ROOMBA_PROGRAM_1.zip
==The Explanation==
You do not have to know how this first section works.
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Program: ROOMBA_TEMPLATE
// Description: - This a template for any Roomba program. In order to use this, simple place code in the 'while' loop in place of "// ((>>>>]]}- PLACE CODE HERE -{[[<<<<))"
// - As a Disclaimer, this loops much more complicated than it is...
//
// Drexelized By: Peter Thai - [pwt23@drexel.edu]
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

// This imports the libraries necessary for communicating with Roomba (namely RoomabComm)
import roombacomm.*;
import roombacomm.net.*;

//This stops Roomba and disconnects it from your computer.
String roombacommPort = "COM3"; // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<::::::::::::: ENTER YOUR ROOMBA PORT :::::::::::::
//String roombacommPort = "/dev/cu.RooTooth-COM0-1";
boolean hwhandshake = false;
RoombaCommSerial roombacomm = new RoombaCommSerial();
roombacomm.waitForDSR = hwhandshake;

// If Roomba fails to connect, it will print out an error and terminate the program
if ( ! roombacomm.connect(roombacommPort) )
{
println("Couldn't connect to "+roombacommPort);
System.exit(1);
}
The only line that you need to worry about is this line:
String roombacommPort = "COM3"; // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<::::::::::::: ENTER YOUR ROOMBA PORT :::::::::::::
Here, the Roomba Port is COM3. You must replace this Roomba Port with your own Roomba Port. If you do not know your Roomba Port, please refer to the end of each installation section of each [[Connecting Roomba to Your Computer]] page.

The next section informs you that the Roomba is indeed connected to your computer. First, it connects to the Roomba to your computer and puts the Roomba in "Safe Mode," which is is a mode programmed by the 1337 h4ck0rz at MIT that allows a certain degree of control of the Roomba brain over the physical components of Roomba.
// Once Roomba is connected, it will perform the following actions to indicate it has connected
println("Roomba startup on port"+roombacommPort); // Prints out the Port on which Roomba is connected
roombacomm.startup();
roombacomm.control(); // Puts Roomba in "Safe Mode"
Now that the Roomba is connected, it plays a note, pauses so that the Roomba can finish playing the note, and then updates the state of all sensors on the Roomba so that it starts fresh. The state of the sensors can be used later with commands such as roombacomm.bumpLeft() and must be updated with the updateSensors().
roombacomm.playNote(72,50); // Plays a note
roombacomm.pause(100); // Pauses Roomba while note is being played
roombacomm.updateSensors(); // Updates the state of all sensors

This next section is the actual loop that drives the robot, the algorithm, if you will. It first creates a boolean variable (boolean refers to a variable of only True or False) called "done" that is set to false. This variable "done" is set into the "while" loop as a condition to terminate or reiterate the loop. The '!' in "(!done)" negates the done, which is initially set as false... so it is now true and will continue the while loop.
// This is the main loop. It is executed continuously until the variable 'done' is set to true
boolean done = false; // This instantiates the variable 'done' and sets it to false
while (!done)
{
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// ::::::::::::: START CODE (Code goes between this thing and.... *look down*) :::::::::::::
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Now that we're actually in the while loop and we know that these next few lines of code will be reiterated continuously, we can finally start commanding Roomba. This first line, "roombacomm.goForward()," simply drives the Roomba forward. The next line, "roombacomm.pause(200)," stops the future execution of commands for 200 milliseconds so that the previous line of code can finish executing in the Roomba.
roombacomm.goForward();
roombacomm.pause(200);
Here is the "roombacomm.updateSensors()" command again... this is just to make sure that the sensors are updated again for the next few lines of code.
roombacomm.updateSensors();
Now comes the heart of the Roomba logic. The "if" statement here makes the Roomba turn right 45 degrees if the left bump sensor is triggered. The Roomba only has 2 sensors, right and a left sensor. When the "roombacom.bumpLeft()" command is called, it returns true if the left sensor is triggered and false if it is not.
if (roombacomm.bumpLeft())
{
roombacomm.spinRight(45);
}
This next else if statement turns the Roomba left 45 degrees if the right bump sensor is triggered (the "roombacomm.bumpRight()" command returns a true).
else if (roombacomm.bumpRight())
{
roombacomm.spinLeft(45);
}
roombacomm.updateSensors();

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// ::::::::::::: END CODE (Code goes between this thing and... *look up*) :::::::::::::
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
}

These last few lines of code simple stop your Roomba and then disconnect the Roomba from your computer... the chances that these few lines will ever be ran are rare.
//This stops Roomba and disconnects it from your computer.
roombacomm.stop();
roombacomm.disconnect();

Roomba Program 1

2007-02-05T15:44:27Z

Pwt23:

This program is a basic autonomous behavior for Roomba and can be used as a starting place. Where you should be looking in this sample code is the "ROOMBA PORT"

The source file can be found here: http://gicl.cs.drexel.edu/wiki-data/images/0/03/ROOMBA_PROGRAM_1.zip

==The Explanation==
You do not have to know how this first section works.
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Program: ROOMBA_TEMPLATE
// Description: - This a template for any Roomba program. In order to use this, simple place code in the 'while' loop in place of "// ((>>>>]]}- PLACE CODE HERE -{[[<<<<))"
// - As a Disclaimer, this loops much more complicated than it is...
//
// Drexelized By: Peter Thai - [pwt23@drexel.edu]
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

// This imports the libraries necessary for communicating with Roomba (namely RoomabComm)
import roombacomm.*;
import roombacomm.net.*;

//This stops Roomba and disconnects it from your computer.
String roombacommPort = "COM3"; // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<::::::::::::: ENTER YOUR ROOMBA PORT :::::::::::::
//String roombacommPort = "/dev/cu.RooTooth-COM0-1";
boolean hwhandshake = false;
RoombaCommSerial roombacomm = new RoombaCommSerial();
roombacomm.waitForDSR = hwhandshake;

// If Roomba fails to connect, it will print out an error and terminate the program
if ( ! roombacomm.connect(roombacommPort) )
{
println("Couldn't connect to "+roombacommPort);
System.exit(1);
}
The only line that you need to worry about is this line:
String roombacommPort = "COM3"; // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<::::::::::::: ENTER YOUR ROOMBA PORT :::::::::::::
Here, the Roomba Port is COM3. You must replace this Roomba Port with your own Roomba Port. If you do not know your Roomba Port, please refer to the end of each installation section of each [[Connecting Roomba to Your Computer]] page.

The next section informs you that the Roomba is indeed connected to your computer. First, it connects to the Roomba to your computer and puts the Roomba in "Safe Mode," which is is a mode programmed by the 1337 h4ck0rz at MIT that allows a certain degree of control of the Roomba brain over the physical components of Roomba.
// Once Roomba is connected, it will perform the following actions to indicate it has connected
println("Roomba startup on port"+roombacommPort); // Prints out the Port on which Roomba is connected
roombacomm.startup();
roombacomm.control(); // Puts Roomba in "Safe Mode"
Now that the Roomba is connected, it plays a note, pauses so that the Roomba can finish playing the note, and then updates the state of all sensors on the Roomba so that it starts fresh. The state of the sensors can be used later with commands such as roombacomm.bumpLeft() and must be updated with the updateSensors().
roombacomm.playNote(72,50); // Plays a note
roombacomm.pause(100); // Pauses Roomba while note is being played
roombacomm.updateSensors(); // Updates the state of all sensors

This next section is the actual loop that drives the robot, the algorithm, if you will. It first creates a boolean variable (boolean refers to a variable of only True or False) called "done" that is set to false. This variable "done" is set into the "while" loop as a condition to terminate or reiterate the loop. The '!' in "(!done)" negates the done, which is initially set as false... so it is now true and will continue the while loop.
// This is the main loop. It is executed continuously until the variable 'done' is set to true
boolean done = false; // This instantiates the variable 'done' and sets it to false
while (!done)
{
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// ::::::::::::: START CODE (Code goes between this thing and.... *look down*) :::::::::::::
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Now that we're actually in the while loop and we know that these next few lines of code will be reiterated continuously, we can finally start commanding Roomba. This first line, "roombacomm.goForward()," simply drives the Roomba forward. The next line, "roombacomm.pause(200)," stops the future execution of commands for 200 milliseconds so that the previous line of code can finish executing in the Roomba.
roombacomm.goForward();
roombacomm.pause(200);
Here is the "roombacomm.updateSensors()" command again... this is just to make sure that the sensors are updated again for the next few lines of code.
roombacomm.updateSensors();
Now comes the heart of the Roomba logic. The "if" statement here makes the Roomba turn right 45 degrees if the left bump sensor is triggered. The Roomba only has 2 sensors, right and a left sensor. When the "roombacom.bumpLeft()" command is called, it returns true if the left sensor is triggered and false if it is not.
if (roombacomm.bumpLeft())
{
roombacomm.spinRight(45);
}
This next else if statement turns the Roomba left if the right bump sensor is triggered (the "roombacomm.bumpRight()" command returns a true).
else if (roombacomm.bumpRight())
{
roombacomm.spinLeft(45);
}
roombacomm.updateSensors();

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// ::::::::::::: END CODE (Code goes between this thing and... *look up*) :::::::::::::
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
}

These last few lines of code simple stop your Roomba and then disconnect the Roomba from your computer... the chances that these few lines will ever be ran are rare.
//This stops Roomba and disconnects it from your computer.
roombacomm.stop();
roombacomm.disconnect();

RoombaComm

2007-02-05T15:04:38Z

Pwt23:

[[Category:Roomba Design Lab (Winter 2007)]]
RoombaComm is a Java library created by Tod E. Kurt that allows users to communicate with Roomba through a high-level language (Java). This library is already included in the issued Processing package. The documentary of commands provided in this library are officially available at http://todbot.com/roomba/roombacomm/javadoc/

Roomba Program 1

2007-02-05T14:58:23Z

Pwt23: