/ - Diff - Colony - Robotics Club

     #include <dragonfly_lib.h>
     #ifndef _LINEFOLLOW_H_
     #define _LINEFOLLOW_H_
      #ifndef _LINEFOLLOW_H_
      #define _LINEFOLLOW_H_
     #define LWHITE			0
     #define LGREY			1
     #define LBLACK	 		2
     #define CENTER			3
     #define NOLINE			-42
     #define LINELOST		-1
     #define NOBARCODE 		-2
     #define INTERSECTION 	-25
     #define INTERSECTION 		-25
     #define FULL_LINE 		-26
     #define NOLINE			-50
     #define FULL_LINE 		-51
     /**
      * @brief Initializes line following.
+     *
      * Must be called before line following will work.
      * Turns the analog loop off.
      */
     /* 	lineFollow_init
     	Must call before lineFollow
     	Turns analog loop off
     */
     void lineFollow_init(void);
     /**	lineFollow
      *	Must call lineFollow_init first
      *	Must be called inside a loop
      */
     /*	lineFollow
     	Must call lineFollow first
     	Must be called inside a loop
     */
     int lineFollow(int speed);
     /**	turnLeft turnRight mergeLeft mergeRight
      *	Must be called inside a loop
      *	returns 0 when complete
      */
     /*	turnLeft turnRight mergeLeft mergeRight
     	Must be called inside a loop
     	returns 0 when complete
     */
     int turnLeft(void);
     int turnRight(void);
     int mergeLeft(void);
     int mergeRight(void);
     /**
      * @brief Updates the values stored in the array to white or black based on
      * current sensor readings.
+     *
      * @param values The array of five integers to be updated.
      */
     /*	updateLine
     	Reads in the analog values
     	Fills the given array with WHITE
     	or BLACK representing the line
     */
     void updateLine(int* values);
     /**
      * @brief Returns an index of the middle of the line based on line readings.
+     *
      * Two special return values are possible:
      *   NOLINE if none of the sensors holds a black value, and
      *   FULL_LINE if all of the sensors see black.
+     *
      * Otherwise, returns a value from -4 (farthest left) to 4 (farthest right), with
      * 0 the line being centered in the middle.
+     *
      * @param colors The array of 5 readings from the line sensor.  Must be either
      *    LWHITE or LBLACK.
      * @return Either a special value or an index from -4 to 4.
+     *
      */
     /*	lineLocate
     	Finds the location of the line
     	Outputs positive for right side
     	Negative for left, or NOLINE if a line is not found
     */
     int lineLocate(int* colors);
     /**	updatebarCode
      *	Reads in and processes
      *	bar code data
      */
     /*	updatebarCode
     	Reads in and processes
     	bar code data
     */
     void updateBarCode(void);
     /**
      * @brief Gets the completed value read by the barcode reader, or NOBARCODE.
+     *
      * Returns a bar code if available (if at the end of a barcode) and resets the
      * barcodePosition to 0. Otherwise, return NOBARCODE.  *
      * @return The value of the barcode if a complete barcode, else NOBARCODE.
      */
     /*	getBarCode
     	returns a bar code, if
     	available, otherwise NOBARCODE
     */
     int getBarCode(void);
     //! A simple function to return the minimum of two integers.
     /*	min max
     	returns the minimum/maximum of two values
     */
     int min(int x, int y);
     //! A simple function to return the maximum of two integers.
     int max(int x, int y);
     /** @todo Alex: I hate these functions, but I'm keeping them so code will still work. But we should delete them sometime. */
     /**	motorLeft
      *	Commands the left motor
      *	Cannot be used to stop
      *	0-126 are backward
      *	127-255 are forward
      */
     /*	motorLeft
     	Commands the left motor
     	Cannot be used to stop
 -126 are backward
 -255 are forward
     */
     void motorLeft(int speed);
     /**	motorRight
      *	Commands the right motor
      *	Cannot be used to stop
      *	0-126 are backward
      *	127-255 are forward
      */
     /*	motorRight
     	Commands the right motor
     	Cannot be used to stop
 -126 are backward
 -255 are forward
     */
     void motorRight(int speed);
     /**	lost
      *	Internal counter to detect if the line was lost
      */
     /*	lost
     	Internal counter to detect if the line was lost
     */
     int lost;
     int onLine(void);
     #endif

     int turn(int type, int dir)
