/ - Diff - Colony - Robotics Club

      * @brief Contains math function(s)
+     *
      * @author Colony Project, CMU Robotics Club, James Kong
     */
      */
     #ifndef _MATH_H_
     #define _MATH_H_

     void orb_init(void);
     /** @brief Set both orbs to a specified color **/
     void orb_set(unsigned char red_led, unsigned char green_led,
     	unsigned char blue_led);
     	     unsigned char blue_led);
     /** @brief Set orb1 to a specified color **/
     void orb1_set(unsigned char red_led, unsigned char green_led,
     	unsigned char blue_led);
     	      unsigned char blue_led);
     /** @brief Set orb2 to a specified color **/
     void orb2_set(unsigned char red_led, unsigned char green_led,
     	unsigned char blue_led);
     	      unsigned char blue_led);
     /** @brief Set both orbs to a specified color **/
     void orb_set_color(int col);

      * @author Colony Project, CMU Robotics Club, based on firefly
      * code by Tom Lauwers
     */
      */
     #ifndef _ANALOG_H
     #define _ANALOG_H
-...
     /** @brief Struct to hold the value of a particular analog port */
     typedef struct {
     	uint8_t adc8;
     	uint16_t adc10;
       uint8_t adc8;
       uint16_t adc10;
     } adc_t;
     /** @brief Initialize analog ports. Will start running a loop
     	 if start_conversion is ADC_START.**/
         if start_conversion is ADC_START.**/
     void analog_init(int start_conversion);
     /** @brief starts the analog loop. Doesn't do anything if the loop is already running. **/
     void analog_start_loop(void);

     #define _DIO_H
     /*
     these are ALL the pins
     don't use unless you know what you're doing
       these are ALL the pins
       don't use unless you know what you're doing
     */
     /*
     DIO pins on new dragonfly boards are shown below:
     -----------------------------------------------
     | _PIN_E6 | _PIN_E7 | _PIN_D2 | _PIN_D3 | VCC |
     -----------------------------------------------
     | _PIN_E2 | _PIN_E3 | _PIN_E4 | _PIN_E5 | GND |
     -----------------------------------------------
       DIO pins on new dragonfly boards are shown below:
       -----------------------------------------------
       | _PIN_E6 | _PIN_E7 | _PIN_D2 | _PIN_D3 | VCC |
       -----------------------------------------------
       | _PIN_E2 | _PIN_E3 | _PIN_E4 | _PIN_E5 | GND |
       -----------------------------------------------
     */
     /** @brief Port A **/
-...
     //#define _PIN_G7 63
     /*
     These are the header pins (the ones you can connect things to)
     Feel free to use these
       These are the header pins (the ones you can connect things to)
       Feel free to use these
     */
     /**

      **/
     /*
     	serial.h - Contains definitions and function prototypes for the RS232 serial port
       serial.h - Contains definitions and function prototypes for the RS232 serial port
       author(s): pkv
       Directions:
-...
       write characters to the serial ports.
       UART Mapping:
         usb_*() -> UART0
         xbee_*() -> UART1
       usb_*() -> UART0
       xbee_*() -> UART1
       Options: (Add the following defines to your code to configure this library)
         #define USB_BAUD { 115200 | 9600 } <= pick ONE value from in here
         #define XBEE_BAUD { 115200 | 9600 } <= pick ONE value from in here
         #define USE_STDIO
       #define USB_BAUD { 115200 | 9600 } <= pick ONE value from in here
       #define XBEE_BAUD { 115200 | 9600 } <= pick ONE value from in here
       #define USE_STDIO
       Note: If you enable USE_STDIO, the first init function that is called will
       automatically be linked to stdin, stdout, and stderr.  To use the baud rate

      * @brief Contains function(s) for resetting the robots
+     *
      * @author Colony Project, CMU Robotics Club, James Kong
     */
      */
     #ifndef _RESET_H_
     #define _RESET_H_

      **/
     /*
     time.c
     anything that requires a delay
     mostly delay_ms
       time.c
       anything that requires a delay
       mostly delay_ms
     author: Robotics Club, Colony Project
       author: Robotics Club, Colony Project
     Change Log:
 .5.07 - Kevin
     		Aaron fixed the orb/servo code and made them use timer3 but compare registers B and C. He hard set the prescaler
     		to 8 so the RTC broke. Changed it so that we use a 8 prescaler which sets the compare match at 1/16th of a second.
     		You now count how many 16ths of a second you want until you trigger your actual interrupt. Works. Changed defines
     		for time so you can still call rtc_init with a scale but now it is defined in terms of actual time like second, quarter_second
     		etc. Read that section in the time.h file for more information. Tested and works, though the clock drifts more than
     		it used to
 .30.07 - Kevin
     		Modified the clock to run on timer3 on the Dragonfly. Works with decent accuracy. Using a prescaler of 256
     	the timer counts up to a precomputer value which will trigger an interrupt and reset the timer. Multiples of
 change it by that multiple. Refer to the time.h file for all possible prescalers.
     		The interrupt will call a specified function _rtc_func every pulse.
     		All of it has been tested and it works.
       Change Log:
 .5.07 - Kevin
       Aaron fixed the orb/servo code and made them use timer3 but compare registers B and C. He hard set the prescaler
       to 8 so the RTC broke. Changed it so that we use a 8 prescaler which sets the compare match at 1/16th of a second.
       You now count how many 16ths of a second you want until you trigger your actual interrupt. Works. Changed defines
       for time so you can still call rtc_init with a scale but now it is defined in terms of actual time like second, quarter_second
       etc. Read that section in the time.h file for more information. Tested and works, though the clock drifts more than
       it used to
 .30.07 - Kevin
       Modified the clock to run on timer3 on the Dragonfly. Works with decent accuracy. Using a prescaler of 256
       the timer counts up to a precomputer value which will trigger an interrupt and reset the timer. Multiples of
 change it by that multiple. Refer to the time.h file for all possible prescalers.
       The interrupt will call a specified function _rtc_func every pulse.
       All of it has been tested and it works.
     */
     #include <avr/interrupt.h>
