/ - Diff - Colony - Robotics Club

      * main.c for Traffic Navigation
      * Runs the highest level behavior for the Dynamic Traffic Navigation (DTM) SURG
+     *
      * Author: Benjamin Wasserman, Colony Project, CMU Robotics Club
      */
      * Author: Benjamin Wasserman, Colony Project, CMU Robotics Club */
     #include <dragonfly_lib.h>
     #include <wl_basic.h>

     /**
      * @file lineDrive.c
+     *
      * Provides functions to implement line driving behavior.  This program extends
      * the behavior of the line-following program by following lines automatically
      * and implementing behaviors to deal with commands passed to lineDrive.
+     *
      * @author Dan Jacobs
      * @date 11-1-2010
      */
     #include "lineDrive.h"
     int state[5];
     int state[5];       //! Stores a queue of sub-commands to be executed
     int stateCounter;
     int stateLength;
     //! Whether lineDrive is currently paused. Set to 0 on initialization.
     int stopped=1;
     /**
      * Starts the line following procedure. Must be called before other
      * line-following functions will work.  This function essentially resets the
      * state of line-following.
      */
     void lineDrive_init()
+    {
     	lineFollow_init();
-...
+    }
     /**
      * Follows a line and executes whatever command is next on the queue.
      * @param speed The speed with which to drive along the line.
      */
     int doDrive(int speed)
+    {
     	if(stopped)
-...
+    }
     /** Starts the line-drive process if paused. */
     void start(void){stopped=0;}
     /** Pauses the line-drive process. Default is started. */
     void stop(void){stopped=1;}
     /**
      * Defines a merge command in the direction specified.  A merge is a switch
      * of lanes.
      * @param dir Left or right, defined by ILEFT or IRIGHT
      */
     int merge(int dir)
+    {
     	if(stateLength!=0)return ERROR;
-...
     	return NORMAL;
+    }
     /**
      * Executes an intersection turn where the intersection type is specified by the
      * parameters.
      * @param type A valid defined intersection type
      * @param dir The direction to turn at the intersection
      */
     int turn(int type, int dir)
+    {
     	if(stateLength!=0)return ERROR;

     /**
      * @file lineFollow.c
+     *
      * Takes care of following a line. Running this program is done by calling the
      * init() function and then the lineFollow(speed) command.  However, direct use
      * of this class is discouraged as its behavior is used by lineDrive.c, which
      * extends this class to provide behavior functionality.
+     *
      * @author Dan Jacobs
      * @date 11-1-2010
      */
     #include "lineFollow.h"
     #define CODESIZE 5
-...
     int disableBarCode=0;
     /**
      * Initializes line following. Must be called before other line-following
      * behavior will work.
      */
     void lineFollow_init()
+    {
     	analog_init(0);
-...
+    }
     /**
      * Follows a line at the given speed.
      * @param speed The speed with which to follow the line.
      */
     int lineFollow(int speed)
+    {
     	int colors[5];
-...
+    }
     /**
      * Implements the left merge, assuming a line exists to the left.  Works by
      * turning off the line at an increasing angle and waiting to hit another line
      * on the left.
      */
     int mergeLeft()
+    {
     	motor_l_set(FORWARD, 200);
-...
+    }
     /**
      * Implements the right merge, assuming a line exists to the right.  Works by
      * turning off the line at an increasing angle and waiting to hit another line
      * on the right.
      */
     int mergeRight()
+    {
             motor_r_set(FORWARD, 200);
-...
     /**
      * Turns left at a cross of two lines.  Assumes that we are at lines in a cross
      * pattern, and turns until it sets straight on the new line.
      * @return 1 if the turn was executed successfully, 0 otherwise.
      */
     int turnLeft()
+    {
             motor_l_set(BACKWARD, 200);
-...
     /**
      * Turns right at a cross of two lines.  Assumes that we are at lines in a cross
      * pattern, and turns until it sets straight on the new line.
      * @return 1 if the turn was executed successfully, 0 otherwise.
      */
     int turnRight()
+    {
             motor_r_set(BACKWARD, 200);
-...
+    }
     //! A simple function to return the minimum of two integers.
     int min(int x, int y){return x>y ? y : x;}
     //! A simple function to return the maximum of two integers.
     int max(int x, int y){return x<y ? y : x;}
     void motorLeft(int speed){
-...
     void motorRight(int speed){
             ((speed-=127)>=0)?motor_r_set(FORWARD, 160+speed*95/128):motor_r_set(BACKWARD, 160-speed*95/127);
+    }

Project

General

Profile

Colony

Revision 1864