+    {
     	if(stateLength!=0)return ERROR;
     	if(dir==IRIGHT)
+        {
             stateLength++;
             state[1]=IRIGHT;
             return NORMAL;
+        }
     	if(dir==IUTURN)
+        {
             stateLength+=2;
             state[1]=state[2]=ILEFT;
             return NORMAL;
+        }
     	if(dir==ISTRAIGHT && type==SINGLE)
+        {
             stateLength++;
             state[1]=ISTRAIGHT;
             return NORMAL;
+        }
     	if(dir==ISTRAIGHT)
+        {
             stateLength+=2;
             state[1]=state[2]=ISTRAIGHT;
             return NORMAL;
+        }
     	// At this point, must be left turn
     	if(type==SINGLE)
+        {
             stateLength++;
             state[1]=ILEFT;
             return NORMAL;
+        }
     	if(type==DOUBLE_C || type==DOUBLE_T)
+        {
             stateLength+=3;
             state[1]=state[3]=ISTRAIGHT;
             state[2]=ILEFT;
             return NORMAL;
+        }
     	if(type==ON_RAMP)
+        {
             stateLength+=2;
             state[1]=ILEFT;
             state[2]=ISTRAIGHT;
             return NORMAL;
+        }
     	if(type==OFF_RAMP)
+        {
             stateLength+=2;
             state[1]=ISTRAIGHT;
             state[2]=ILEFT;
             return NORMAL;
+        }
     	if(dir==IRIGHT){stateLength++; state[1]=IRIGHT; return NORMAL;}
     	if(dir==IUTURN){stateLength+=2;  state[1]=state[2]=ILEFT; return NORMAL;}
     	if(dir==ISTRAIGHT && type==SINGLE){stateLength++; state[1]=ISTRAIGHT; return NORMAL;}
     	if(dir==ISTRAIGHT){stateLength+=2; state[1]=state[2]=ISTRAIGHT; return NORMAL;}
     	//must be left turn
     	if(type==SINGLE){stateLength++; state[1]=ILEFT; return NORMAL;}
     	if(type==DOUBLE){stateLength+=3;state[1]=state[3]=ISTRAIGHT; state[2]=ILEFT; return NORMAL;}
     	if(type==ON_RAMP){stateLength+=2; state[1]=ILEFT; state[2]=ISTRAIGHT; return NORMAL;}
     	if(type==OFF_RAMP){stateLength+=2; state[1]=ISTRAIGHT; state[2]=ILEFT; return NORMAL;}
     	//Should never get here
     	return ERROR;

trunk/code/projects/linefollowing/main.c
2	2	#include <lineFollow.h>
3	3
4	4
	5
5	6	int main(void)
6	7	{
7	8
...	...
12	13	while(1)
13	14	{
14	15
	16
	17	for(int i=0; i<8; i++){
	18	usb_puti(read_line(i));
	19	usb_putc('\t');
	20	}
	21	usb_putc(13);
	22
	23	/*
	24
15	25	for(int q=0; q<500; q++)
16	26	barCode = lineFollow(200);
17	27	while(mergeLeft());
18		for(int q=0; q<1000; q++)
19		lineFollow(200);
	28	for(int q=0; q<1000; q++)lineFollow(200);
20	29
21	30	continue;
22
23		if(barCode==-25)
24		while(turnRight());
25
	31	if(barCode==-25)while(turnRight());
26	32	continue;
27
28	33	if(barCode != -2 && barCode != LINELOST)
29	34	{
30	35	usb_puti(barCode);
31	36	usb_putc('\n');
32	37	}
	38	*/
	39
	40
	41
33	42	/*
34	43
35	44	switch (barCode)
...	...
65	74	}
66	75	return 0;
67	76	}
68
69	77	void right()
70	78	{
71	79	motor_r_set(BACKWARD, 200);
...	...
73	81	delay_ms(400);
74	82	}
75	83
	84
76	85	void straight()
77	86	{
78	87	motor_r_set(FORWARD, 210);

     #include "lineFollow.h"
     /* Old definitions, delete as soon as possible
     #define DOUBLE   	0
     #define DOUBLE		0
     #define SINGLE		1
     #define ON_RAMP		2
     #define OFF_RAMP	3
     */
     #define SINGLE      0
     #define ON_RAMP     1
     #define OFF_RAMP    2
     #define DOUBLE_C    3
     #define DOUBLE_T    4
     #define ISTRAIGHT	0
     #define ILEFT		1
     #define IRIGHT		2

     /**
      * @file lineFollow.c
      * @defgroup lineFollwing Line Following
+     *
      * 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 and the Colony Project
      * @author Dan Jacobs
      * @date 11-1-2010
      */
     #include "lineFollow.h"
     //! The number of bits expected in a barcode
     #define CODESIZE 5
     int countHi = 0;
-...
     int barCodePosition=0;
     int turnDistance=0;
     //! Counts the number of full line readings before we determine an intersection
     int intersectionFilter=0;
     int disableBarCode=0;
     //! Keeps track of where the encoder of one motor started, for use in turns.
     int encoderStart = -1;
     int encoderReset = 0;   // 0 if encoderStart has no value set
     /**
      * Initializes line following. Must be called before other line-following
      * behavior will work.
      */
     void lineFollow_init()
+    {
     	analog_init(0);
-...
     	//not on line
     	if(position == NOLINE)
+    	{
     		if(lost++ > 20)
     		if(lost++>20)
+    		{
     			orb2_set_color(GREEN);
     			motors_off();
-...
+    	}
     	else if(position == FULL_LINE)
+    	{
     		if(intersectionFilter++ > 4)
     		if(intersectionFilter++>4)
+    		{
     			orb2_set_color(RED);
     			barCodePosition=0;
-...
     /**
      * 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 0 if turn finishes otherwise return 1
      * @return 1 if the turn was executed successfully, 0 otherwise.
      */
     int turnLeft()
+    {
             /*motor_l_set(BACKWARD, 200);
             motor_l_set(BACKWARD, 200);
             motor_r_set(FORWARD, 200);
             int colors[5];
             updateLine(colors);
-...
                              return 0;
+                    }
+            }
             return 1;*/
             motor_l_set(BACKWARD,200);
             motor_r_set(FORWARD,200);
             if(!encoderReset)
+            {
                 encoderStart = encoder_get_x(RIGHT);
                 encoderReset = 1;
+            }
             if(encoder_get_x(RIGHT) < encoderStart)
+            {
                 encoderStart = 0;
                 // Temporary: display an "error message" in case of overflow.
                 // Using this for debugging, take it out soon!
                 motor_l_set(FORWARD,0);
                 motor_r_set(FORWARD,0);
                 orb_set_color(WHITE);
                 delay_ms(2000);
+            }
             if(encoder_get_x(RIGHT) - encoderStart > 300)
+            {
                 encoderReset = 0;
                 return 0;
+            }
             return 1;
+    }
-...
     /**
      * 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 0 if the turn finishes otherwise return 1
      * @return 1 if the turn was executed successfully, 0 otherwise.
      */
     int turnRight()
+    {
-...
     int getBarCode()
+    {
     	if(barCodePosition!=CODESIZE) return NOBARCODE ;
     	int temp = 0;
     	for(int i=0; i<CODESIZE; i++)
     	int i;
     	for(i=0; i<CODESIZE; i++)
     		temp += (barCode[i] << i);
     	barCodePosition = 0;
     	return temp;
-...
     		return NOLINE;
     	if(count==5)
     		return FULL_LINE;
     	return (wsum/count)-4; // Subtract 4 to center the index around the center.
     	return (wsum/count)-4;
+    }
     void updateBarCode()
+    {
     	//! Note: currently only uses one of the barcode sensors.
     	//NOTE: currently only uses one of the barcode sensors.
     	//maps the sensors to the analog input ports
     	int ports[2] = {8,1};
     	int current[2];
-...
+    }
     //! 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){

     #this is a local makefile
     # this is a local makefile
     # Relative path to the root directory (containing lib directory)
     ifndef COLONYROOT
-...
     USE_WIRELESS = 1
     # com1 = serial port. Use lpt1 to connect to parallel port.
     AVRDUDE_PORT = $(shell if uname -s |grep -i w32 >/dev/null; then echo 'COM4:'; else echo '/dev/ttyUSB*'; fi)
     AVRDUDE_PORT = $(shell if uname -s |grep -i w32 >/dev/null; then echo 'COM4:'; else echo '/dev/ttyUSB0'; fi)
     else
     COLONYROOT := ../$(COLONYROOT)

     	// Set external mux lines to outputs
     	DDRG |= 0x1C;
     	// Set line sensor mux lines to output.  Uses LCD/SPI header
     	DDRD |=0xE0;
     	// Set up first port for conversions
     	set_adc_mux(0x00);
     	adc_current_port = AN1;
     	//Start the conversion loop if requested
     	if (start_conversion)
     		analog_start_loop();
     	//Conversion loop disabled by default
+    }
-...
     	return ((adc_h << 2) | (adc_l >> 6));
+    }
     /** Returns the 10 bit value from the line sensors **/
     unsigned int read_line(int which) {
     	int adc_h;
     	int adc_l;
     	// Let any previous conversion finish
     	while (ADCSRA & _BV(ADSC));
     	ADMUX = ADMUX_OPT + AN1;
     //	which = (which&1)<<2 + (which&2) + (which&4)>>2;
             // mask so only proper bits are possible.
             PORTD = (PORTD & 0x1F) | ((which & 0x07) << 5);
     	// Start the conversion
     	ADCSRA |= _BV(ADSC);
     	// Wait for the conversion to finish
     	while (ADCSRA & _BV(ADSC));
     	adc_l = ADCL;
     	adc_h = ADCH;
     	return ((adc_h << 2) | (adc_l >> 6));
+    }
     /**
      * Returns the current position of the wheel, as an integer
      * in the range 0 - 255.
-...
+    }
     /**@}**/ //end defgroup
     ISR(ADC_vect) {
     	int adc_h = 0;
     	int adc_l = 0;
     	if(adc_loop_status != ADC_LOOP_RUNNING) return;
     	//Store the value only if this read isn't for the BOM
     	if (ADMUX != BOM_PORT) {
     		adc_l = ADCL;
     		adc_h = ADCH;
     		an_val[adc_current_port - 1].adc10 = (adc_h << 2) | (adc_l >> 6);
     		an_val[adc_current_port - 1].adc8 = adc_h;
+    	}
     	//Skip AN7 because it is not a real port
     	if (adc_current_port == AN6) {
     		ADMUX = ADMUX_OPT | EXT_MUX;
     		set_adc_mux(AN8 - 8);
     		adc_current_port = AN8;
     	//Wrap around
     	} else if (adc_current_port == AN11) {
     		adc_current_port = AN1;
     		ADMUX = ADMUX_OPT | adc_current_port;
     	//Normal increment
     	} else {
     		adc_current_port++;
     		if(adc_current_port < EXT_MUX) {
     			ADMUX = ADMUX_OPT | adc_current_port;
     		} else {
     			ADMUX = ADMUX_OPT | EXT_MUX;
     			set_adc_mux(adc_current_port - 8);
+    		}
+    	}
     	//Stop loop if signal is set
     	if(adc_sig_stop_loop) {
     		adc_sig_stop_loop = 0;
     		adc_loop_status = ADC_LOOP_STOPPED;
     		return;
+    	}
     	//Start next conversion
     	ADCSRA |= _BV(ADSC);
+    }

Project

General

Profile

Colony

Revision 1922