-...
+     *
      * @param ms the number of milliseconds to delay for
      **/
     void delay_ms(int ms)
+    {
     	for(; ms > 15; ms-=15)
     		_delay_ms(15);
     	_delay_ms(ms);
     void delay_ms(int ms) {
       for(; ms > 15; ms-=15)
         _delay_ms(15);
       _delay_ms(ms);
+    }
     /* 	Prescales defined in time.h. SECOND will give you 1 second.
     	More scales are defined in the time.h file.
     	rtc_func is the address to a function that you want called every clock tick. */
-...
      **/
     void rtc_init(int prescale_opt, void (*rtc_func)(void)) {
     	//Clear timer register for Timer 3
     	TCNT3 = 0;
       //Clear timer register for Timer 3
       TCNT3 = 0;
     	/* 	This sets the Waveform Generation Module to CTC (Clear Timer on Compare) Mode (100)
     		See page135 in Atmega128 Docs for more modes and explanations */
     	TCCR3B |= _BV(WGM32);
       /* 	This sets the Waveform Generation Module to CTC (Clear Timer on Compare) Mode (100)
     	See page135 in Atmega128 Docs for more modes and explanations */
       TCCR3B |= _BV(WGM32);
     	/* 	This sets the prescaler for the system clock (8MHz) ie: divides the clock by some number.
     		Currently set to a prescaler of 8 because that is what the orb and servos use (they are on this timer as well)
     		See page137 in Atemga128 Docs for all the available prescalers */
     	TCCR3B |= _BV(CS31);
       /* 	This sets the prescaler for the system clock (8MHz) ie: divides the clock by some number.
     	Currently set to a prescaler of 8 because that is what the orb and servos use (they are on this timer as well)
     	See page137 in Atemga128 Docs for all the available prescalers */
       TCCR3B |= _BV(CS31);
     	/* 	Sets the two regsiters that we compare against. So the timer counts up to this number and
     		then resets back to 0 and calls the compare match interrupt.
 x10^6 / 8 = 1/16 Second. All values are based off of this number. Do not change it unless you
     		are l337*/
       /* 	Sets the two regsiters that we compare against. So the timer counts up to this number and
     	then resets back to 0 and calls the compare match interrupt.
 x10^6 / 8 = 1/16 Second. All values are based off of this number. Do not change it unless you
     	are l337*/
     	OCR3A = 0xF424;
       OCR3A = 0xF424;
     	/* 	Enable Output Compare A Interrupt. When OCR3A is met by the timer TCNT3 this interrupt will be
     		triggerd. (See page140 in Atmega128 Docs for more information */
     	ETIMSK |= _BV(OCIE3A);
       /* 	Enable Output Compare A Interrupt. When OCR3A is met by the timer TCNT3 this interrupt will be
     	triggerd. (See page140 in Atmega128 Docs for more information */
       ETIMSK |= _BV(OCIE3A);
     	/*	Store the pointer to the function to be used in the interrupt */
     	_rtc_f = rtc_func;
       /*	Store the pointer to the function to be used in the interrupt */
       _rtc_f = rtc_func;
     	/*	Store how many 1/16ths of a second you want to let by before triggering an interrupt */
     	_rtc_scale = prescale_opt;
       /*	Store how many 1/16ths of a second you want to let by before triggering an interrupt */
       _rtc_scale = prescale_opt;
+    }
     /**
-...
+     *
      * @see rtc_init, rtc_reset
      **/
     int rtc_get(void){
     	return _rtc_val;
     int rtc_get(void) {
       return _rtc_val;
+    }
     /**
-...
+     *
      * @see rtc_init, rtc_get
      **/
     void rtc_reset(void){
     	_rtc_val = 0;
     void rtc_reset(void) {
       _rtc_val = 0;
+    }
     /** @} **/ //end defgroup
-...
     	and when it reaches the amount of time you want, execute the code. */
     SIGNAL(TIMER3_COMPA_vect) {
     	if (_rtc_pulse ==  _rtc_scale) {
     		//Increment the real time clock counter
     		_rtc_val++;
       if (_rtc_pulse ==  _rtc_scale) {
         //Increment the real time clock counter
         _rtc_val++;
     		//Calls the function tied to the real time clock if defined
     		if(_rtc_f != 0)
     			_rtc_f();
         //Calls the function tied to the real time clock if defined
         if(_rtc_f != 0)
           _rtc_f();
     		//Resets the pulse until the next scale is matched
     		_rtc_pulse = 0;
+    	}
         //Resets the pulse until the next scale is matched
         _rtc_pulse = 0;
+      }
     	//Updates the amount of pulses seen since the last scale match
     	_rtc_pulse++;
       //Updates the amount of pulses seen since the last scale match
       _rtc_pulse++;
+    }

      * @see motors_off, motor1_set, motor2_set
      **/
     void motors_init( void ) {
     	// Configure counter such that we use phase correct
     	// PWM with 8-bit resolution
     	PORTA &= 0x0F;
     	DDRA |= 0xF0;
     	DDRB |= 0x60;
       // Configure counter such that we use phase correct
       // PWM with 8-bit resolution
       PORTA &= 0x0F;
       DDRA |= 0xF0;
       DDRB |= 0x60;
     	//timer 1A and 1B
     	TCCR1A = _BV(COM1A1) | _BV(COM1B1) | _BV(WGM10);
     	TCCR1B = _BV(WGM12) | _BV(CS10);
     //	TCCR1A = 0xA1;
     //	TCCR1B = 0x04;
     	OCR1AH=0;
     	OCR1AL=0;
     	OCR1BH=0;
     	OCR1BL=0;
       //timer 1A and 1B
       TCCR1A = _BV(COM1A1) | _BV(COM1B1) | _BV(WGM10);
       TCCR1B = _BV(WGM12) | _BV(CS10);
       //	TCCR1A = 0xA1;
       //	TCCR1B = 0x04;
       OCR1AH=0;
       OCR1AL=0;
       OCR1BH=0;
       OCR1BL=0;
+    }
     /**
-...
      **/
     void motor1_set(int direction, int speed) {
     	if(direction == 0) {
     	    // turn off PWM first if switching directions
     		if((PORTA & 0x30) != 0x10)
+    		{
     		  OCR1A = 0;
+    		}
     		PORTA = (PORTA & 0xCF) | 0x10;
     //		PORTD |= 0x10;
     //		PORTD &= 0xBF;
+    	}
     	else {
     	    // turn off PWM first if switching directions
     		if((PORTA & 0x30) != 0x20)
+    		{
     		  OCR1A = 0;
+    		}
     		PORTA = (PORTA & 0xCF) | 0x20;
     //		PORTD |= 0x40;
     //		PORTD &= 0xEF;
+    	}
       if(direction == 0) {
         // turn off PWM first if switching directions
         if((PORTA & 0x30) != 0x10) {
           OCR1A = 0;
+        }
         PORTA = (PORTA & 0xCF) | 0x10;
         //		PORTD |= 0x10;
         //		PORTD &= 0xBF;
       } else {
         // turn off PWM first if switching directions
         if((PORTA & 0x30) != 0x20) {
           OCR1A = 0;
+        }
         PORTA = (PORTA & 0xCF) | 0x20;
         //		PORTD |= 0x40;
         //		PORTD &= 0xEF;
+      }
     	// Set the timer to count up to speed, an 8-bit value
     	OCR1AL = speed;
       // Set the timer to count up to speed, an 8-bit value
       OCR1AL = speed;
+    }
     /**
-...
      * @see motor1_set, motors_init
      **/
     void motor2_set(int direction, int speed) {
     	if(direction == 0) {
     //		PORTD |= 0x20;
     //		PORTD &= 0x7F;
     	    // turn off PWM first if switching directions
     		if((PORTA & 0xC0) != 0x80)
+    		{
     		  OCR1B = 0;
+    		}
       if(direction == 0) {
         //		PORTD |= 0x20;
         //		PORTD &= 0x7F;
         // turn off PWM first if switching directions
         if((PORTA & 0xC0) != 0x80) {
           OCR1B = 0;
+        }
     		PORTA = (PORTA & 0x3F) | 0x80;
+    	}
     	else {
     //		PORTD |= 0x80;
     //		PORTD &= 0xDF;
         PORTA = (PORTA & 0x3F) | 0x80;
       } else {
         //		PORTD |= 0x80;
         //		PORTD &= 0xDF;
     	    // turn off PWM first if switching directions
     		if((PORTA & 0xC0) != 0x40)
+    		{
     		  OCR1B = 0;
+    		}
         // turn off PWM first if switching directions
         if((PORTA & 0xC0) != 0x40) {
           OCR1B = 0;
+        }
     		PORTA = (PORTA & 0x3F) | 0x40;
+    	}
     	OCR1BL = speed;
         PORTA = (PORTA & 0x3F) | 0x40;
+      }
       OCR1BL = speed;
+    }
     /**
-...
      * @see motors_init
      **/
     void motors_off( void ) {
     	OCR1AL = 0x0;
     	OCR1BL = 0x0;
       OCR1AL = 0x0;
       OCR1BL = 0x0;
+    }
     /**@}**///end defgroup

      * Initializes the ADC.
      * Call analog_init before reading from the analog ports.
+     *
      * @see analog8, analog10
      * @see analog8, analog10, analog_get8, analog_get10
      **/
     void analog_init(int start_conversion)
+    {
-...
+    	}
+    }
     /**
      * Returns the 10-bit analog conversion of which from
      * the lookup table. If the requested port is the BOM_PORT
      * you will get an automatic 0 since the BOM_PORT is not
      * read in the loop and not stored. If you need that port
      * you should use the functions in bom.c. There is an analog_get10
      * function which for instant lookups but should be avoided.
+     *
      * @param which the port that you want to read
+     *
      * @bug may cause a seg fault if which is a larger value
      * than exists in an_val table. Not sure if we should fix
      * this or not since it would add overhead.
+     *
      * @return 10-bit analog value for the which port requested
+     *
      * @see analog8, analog_get8, analog_get10
      **/
     unsigned int analog10(int which) {
     	if (which == BOM_PORT) {
     		return 0;
-...
+    	}
+    }
     /**
      * Starts the analog update loop. Will continue to run
      * until analog_stop_loop is called.
+     *
      * @see analog_stop_loop
      **/
     void analog_start_loop(void) {
     	//Start the conversion
     	ADCSRA |= _BV(ADSC);
     	adc_loop_running = 0x1;
+    }
     //will stop after current conversion finishes
     /**
      * Stops the analog update loop. If there is a current
      * read, it will finish up and be stored before the loop
      * is interrupted. No further updates will be made until
      * the loop is started again.
+     *
      * @see analog_start_loop
      **/
     void analog_stop_loop(void) {
     	//Stop the conversion
     	adc_loop_running = 0x0;
-...
     ISR(ADC_vect) {
     	static volatile int adc_prev_loop_running = 0;
     	static volatile int adc_prev_loop_running = 0;
     	int adc_h = 0;
     	int adc_l = 0;
     	//usb_putc('p');
     	//usb_puti(adc_current_port);
     	//usb_putc('r');
     	//usb_puti(adc_loop_running);
     	//usb_puts("\n\r");
     	//Store the value only if this read isn't for the BOM
     	if (ADMUX != BOM_PORT) {
     		adc_l = ADCL;
-...
     		an_val[adc_current_port - 1].adc10 = (adc_h << 2) | (adc_l >> 6);
     		an_val[adc_current_port - 1].adc8 = adc_h;
     		//usb_puti(an_val[adc_current_port - 1].adc10);
     		//usb_puts("\n\r");
     		//usb_puti(an_val[adc_current_port - 1].adc8);
     		//usb_puti(ADCH);
     		//usb_puts("\n\r");
+    	}
     	//Save the result only if we just turned off the loop
-...
+    	}
     	//Initiate next conversion only if we are running a loop
     	if (!adc_loop_running)
     	if (!adc_loop_running) {
     		return;
     	ADCSRA |= _BV(ADSC);
     	//if (ADCSRA & _BV(ADSC))
     	//	usb_putc('s');
         } else {
         	ADCSRA |= _BV(ADSC);
+    	}
     	return;
+    }

     //**************************************Old shit below!*****************
     /*
     FontLookup - a lookup table for all characters
       FontLookup - a lookup table for all characters
     */
     static const unsigned char FontLookup [][5] =
+    {
+      {
         { 0x00, 0x00, 0x00, 0x00, 0x00 },  // sp
         { 0x00, 0x00, 0x5f, 0x00, 0x00 },   // !
         { 0x00, 0x07, 0x00, 0x07, 0x00 },   // "
-...
         { 0x41, 0x41, 0x36, 0x08, 0x00 },   // }
         { 0x02, 0x01, 0x01, 0x02, 0x01 },   // ~
         { 0x55, 0x2A, 0x55, 0x2A, 0x55 },   // del
     };
       };
     /**
-...
      * Initializes the LCD. Must be called before any other
      * LCD functions.
      **/
     void lcd_init(void)
+    {
     	LCDDDR |= (SCE | SDI | SCK);
     	LCDRESETDDR |= (RST|D_C);
     void lcd_init(void) {
       LCDDDR |= (SCE | SDI | SCK);
       LCDRESETDDR |= (RST|D_C);
     	LCDPORT &= ~( SCE | SDI | SCK);
     	LCDRESETPORT &=~(D_C);
       LCDPORT &= ~( SCE | SDI | SCK);
       LCDRESETPORT &=~(D_C);
     	SPCR |= 0x50;//0b01010000; // no SPI int, SPI en, Master, sample on rising edge, fosc/2
     	SPSR |= 0x01;       // a continuation of the above
       SPCR |= 0x50;//0b01010000; // no SPI int, SPI en, Master, sample on rising edge, fosc/2
       SPSR |= 0x01;       // a continuation of the above
     	LCDRESETPORT |= RST;
     	delay_ms(10);
     	LCDRESETPORT &= (~RST);
     	delay_ms(100);
     	LCDRESETPORT |= RST;
       LCDRESETPORT |= RST;
       delay_ms(10);
       LCDRESETPORT &= (~RST);
       delay_ms(100);
       LCDRESETPORT |= RST;
     	lcd_putbyte( 0x21 );  // LCD Extended Commands.
     	lcd_putbyte( 0xC8 );  // Set LCD Vop (Contrast).
     	lcd_putbyte( 0x06 );  // Set Temp coefficent.
     	lcd_putbyte( 0x13 );  // LCD bias mode 1:48.
     	lcd_putbyte( 0x20 );  // LCD Standard Commands, Horizontal addressing mode.
     	lcd_putbyte( 0x0C );  // LCD in normal mode.
       lcd_putbyte( 0x21 );  // LCD Extended Commands.
       lcd_putbyte( 0xC8 );  // Set LCD Vop (Contrast).
       lcd_putbyte( 0x06 );  // Set Temp coefficent.
       lcd_putbyte( 0x13 );  // LCD bias mode 1:48.
       lcd_putbyte( 0x20 );  // LCD Standard Commands, Horizontal addressing mode.
       lcd_putbyte( 0x0C );  // LCD in normal mode.
     	LCDRESETPORT |= D_C;		//put it in init instead of main
       LCDRESETPORT |= D_C;		//put it in init instead of main
     	lcd_clear_screen();
       lcd_clear_screen();
+    }
     /**
-...
      * @see lcd_init
      **/
     void lcd_clear_screen( void ) {
     	int i;
     	for (i = 0; i < 504; i++)
     		lcd_putbyte(0x0);
       int i;
       for (i = 0; i < 504; i++)
         lcd_putbyte(0x0);
     	lcd_gotoxy(0,0);
       lcd_gotoxy(0,0);
+    }
     /**
-...
+     *
      * @see lcd_init
      **/
     void lcd_putc(char c)
+    {
     	int i;
     void lcd_putc(char c) {
       int i;
     	for (i = 0; i < 5; i++)
     		lcd_putbyte(FontLookup[c-32][i]);
     	lcd_putbyte(0);
       for (i = 0; i < 5; i++)
         lcd_putbyte(FontLookup[c-32][i]);
       lcd_putbyte(0);
+    }
     /*
     print an entire string to the lcd
       print an entire string to the lcd
     */
     void lcd_puts(char *s)
+    {
     	char *t = s;
     	while (*t != 0)
+    	{
     		lcd_putc(*t);
     		t++;
+    	}
     void lcd_puts(char *s) {
       char *t = s;
       while (*t != 0) {
         lcd_putc(*t);
         t++;
+      }
+    }
     /*
     go to coordinate x, y
     y: vertically - 1 char
     x: horizontally - 1 pixel
       go to coordinate x, y
       y: vertically - 1 char
       x: horizontally - 1 pixel
     multiply x by 6 if want to move 1 entire character
       multiply x by 6 if want to move 1 entire character
     origin (0,0) is at top left corner of lcd screen
       origin (0,0) is at top left corner of lcd screen
     */
     /**
-...
+     *
      * @see lcd_init
      **/
     void lcd_gotoxy(int x, int y)
+    {
     	LCDRESETPORT &= ~(D_C);
     	lcd_putbyte(0x40 | (y & 0x07));
     	lcd_putbyte(0x80 | (x & 0x7f));
     	LCDRESETPORT |= D_C;
     void lcd_gotoxy(int x, int y) {
       LCDRESETPORT &= ~(D_C);
       lcd_putbyte(0x40 | (y & 0x07));
       lcd_putbyte(0x80 | (x & 0x7f));
       LCDRESETPORT |= D_C;
+    }
     /*
     prints an int to the lcd
       prints an int to the lcd
     code adapted from Chris Efstathiou's code (hendrix@otenet.gr)
       code adapted from Chris Efstathiou's code (hendrix@otenet.gr)
     */
     /**
-...
+     *
      * @see lcd_init
      **/
     void lcd_puti(int value )
+    {
     	unsigned char lcd_data[6]={'0','0','0','0','0','0' }, position=sizeof(lcd_data), radix=10;
     void lcd_puti(int value ) {
       unsigned char lcd_data[6]={'0','0','0','0','0','0' }, position=sizeof(lcd_data), radix=10;
             /* convert int to ascii  */
             if(value<0) {
     	  lcd_putc('-');
     	  value=-value;
+    	}
             do {
     	  position--;
     	  *(lcd_data+position)=(value%radix)+'0';
     	  value/=radix;
     	} while(value);
       /* convert int to ascii  */
       if(value<0) {
         lcd_putc('-');
         value=-value;
+      }
       do {
         position--;
         *(lcd_data+position)=(value%radix)+'0';
         value/=radix;
       } while(value);
             /* start displaying the number */
             for( ; position<=(sizeof(lcd_data)-1); position++)
     		lcd_putc(lcd_data[position]);
       /* start displaying the number */
       for(;position<=(sizeof(lcd_data)-1);position++)
         lcd_putc(lcd_data[position]);
     	return;
       return;
+    }
     /** @} **/ //end defgroup
     void lcd_putbyte(unsigned char b)
+    {
     	SPDR = b;
     	while (!(SPSR & 0x80)); /* Wait until SPI transaction is complete */
     void lcd_putbyte(unsigned char b) {
       SPDR = b;
       while (!(SPSR & 0x80)); /* Wait until SPI transaction is complete */
+    }

     void translateAngulartoLinear (int velocity, int omega, int* vl, int* vr);
     // global varaibles for move_avoid
     int d1, d2, d3, d4, d5; /**
     int d1, d2, d3, d4, d5;
     /**
      * @defgroup move Movement
      * @brief Functions fo controlling robot motion
      * Higher level functions to control the movement of robots.
-...
+     *
      * @see motors_init, range_init, move
      **/
     void move_avoid(int velocity, int omega, int strength){
     void move_avoid(int velocity, int omega, int strength) {
       int pControl;
       int vl = 0;
       int vr = 0;
-...
       d5=(temp == -1) ? d5 : temp;
       /* Avoid obstacles ahead
       if(d2>170)
         v*=-1;
          if(d2>170)
          v*=-1;
       Naturally slow down if there is something in the way.
       if(d2>150 || d1>180 || d3>180){
         v>>=1;
          Naturally slow down if there is something in the way.
          if(d2>150 || d1>180 || d3>180){
          v>>=1;
       */
       //pControl= (((d3-d1) + (d4-d5))*strength)/100;
-...
     /**@}**///end the motion group
     void translateAngulartoLinear (int velocity, int omega, int* vl, int* vr) {
     	//omega: angle measure, positive couter-clockwise from front.
     	// -180 <= omega <= 180
     	//velocity: -255 <= velocity <= 255
       //omega: angle measure, positive couter-clockwise from front.
       // -180 <= omega <= 180
       //velocity: -255 <= velocity <= 255
       long int vltemp, vrtemp;
-...
       if (velocity < -255 || velocity >255 || omega < -255 || omega > 255) return;
       //compute
     	vrtemp = velocity + omega * 3;
     	vltemp = velocity - omega * 3;
       vrtemp = velocity + omega * 3;
       vltemp = velocity - omega * 3;
     	//check to see if max linear velocities have been exceeded.
       //check to see if max linear velocities have been exceeded.
       if (vrtemp > 255) {
         vltemp = 255 * vltemp / vrtemp;
         vrtemp = 255;
+      }
       if (vltemp > 255) {
     	vrtemp = 255 * vrtemp / vltemp;
     	vltemp = 255;
         vrtemp = 255 * vrtemp / vltemp;
         vltemp = 255;
+      }
       if (vrtemp < -255) {
         vltemp = -255 * vltemp / vrtemp;
-...
       *vr = (int)vrtemp;
       *vl = (int)vltemp;
+    }

       int batt_reading = battery8();
       if(next_read == 0) {
       if(next_read == 0)
+      {
         if(batt_reading > BATTERY_LOWV)
+        {
             ret = 0;
-...
       int i;
       long int sum = 0;
       for(i = 0; i < n_samples; i++) {
       for(i = 0; i < n_samples; i++)
+      {
         sum += battery8();
+      }

      * @see analog_init, usb_init, xbee_init, buzzer_init,
      * bom_init, orb_init, motors_init, lcd_init
      **/
     void dragonfly_init(int config)
+    {
     		sei();
     void dragonfly_init(int config) {
       sei();
     	// Set directionality of various IO pins
     	DDRG &= ~(_BV(PING0)|_BV(PING1));
     	PORTG |= _BV(PING0)|_BV(PING1);
       // Set directionality of various IO pins
       DDRG &= ~(_BV(PING0)|_BV(PING1));
       PORTG |= _BV(PING0)|_BV(PING1);
     	if(config & ANALOG)
     		analog_init(ADC_START);
       if(config & ANALOG)
         analog_init(ADC_START);
     	if(config & COMM)
+    	{
     		//Defaults to 115200. Check serial.h for more information.
     		usb_init();
     		xbee_init();
+    	}
       if(config & COMM) {
         //Defaults to 115200. Check serial.h for more information.
         usb_init();
         xbee_init();
+      }
     	if(config & BUZZER)
+    	{
     		sei();
     		buzzer_init();
+    	}
       if(config & BUZZER) {
         sei();
         buzzer_init();
+      }
     	if(config & ORB)
+    	{
     		sei();
     		orb_init();
+    	}
       if(config & ORB) {
         sei();
         orb_init();
+      }
     	if(config & MOTORS)
     		motors_init();
       if(config & MOTORS)
         motors_init();
     	if(config & LCD)
     		lcd_init();
       if(config & LCD)
         lcd_init();
     	if(config & ORB)
+    	{
     		sei();
     		orb_init();
+    	}
       if(config & ORB) {
         sei();
         orb_init();
+      }
     	// delay a bit for stability
     	_delay_ms(1);
       // delay a bit for stability
       _delay_ms(1);
+    }

+     *
      * @return 1 or 0, depending on the value of the portpin.
      **/
     int digital_input(int portpin){
     int digital_input(int portpin) {
       int pin = portpin & 0x7;
       int pin_val = 0;
       switch(portpin >> 3){
       switch(portpin >> 3) {
       case _PORT_A:
         DDRA &= ~_BV(pin);
         pin_val = PINA;
-...
         pin_val = PINE;
         return (pin_val >> pin) & 1;
       case _PORT_F:
         if(pin>=4){
         if(pin>=4) {
           MCUSR|=1<<7;
           MCUSR|=1<<7;
+        }
-...
           PORTG &= (0XFF - _BV(pins));
           break;
+        }
       }else { /* ( val == 1) */
       } else { /* ( val == 1) */
         switch(portpin >> 3) {
         case _PORT_A:
           DDRA |= _BV(pins);
-...
+     *
      * @see button1_wait, button1_click
      **/
     int button1_read( void )
+    {
     	int pin_val;
     	DDRG &= ~_BV(PING0);
     	PORTG|= _BV(PING0);
         pin_val = PING;
     	return !((pin_val & _BV(PING0)));
     int button1_read( void ) {
       int pin_val;
       DDRG &= ~_BV(PING0);
       PORTG|= _BV(PING0);
       pin_val = PING;
       return !((pin_val & _BV(PING0)));
+    }
     /**
-...
+     *
      * @see button1_read, button1_click
      **/
     void button1_wait( void )
+    {
     void button1_wait( void ) {
       while(!button1_read() ) {
         delay_ms(15);
+      }
-...
+     *
      * @see button1_read, button1_wait
      **/
     int button1_click()
+    {
       if(button1_read()){
     int button1_click() {
       if(button1_read()) {
         while(button1_read());
         return 1;
       }else{
       } else {
         return 0;
+      }
+    }
-...
+     *
      * @see button2_wait, button2_click
      **/
     int button2_read( void )
+    {
     	int pin_val;
     	DDRG &= ~_BV(PING1);
     	PORTG|= _BV(PING1);
         pin_val = PING;
     	return !((pin_val & _BV(PING1)));
     int button2_read( void ) {
       int pin_val;
       DDRG &= ~_BV(PING1);
       PORTG|= _BV(PING1);
       pin_val = PING;
       return !((pin_val & _BV(PING1)));
+    }
     /**
-...
+     *
      * @see button2_read, button2_click
      **/
     void button2_wait( void )
+    {
     void button2_wait( void ) {
       while(!button2_read()){
         delay_ms(15);
+      }
-...
+     *
      * @see button2_read, button2_wait
      **/
     int button2_click()
+    {
     	if(button2_read()){
     int button2_click() {
       if(button2_read()) {
         while(button2_read());
         return 1;
       }else{
     		return 0;
       } else {
         return 0;
+      }
+    }

       //Set baud rate
       // - 115200 (both wired and wireless) is UBRR=8, U2X=1
       // - 9600 is U2X =1, UBRR = 107.
     	#if (USB_BAUD == 115200)
         UBRR0H = 0x00;
         UBRR0L = 8;
         UCSR0A |= _BV(U2X0);
       #elif (USB_BAUD == 9600)
         UBRR0H = 0x00;
         UBRR0L = 103;
         UCSR0A |= _BV(U2X0);
       #else //Baud rate is defined in the header file, we should not get here
         return;
       #endif
     #if (USB_BAUD == 115200)
       UBRR0H = 0x00;
       UBRR0L = 8;
       UCSR0A |= _BV(U2X0);
     #elif (USB_BAUD == 9600)
       UBRR0H = 0x00;
       UBRR0L = 103;
       UCSR0A |= _BV(U2X0);
     #else //Baud rate is defined in the header file, we should not get here
       return;
     #endif
       /*Enable receiver and transmitter */
     	UCSR0B |= (1<<RXEN0)|(1<<TXEN0);
       UCSR0B |= (1<<RXEN0)|(1<<TXEN0);
     	/* Set frame format: 8data, 1stop bit, asynchronous normal mode */
     	UCSR0C |= (1<<UCSZ00) | (1<<UCSZ01);
       /* Set frame format: 8data, 1stop bit, asynchronous normal mode */
       UCSR0C |= (1<<UCSZ00) | (1<<UCSZ01);
       // if we have enabled the stdio stuff, then we init it here
       #ifdef USE_STDIO
         /* Open the stdio stream corresponding to this port */
         usb_fd = fdevopen(usb_putc, usb_getc);
       #endif
     #ifdef USE_STDIO
       /* Open the stdio stream corresponding to this port */
       usb_fd = fdevopen(usb_putc, usb_getc);
     #endif
+    }
     /**
-...
       //Set baud rate
       // - 115200 (both wired and wireless) is UBRR=8, U2X=1
       // - 9600 is U2X =1, UBRR = 107.
     	#if (XBEE_BAUD == 115200)
         UBRR1H = 0x00;
         UBRR1L = 8;
         UCSR1A |= _BV(U2X1);
       #elif (XBEE_BAUD == 9600)
         UBRR1H = 0x00;
         UBRR1L = 103;
         UCSR1A |= _BV(U2X1);
       #else //Baud rate is defined in the header file, we should not get here
         return;
       #endif
     #if (XBEE_BAUD == 115200)
       UBRR1H = 0x00;
       UBRR1L = 8;
       UCSR1A |= _BV(U2X1);
     #elif (XBEE_BAUD == 9600)
       UBRR1H = 0x00;
       UBRR1L = 103;
       UCSR1A |= _BV(U2X1);
     #else //Baud rate is defined in the header file, we should not get here
       return;
     #endif
     	//Enable receiver and transmitter
     	UCSR1B |= (1<<RXEN1)|(1<<TXEN1);
       //Enable receiver and transmitter
       UCSR1B |= (1<<RXEN1)|(1<<TXEN1);
     	// Set frame format: 8data, 1stop bit, asynchronous normal mode
     	UCSR1C |= (1<<UCSZ10) | (1<<UCSZ11);
       // Set frame format: 8data, 1stop bit, asynchronous normal mode
       UCSR1C |= (1<<UCSZ10) | (1<<UCSZ11);
       // if we have enabled the stdio stuff, then we init it here
       #ifdef USE_STDIO
         /* Open the stdio stream corresponding to this port */
         xbee_fd = fdevopen(xbee_putc, xbee_getc);
       #endif
     #ifdef USE_STDIO
       /* Open the stdio stream corresponding to this port */
       xbee_fd = fdevopen(xbee_putc, xbee_getc);
     #endif
+    }
     /**
-...
      * @param c the character to send
      * @return 0 for success, nonzero for failure
      **/
     int usb_putc(char c)
+    {
     int usb_putc(char c) {
       // Wait until buffer is clear for sending
       loop_until_bit_is_set(UCSR0A, UDRE0);
-...
      * @param c the character to send
      * @return 0 for success, nonzero for failure
      **/
     int xbee_putc(char c)
+    {
     int xbee_putc(char c) {
       // Wait until buffer is clear for sending
       loop_until_bit_is_set(UCSR1A, UDRE1);
-...
      * @param s the string to send
      * @return 0 for success, nonzero for failure
      **/
     int usb_puts(char *s)
+    {
     	char *t = s;
     	while (*t != 0)
+    	{
     		usb_putc(*t);
     		t++;
+    	}
     int usb_puts(char *s) {
       char *t = s;
       while (*t != 0) {
         usb_putc(*t);
         t++;
+      }
       return 0;
+    }
-...
+     *
      * @see usb_init, usb_getc_nb
      **/
     int usb_getc(void)
+    {
     	// Wait for the receive buffer to be filled
     	loop_until_bit_is_set(UCSR0A, RXC0);
     int usb_getc(void) {
       // Wait for the receive buffer to be filled
       loop_until_bit_is_set(UCSR0A, RXC0);
     	// Read the receive buffer
     	return UDR0;
       // Read the receive buffer
       return UDR0;
+    }
     /**
-...
+     *
      * @see xbee_init, xbee_getc_nb
      **/
     int xbee_getc(void)
+    {
     	// Wait for the receive buffer to be filled
         loop_until_bit_is_set(UCSR1A, RXC1);
     int xbee_getc(void) {
       // Wait for the receive buffer to be filled
       loop_until_bit_is_set(UCSR1A, RXC1);
     	// Read the receive buffer
     	return UDR1;
       // Read the receive buffer
       return UDR1;
+    }
     /**
-...
+     *
      * @see usb_init, usb_getc
      **/
     int usb_getc_nb(char *c)
+    {
     	// check if the receive buffer is filled
     int usb_getc_nb(char *c) {
       // check if the receive buffer is filled
       if (UCSR0A & _BV(RXC0)) {
         // Read the receive buffer
         (*c) = UDR0;
         return 0;
+      }
       else {
       } else {
         // Return empty
         return -1;
+    	}
+      }
+    }
     /**
-...
+     *
      * @see xbee_init, xbee_getc
      **/
     int xbee_getc_nb(char *c)
+    {
     	// check if the receive buffer is filled
     int xbee_getc_nb(char *c) {
       // check if the receive buffer is filled
       if (UCSR1A & _BV(RXC1)) {
         // Read the receive buffer
         (*c) = UDR1;
         return 0;
+      }
       else {
       } else {
         // Return empty
         return -1;
+    	}
+      }
+    }
     /*
     prints an int to serial
       prints an int to serial
     code adapted from Chris Efstathiou's code (hendrix@otenet.gr)
     uses usb_putc
       code adapted from Chris Efstathiou's code (hendrix@otenet.gr)
       uses usb_putc
     */
     /**
      * Prints an integer, converted to ASCII, to usb. usb_init must be called
-...
      * @see usb_init, usb_putc
      **/
     int usb_puti(int value ) {
     	unsigned char usb_data[6]={'0','0','0','0','0','0' }, position=sizeof(usb_data), radix=10;
       unsigned char usb_data[6]={'0','0','0','0','0','0' }, position=sizeof(usb_data), radix=10;
             /* convert int to ascii  */
             if(value<0) { usb_putc('-'); value=-value; }
             do { position--; *(usb_data+position)=(value%radix)+'0'; value/=radix;  } while(value);
       /* convert int to ascii  */
       if(value<0) {
         usb_putc('-');
         value=-value;
+      }
       do {
         position--;
         *(usb_data+position)=(value%radix)+'0';
         value/=radix;
       } while(value);
             /* start displaying the number */
             for(;position<=(sizeof(usb_data)-1);position++)
+              {
       /* start displaying the number */
       for(;position<=(sizeof(usb_data)-1);position++) {
                 usb_putc(usb_data[position]);
+              }
         usb_putc(usb_data[position]);
+      }
     	return 0;
       return 0;
+    }

      * and Status Register (MCUCSR).
      **/
     void reset(void) {
         WDTCR &= 0xF8;
         WDTCR |= 0x08;
         _delay_ms(15);
       WDTCR &= 0xF8;
       WDTCR |= 0x08;
       _delay_ms(15);
+    }
     /**@}**/ //end defgroup

      **/
     /*
     Authors: James Kong and Greg Tress
       Authors: James Kong and Greg Tress
     Last Modified: 4/30/06 by James
     -Started log_distance conversion function !!!NOT COMPLETE!!!
     -Cleaning up comments
       Last Modified: 4/30/06 by James
       -Started log_distance conversion function !!!NOT COMPLETE!!!
       -Cleaning up comments
     -----------------
     rangefinder.c
     Using Sharp GP2D02 IR Rangefinder
       -----------------
       rangefinder.c
       Using Sharp GP2D02 IR Rangefinder
     Vin is the input to the rangefinder, designated RANGE_CTRL.
     Vout is the output from the rangefinder, designated RANGE_IN# where # is the rangefinder you are reading from
       Vin is the input to the rangefinder, designated RANGE_CTRL.
       Vout is the output from the rangefinder, designated RANGE_IN# where # is the rangefinder you are reading from
     Expected Initial Conditions:
     Vin is high and Vout should read high.
       Expected Initial Conditions:
       Vin is high and Vout should read high.
     Usage:
 .) Set Vin low. Vout should read low.
 .) Wait for high on Vout.
 .) Begin clocking Vin and reading 8 bits from Vout (MSB first).
 .) Set Vin high for 2ms or more to turn off rangefinder
       Usage:
 .) Set Vin low. Vout should read low.
 .) Wait for high on Vout.
 .) Begin clocking Vin and reading 8 bits from Vout (MSB first).
 .) Set Vin high for 2ms or more to turn off rangefinder
     */
-...
     #include "rangefinder.h"
     /*
     read_distance returns the 8-bit reading from the rangefinder
     parameters:
     range_id - dio pin set as the rangefinder Vout [i.e. RANGE_IN0]
       read_distance returns the 8-bit reading from the rangefinder
       parameters:
       range_id - dio pin set as the rangefinder Vout [i.e. RANGE_IN0]

Project

General

Profile

Colony

Revision 437