/ - Diff - Colony - Robotics Club

     	/**
     	 * The size of the sensor matrix.
     	**/
     	unsigned int size;
     	int size;
     	/**
     	 * The matrix. Each row represents the readings of one
     	 * robot.
-...
     /**@brief Destroy a sensor matrix **/
     void sensor_matrix_destroy(SensorMatrix* m);
     /**@brief Add a robot to a sensor matrix **/
     void sensor_matrix_add_robot(SensorMatrix* m, unsigned int id);
     void sensor_matrix_add_robot(SensorMatrix* m, int id);
     /**@brief Remove a robot from a sensor matrix **/
     void sensor_matrix_remove_robot(SensorMatrix* m, unsigned int id);
     void sensor_matrix_remove_robot(SensorMatrix* m, int id);
     /**@brief Set a reading in a sensor matrix **/
     void sensor_matrix_set_reading(SensorMatrix* m, int observer, int robot, int reading);
     /**@brief Get a reading in a sensor matrix **/

     } PacketGroupHandler;
     /**@brief Initialize the wireless library **/
     void wl_init(void);
     int wl_init(void);
     /**@brief Uninitialize the wireless library **/
     void wl_terminate(void);
     /**@brief Perform wireless library functionality **/
-...
     /**@brief Get the channel we are using **/
     int wl_get_channel(void);
     /**@brief Get the 16-bit address of the XBee module **/
     unsigned int wl_get_xbee_id(void);
     int wl_get_xbee_id(void);
     /**@brief Set the com port on a computer, undefined on the robot.**/
     void wl_set_com_port(char* port);

     // timing constants
     #ifndef FIREFLY
     #define BOM_DELAY 50
     #define BOM_DELAY 100
     #else
     #define BOM_DELAY 100
     #define BOM_DELAY 200
     #endif
     #define DEATH_DELAY 4

      * Also, a backup port if the other is used.
      **/
     #ifndef ROBOT
     #ifndef XBEE_PORT
     #define XBEE_PORT "/dev/ttyUSB0"
     #define XBEE_PORT_DEFAULT "/dev/ttyUSB1"
     #endif
     #define XBEE_PORT2 "/dev/ttyUSB0"
     #endif
     /**
      * @defgroup xbee XBee
-...
     #define XBEE_RX 0x81
     /**@brief Initialize the XBee library **/
     void xbee_lib_init(void);
     int xbee_lib_init(void);
     /**@brief Uninitialize the XBee library **/
     void xbee_terminate(void);
     /**@brief Get a packet from the XBee **/

     #ifndef WIRELESS_QUEUE_H
     #define WIRELESS_QUEUE_H
     #ifndef ROBOT
     #include <pthread.h>
     #endif
     struct node_def;
     /**
-...
     	 * The number of elements in the queue.
     	 **/
     	int size;
     #ifndef ROBOT
     	pthread_mutex_t lock;
     #endif
     } Queue;
     /** @brief Create a new queue **/
-...
     /** @brief Destroy a queue **/
     void queue_destroy(Queue* q);
     /** @brief Add an element to a queue **/
     void queue_add(Queue* q, void* item);
     int queue_add(Queue* q, void* item);
     /** @brief Remove an element from a queue **/
     void* queue_remove(Queue* q);
     /** @brief Remove all instances of a given element from a queue **/
-...
     #endif

trunk/code/lib/include/libdragonfly/move.h
72	72	/ @} /
73	73
74	74	#endif
75

     #include <unistd.h>
     #include <pthread.h>
     #include <errno.h>
     #include <termios.h>
     #else
-...
     #include <stdlib.h>
     #include <string.h>
     #include <queue.h>
     #define XBEE_FRAME_START 0x7E
     /*Frame Types*/
-...
     void xbee_enter_command_mode(void);
     void xbee_exit_command_mode(void);
     void xbee_enter_api_mode(void);
     void xbee_exit_api_mode(void);
     void xbee_wait_for_string(char* s, int len);
     void xbee_wait_for_ok(void);
-...
     /*Global Variables*/
     #ifndef ROBOT
     char* xbee_com_port;
     char* xbee_com_port = XBEE_PORT_DEFAULT;
     int xbee_stream;
     pthread_t* xbee_listen_thread;
     #endif
     Queue* xbee_queue;
     // TODO: is this a good size?
     #define XBEE_BUFFER_SIZE	256
     // a buffer for data received from the XBee
     char arrival_buf[XBEE_BUFFER_SIZE];
     // location of last unread byte in buffer
     volatile int buffer_last = 0;
     // first unread byte in buffer
     volatile int buffer_first = 0;
     //used to store packets as they are read
     char xbee_buf[128];
     int currentBufPos = 0;
-...
     /**
      * Interrupt for the robot. Adds bytes received from the xbee
      * to the queue.
      * to the buffer.
      **/
     #ifndef FIREFLY
     ISR(USART1_RX_vect)
+    {
     	char c = UDR1;
     	queue_add(xbee_queue, (void*)(int)c);
     	arrival_buf[buffer_last] = c;
     	int t = buffer_last + 1;
     	if (t == XBEE_BUFFER_SIZE)
     		t = 0;
     	if (t == buffer_first)
+    	{
     		WL_DEBUG_PRINT("Out of space in buffer.\n");
+    	}
     	buffer_last = t;
+    }
     #else
     SIGNAL(SIG_USART0_RECV)
+    {
     	char c = UDR0;
     	queue_add(xbee_queue, (void*)(int)c);
     	arrival_buf[buffer_last] = c;
     	int t = buffer_last + 1;
     	if (t == XBEE_BUFFER_SIZE)
     		t = 0;
     	if (t == buffer_first)
+    	{
     		WL_DEBUG_PRINT("Out of space in buffer.\n");
+    	}
     	buffer_last = t;
+    }
     #endif
-...
     	while (1)
+    	{
     		xbee_read(&c, 1);
     		queue_add(xbee_queue, (void*)(int)c);
     		arrival_buf[buffer_last] = c;
     		int t = buffer_last + 1;
     		if (t == XBEE_BUFFER_SIZE)
     			t = 0;
     		if (t == buffer_first)
+    		{
     			WL_DEBUG_PRINT("Out of space in buffer.\n");
+    		}
     		buffer_last = t;
+    	}
     	return 0;
+    }
-...
     /**
      * Initializes the XBee library so that other functions may be used.
      **/
     void xbee_lib_init(void)
     int xbee_lib_init(void)
+    {
     	xbee_queue = queue_create();
     	arrival_buf[0] = 'A';
     	arrival_buf[1] = 'A';
     	arrival_buf[2] = 'A';
     	#ifdef ROBOT
     	//enable the receiving interrupt
-...
     	#endif
     	sei();
     	#else
     	printf("Connecting to port %s.\n", xbee_com_port);
     	xbee_stream = open(xbee_com_port, O_RDWR);
     	if (xbee_stream == -1 || lockf(xbee_stream, F_TEST, 0) != 0)
     		xbee_stream = open(XBEE_PORT2, O_RDWR);
     	if (xbee_stream == -1 || lockf(xbee_stream, F_TEST, 0) != 0)
     	if (xbee_stream == -1/* || lockf(xbee_stream, F_TEST, 0) != 0*/)
+    	{
     		printf("Failed to open connection to XBee on port %s\r\n",xbee_com_port);
     		exit(0);
     		printf("Failed to open connection to XBee on port %s\r\n", xbee_com_port);
     		return -1;
+    	}
     	lockf(xbee_stream, F_LOCK, 0);
     	// set baud rate, etc. correctly
     	struct termios options;
     	tcgetattr(xbee_stream, &options);
     	cfsetispeed(&options, B9600);
     	cfsetospeed(&options, B9600);
     	options.c_iflag &= ~ICRNL;
     	options.c_oflag &= ~OCRNL;
     	options.c_cflag |= (CLOCAL | CREAD);
     	options.c_cflag &= ~PARENB;
     	options.c_cflag &= ~CSTOPB;
     	options.c_cflag &= ~CSIZE;
     	options.c_cflag |= CS8;
     	options.c_lflag &= ~ICANON;
     	options.c_cc[VMIN] = 1;
     	options.c_cc[VTIME] = 50;
     	if (tcsetattr(xbee_stream, TCSANOW, &options))
+    	{
     		fprintf(stderr, "Error setting attributes.\n");
     		return -1;
+    	}
     	//lockf(xbee_stream, F_LOCK, 0);
     	xbee_listen_thread =
     		(pthread_t*)malloc(sizeof(pthread_t));
     	if (xbee_listen_thread == NULL)
+    	{
     		fprintf(stderr, "%s: Malloc failed.\n", __FUNCTION__);
     		return -1;
+    	}
     	int ret = pthread_create(xbee_listen_thread, NULL,
     	int ret = pthread_create(xbee_listen_thread, NULL,
     		listen_to_xbee, NULL);
     	if (ret)
+    	{
     		printf("Failed to create listener thread.\r\n");
     		exit(0);
     		fprintf(stderr, "Failed to create listener thread.\r\n");
     		return -1;
+    	}
     	#endif
     	xbee_enter_command_mode();
     	xbee_enter_api_mode();
-...
     	//wait to return until the address is set
     	while (xbee_address == 0) xbee_get_packet(NULL);
     	return 0;
+    }
     /**
-...
     	lockf(xbee_stream, F_ULOCK, 0);
     	close(xbee_stream);
     	#endif
     	queue_destroy(xbee_queue);
+    }
     /**
-...
+    }
     /**
      * Exit API mode. (warning - does not check for response)
      **/
     void xbee_exit_api_mode()
+    {
     	xbee_send_string("ATAP 0\r");
+    }
     /**
      * Wait until the string "OK\r" is received from the XBee.
      **/
     void xbee_wait_for_ok()
-...
     	char* curr = s;
     	while (curr - s < len)
+    	{
     		if (queue_is_empty(xbee_queue))
     		// check if buffer is empty
     		if (buffer_last == buffer_first)
     			continue;
     		char c = (char)(int)queue_remove(xbee_queue);
     		char c = arrival_buf[buffer_first++];
     		if (buffer_first == XBEE_BUFFER_SIZE)
     			buffer_first = 0;
     		if (c == *curr)
     			curr++;
     		else
-...
     	if (currentBufPos == 0)
+    	{
     		do
     			if (queue_is_empty(xbee_queue))
+    		{
     			if (buffer_first == XBEE_BUFFER_SIZE)
     				buffer_first = 0;
     			// check if buffer is empty
     			if (buffer_first == buffer_last)
     				return -1;
     		while ((char)(int)queue_remove(xbee_queue) != XBEE_FRAME_START);
+    		}
     		while (arrival_buf[buffer_first++] != XBEE_FRAME_START);
     		if (buffer_first == XBEE_BUFFER_SIZE)
     			buffer_first = 0;
     		xbee_buf[0] = XBEE_FRAME_START;
     		currentBufPos++;
+    	}
-...
     				return -1;
+    			}
+    		}
     		if (queue_is_empty(xbee_queue))
     		// check if buffer is empty
     		if (buffer_first == buffer_last)
     			return -1;
     		xbee_buf[currentBufPos++] = (char)(int)queue_remove(xbee_queue);
     		xbee_buf[currentBufPos++] = arrival_buf[buffer_first++];
     		if (buffer_first == XBEE_BUFFER_SIZE)
     			buffer_first = 0;
+    	}
     	currentBufPos = 0;
-...
+    }
     #ifndef ROBOT
     void xbee_set_com_port(char* port){
       //printf("Port being passed is %s\n",port);
       xbee_com_port = (char *) malloc(strlen(port));
       strcpy(xbee_com_port,port);
     void xbee_set_com_port(char* port)
+    {
     	xbee_com_port = port;
+    }
     #endif

     #include <stdlib.h>
     #include <stdio.h>
     #ifndef ROBOT
     #include <pthread.h>
     #endif
     /**
      * @struct node_def
-...
     	q->head = NULL;
     	q->size = 0;
     	#ifndef ROBOT
     	pthread_mutex_init(&(q->lock), NULL);
     	#endif
     	return q;
+    }
-...
     		free(t);
     		t = t2;
+    	}
     	#ifndef ROBOT
     	pthread_mutex_destroy(&(q->lock));
     	#endif
     	free(q);
+    }
-...
      * @param q the queue to add an element to
      * @param item the item to add to the queue
      **/
     void queue_add(Queue* q, void* item)
     int queue_add(Queue* q, void* item)
+    {
     	#ifndef ROBOT
     	pthread_mutex_lock(&(q->lock));
     	#endif
     	Node* n = (Node*)malloc(sizeof(Node));
     	if (n == NULL)
+    	{
     		#ifndef ROBOT
     		pthread_mutex_unlock(&(q->lock));
     		#endif
     		return -1;
+    	}
     	n->val = item;
     	n->next = NULL;
-...
+    	}
     	else
+    	{
     		q->tail->next = n;
     		q->tail = n;
+    	}
     	q->size++;
     	#ifndef ROBOT
     	pthread_mutex_unlock(&(q->lock));
     	#endif
     	return 0;
+    }
     /**
-...
      **/
     void* queue_remove(Queue* q)
+    {
     	#ifndef ROBOT
     	pthread_mutex_lock(&(q->lock));
     	#endif
     	Node* first = q->head;
     	if (first == NULL)
+    	{
     		WL_DEBUG_PRINT("Attempting to remove item \
     			from empty queue.\r\n");
     		WL_DEBUG_PRINT_INT(queue_size(q));
     		#ifndef ROBOT
     		pthread_mutex_unlock(&(q->lock));
     		#endif
     		return NULL;
+    	}
     	void* ret = first->val;
     	q->head = first->next;
-...
     		q->tail = NULL;
     	free(first);
     	q->size--;
     	#ifndef ROBOT
     	pthread_mutex_unlock(&(q->lock));
     	#endif
     	return ret;
+    }
-...
      **/
     void queue_remove_all(Queue* q, void* item)
+    {
     	#ifndef ROBOT
     	pthread_mutex_lock(&(q->lock));
     	#endif
     	Node* curr = q->head;
     	Node* prev = NULL;
-...
     			prev = curr;
     		curr = next;
+    	}
     	#ifndef ROBOT
     	pthread_mutex_unlock(&(q->lock));
     	#endif
+    }
     /**
-...
      **/
     int queue_size(Queue* q)
+    {
     	return q->size;
     	int size;
     	#ifndef ROBOT
     	pthread_mutex_lock(&(q->lock));
     	#endif
     	size = q->size;
     	#ifndef ROBOT
     	pthread_mutex_unlock(&(q->lock));
     	#endif
     	return size;
+    }
     /**
-...
      **/
     int queue_is_empty(Queue* q)
+    {
     	return q->size == 0;
     	int result;
     	#ifndef ROBOT
     	pthread_mutex_lock(&(q->lock));
     	#endif
     	result = q->size == 0;
     	#ifndef ROBOT
     	pthread_mutex_unlock(&(q->lock));
     	#endif
     	return result;
+    }

      * @param m the sensor matrix
      * @param id the XBee ID of the robot to add
      **/
     void sensor_matrix_add_robot(SensorMatrix* m, unsigned int id)
     void sensor_matrix_add_robot(SensorMatrix* m, int id)
+    {
     	int i;
     	if (id >= m->size)
-...
      * @param m the sensor matrix
      * @param id the XBee ID of the robot to remove
      **/
     void sensor_matrix_remove_robot(SensorMatrix* m, unsigned int id)
     void sensor_matrix_remove_robot(SensorMatrix* m, int id)
+    {
     	int i;

     /**
      * Copyright (c) 2007 Colony Project
+     *
+     *
      * Permission is hereby granted, free of charge, to any person
      * obtaining a copy of this software and associated documentation
      * files (the "Software"), to deal in the Software without
-...
      * copies of the Software, and to permit persons to whom the
      * Software is furnished to do so, subject to the following
      * conditions:
+     *
+     *
      * The above copyright notice and this permission notice shall be
      * included in all copies or substantial portions of the Software.
+     *
+     *
      * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
      * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
      * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-...
      * Initializes the wireless library. Must be called before any
      * other function.
      **/
     void wl_init()
     int wl_init()
+    {
     	int i;
     	for (i = 0; i < WL_MAX_PACKET_GROUPS; i++)
     		wl_packet_groups[i] = NULL;
     	xbee_lib_init();
     	if (xbee_lib_init() == -1) {
     	  return -1;
+    	}
     	//begin timeout timer
     	#ifdef ROBOT
     	#ifdef FIREFLY
     	rtc_init(PRESCALE_DIV_256, 32, &timer_handler);
     	#else
     	rtc_init(HALF_SECOND, &timer_handler);
     	rtc_init(HALF_SECOND, &timer_handler);
     	#endif
     	#else
     	//create our timer
     	struct itimerval timer_val;
     	struct timeval interval;
-...
     	timer_val.it_value = first_time;
     	if(setitimer(ITIMER_REAL,&timer_val,NULL)==-1)
+    	{
     		WL_DEBUG_PRINT("Error creating a timer.\r\n");
     		WL_DEBUG_PRINT("Error creating a timer.\r\n");
     		perror("Failure's cause");
     		exit(1);
     		exit(1);
+    	}
     	//create signal handler
-...
     	sigaction(SIGALRM, &wl_sig_act, 0);
     	sigaction(SIGINT, &wl_sig_act, 0);
     	#endif
     	return 0;
+    }
     /**
-...
     		if (wl_packet_groups[i] != NULL &&
     			wl_packet_groups[i]->unregister != NULL)
     			wl_packet_groups[i]->unregister();
     	xbee_terminate();
+    }
-...
+     *
      * @return the 16-bit address of the XBee module.
      **/
     unsigned int wl_get_xbee_id()
     int wl_get_xbee_id()
+    {
     	return xbee_get_address();
+    }
-...
     void wl_send_pan_packet(char group, char type,
     		char* data, int len, char frame)
+    {
     	wl_send_packet(group, type, data, len, XBEE_BROADCAST,
     	wl_send_packet(group, type, data, len, XBEE_BROADCAST,
     			XBEE_OPTIONS_NONE, frame);
+    }
-...
     /**
      * Unregister a packet group from the wireless library.
+     *
+     *
      * @param h the packet group to remove
      **/
     void wl_unregister_packet_group(PacketGroupHandler* h)
-...
     		wl_do_timeout();
     		wl_timeout = 0;
+    	}
     	int len = xbee_get_packet(wl_buf);
     	if (len < 0)//no packet received
     		return;
     	if (wl_buf[0] == XBEE_TX_STATUS)
+    	{
     		if (len != 3)
-...
     			WL_DEBUG_PRINT("Transmit Status packet should be of length 3.\r\n");
     			return;
+    		}
     		//the first four bits are the packet group
     		//this only works with under 16 groups
     		int group = (int)(wl_buf[1] >> 4);
-...
     				WL_DEBUG_PRINT("Purged\r\n");
+    			}
+    		}
     		if (wl_packet_groups[group] != NULL &&
     					wl_packet_groups[group]->handle_response != NULL)
     			wl_packet_groups[group]->handle_response(
     					(int)wl_buf[1] & 0x0F, success);
     		return;
+    	}
     	if (wl_buf[0] == XBEE_RX)
+    	{
     		if (len < 7)
-...
     			WL_DEBUG_PRINT("Packet is too small.\r\n");
     			return;
+    		}
     		int source = ((int)wl_buf[1] << 8) + ((int)wl_buf[2]);
     		/*
     		//unused for now
     		int signalStrength = wl_buf[3];
     		//1 for Address broadcast, 2 for PAN broadcast
     		int options = wl_buf[4];
     		*/
     		int group = wl_buf[5];
     		int type = wl_buf[6];
     		int packetLen = len - 7;
     		if (wl_packet_groups[group] != NULL
     				&& wl_packet_groups[group]->handle_receive != NULL)
     			wl_packet_groups[group]->handle_receive(type, source,
     			wl_packet_groups[group]->handle_receive(type, source,
     				wl_buf + 7, packetLen);
     		return;
+    	}
     	WL_DEBUG_PRINT("Unexpected packet received from XBee.\r\n");
     	return;
+    }
     #ifndef ROBOT
     void wl_set_com_port(char* port){
       xbee_set_com_port(port);
     void wl_set_com_port(char* port)
+    {
     	xbee_set_com_port(port);
+    }
     #endif

     /**
      * Copyright (c) 2007 Colony Project
+     *
      * Permission is hereby granted, free of charge, to any person
      * obtaining a copy of this software and associated documentation
      * files (the "Software"), to deal in the Software without
      * restriction, including without limitation the rights to use,
      * copy, modify, merge, publish, distribute, sublicense, and/or sell
      * copies of the Software, and to permit persons to whom the
      * Software is furnished to do so, subject to the following
      * conditions:
+     *
      * The above copyright notice and this permission notice shall be
      * included in all copies or substantial portions of the Software.
+     *
      * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
      * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
      * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
      * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
      * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
      * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
      * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
      * OTHER DEALINGS IN THE SOFTWARE.
      **/
     /**
      * @file time.c
      * @brief Timer code
+     *
      * Implementation of functions for timers.
+     *
      * @author Colony Project, CMU Robotics Club
      **/
     /*
     time.c
     anything that requires a delay
     mostly delay_ms
     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.
     */
     #include <avr/interrupt.h>
     #include <util/delay.h>
     #include <time.h>
     #include <serial.h>
     static volatile int _rtc_val = 0;
     static volatile int _rtc_pulse = 0;
     static volatile int _rtc_scale = 32;	//Defaults to 1 Second per pulse
     static void (*_rtc_f)(void) = 0;
     /**
      * @defgroup time Time
      * @brief Time functions
+     *
      * Functions dealing with time.
+     *
      * @{
      **/
     /**
      * Delays for the specified number of milliseconds.
      * The accuracy of this function is unknown.
+     *
      * @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);
+    }
     /* 	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. */
     /**
      * Initializes the real time clock. Prescales are defined in time.h.
      * For example, SECOND will give 1 second. The specified function is
      * called every clock tick. For the real time clock to activate,
      * interrupts must be enabled. (through sei() )
+     *
      * @param prescale_opt the period with which the timer is triggered
      * @param rtc_func the function called when the timer is triggered
+     *
      * @see rtc_get, rtc_reset
+     *
      **/
     void rtc_init(int prescale_opt, void (*rtc_func)(void)) {
     	//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 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*/
     	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);
     	/*	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;
+    }
     /**
      * Returns the time elapsed in seconds since the last call to
      * rtc_init or rtc_reset.
+     *
      * @return the number of seconds since the last call to rtc_init or rtc_reset
+     *
      * @see rtc_init, rtc_reset
      **/
     int rtc_get(void){
     	return _rtc_val;
+    }
     /**
      * Resets the real time clock counter to 0.
+     *
      * @see rtc_init, rtc_get
      **/
     void rtc_reset(void){
     	_rtc_val = 0;
+    }
     /** @} **/ //end defgroup
     /*	Called every pulse. Function in _rtc_f is called every _rtc_scale and also the counter is updated.
     	Bascially, since the pulse is hard set at 1/16s  you want to count how many 16ths of a second have passed
     	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++;
     		//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;
+    	}
     	//Updates the amount of pulses seen since the last scale match
     	_rtc_pulse++;
+    }
     /**
      * Copyright (c) 2007 Colony Project
+     *
      * Permission is hereby granted, free of charge, to any person
      * obtaining a copy of this software and associated documentation
      * files (the "Software"), to deal in the Software without
      * restriction, including without limitation the rights to use,
      * copy, modify, merge, publish, distribute, sublicense, and/or sell
      * copies of the Software, and to permit persons to whom the
      * Software is furnished to do so, subject to the following
      * conditions:
+     *
      * The above copyright notice and this permission notice shall be
      * included in all copies or substantial portions of the Software.
+     *
      * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
      * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
      * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
      * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
      * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
      * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
      * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
      * OTHER DEALINGS IN THE SOFTWARE.
      **/
     /**
      * @file time.c
      * @brief Timer code
+     *
      * Implementation of functions for timers.
+     *
      * @author Colony Project, CMU Robotics Club
      **/
     /*
     time.c
     anything that requires a delay
     mostly delay_ms
     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.
     */
     #include <avr/interrupt.h>
     #include <util/delay.h>
     #include <time.h>
     #include <serial.h>
     static volatile int _rtc_val = 0;
     static volatile int _rtc_pulse = 0;
     static volatile int _rtc_scale = 32;	//Defaults to 1 Second per pulse
     static void (*_rtc_f)(void) = 0;
     /**
      * @defgroup time Time
      * @brief Time functions
+     *
      * Functions dealing with time.
+     *
      * @{
      **/
     /**
      * Delays for the specified number of milliseconds.
      * The accuracy of this function is unknown.
+     *
      * @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);
+    }
     /* 	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. */
     /**
      * Initializes the real time clock. Prescales are defined in time.h.
      * For example, SECOND will give 1 second. The specified function is
      * called every clock tick. For the real time clock to activate,
      * interrupts must be enabled. (through sei() )
+     *
      * @param prescale_opt the period with which the timer is triggered
      * @param rtc_func the function called when the timer is triggered
+     *
      * @see rtc_get, rtc_reset
+     *
      **/
     void rtc_init(int prescale_opt, void (*rtc_func)(void)) {
     	//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 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*/
     	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);
     	/*	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;
+    }
     /**
      * Returns the time elapsed in seconds since the last call to
      * rtc_init or rtc_reset.
+     *
      * @return the number of seconds since the last call to rtc_init or rtc_reset
+     *
      * @see rtc_init, rtc_reset
      **/
     int rtc_get(void){
     	return _rtc_val;
+    }
     /**
      * Resets the real time clock counter to 0.
+     *
      * @see rtc_init, rtc_get
      **/
     void rtc_reset(void){
     	_rtc_val = 0;
+    }
     /** @} **/ //end defgroup
     /*	Called every pulse. Function in _rtc_f is called every _rtc_scale and also the counter is updated.
     	Bascially, since the pulse is hard set at 1/16s  you want to count how many 16ths of a second have passed
     	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++;
     		//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;
+    	}
     	//Updates the amount of pulses seen since the last scale match
     	_rtc_pulse++;
+    }

     /**
      * Copyright (c) 2007 Colony Project
+     *
      * Permission is hereby granted, free of charge, to any person
      * obtaining a copy of this software and associated documentation
      * files (the "Software"), to deal in the Software without
      * restriction, including without limitation the rights to use,
      * copy, modify, merge, publish, distribute, sublicense, and/or sell
      * copies of the Software, and to permit persons to whom the
      * Software is furnished to do so, subject to the following
      * conditions:
+     *
      * The above copyright notice and this permission notice shall be
      * included in all copies or substantial portions of the Software.
+     *
      * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
      * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
      * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
      * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
      * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
      * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
      * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
      * OTHER DEALINGS IN THE SOFTWARE.
      **/
     /**
      * @file motor.c
      * @brief Motors
+     *
      * Implementation of functions for controlling the motors.
+     *
      * @author Colony Project, CMU Robotics Club
      * Much of this is taken from FWR's library, author: Tom Lauwers
      **/
     #include "motor.h"
     /**
      * @defgroup motors Motors
      * @brief Functions for controlling the motors.
      * Functions for controlling the motors. Found in motor.h.
      * @{
      **/
     /**
      * Initializes both motors so that they can be used with future
      * calls to motor1_set and motor2_set.
+     *
      * @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;
     	//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;
+    }
     /**
      * Sets the speed and direction of motor1.
      * motors_init must be called before this function can be used.
+     *
      * @param direction Either FORWARD or BACKWARD to set the direction of rotation.
      * @param speed The speed the motor will run at, in the range 0-255.
+     *
      * @see motor2_set, motors_init
      **/
     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;
+    	}
     	// Set the timer to count up to speed, an 8-bit value
     	OCR1AL = speed;
+    }
     /**
      * Sets the speed and direction of motor2.
      * motors_init must be called before this function can be used.
+     *
      * @param direction Either FORWARD or BACKWARD to set the direction of rotation.
      * @param speed The speed the motor will run at, in the range 0-255.
+     *
      * @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;
+    		}
     		PORTA = (PORTA & 0x3F) | 0x80;
+    	}
     	else {
     //		PORTD |= 0x80;
     //		PORTD &= 0xDF;
     	    // turn off PWM first if switching directions
     		if((PORTA & 0xC0) != 0x40)
+    		{
     		  OCR1B = 0;
+    		}
     		PORTA = (PORTA & 0x3F) | 0x40;
+    	}
     	OCR1BL = speed;
+    }
     /**
      * Turns off both motors.
+     *
      * @see motors_init
      **/
     void motors_off( void ) {
     	OCR1AL = 0x0;
     	OCR1BL = 0x0;
+    }
     /**@}**///end defgroup
     /**
      * Copyright (c) 2007 Colony Project
+     *
      * Permission is hereby granted, free of charge, to any person
      * obtaining a copy of this software and associated documentation
      * files (the "Software"), to deal in the Software without
      * restriction, including without limitation the rights to use,
      * copy, modify, merge, publish, distribute, sublicense, and/or sell
      * copies of the Software, and to permit persons to whom the
      * Software is furnished to do so, subject to the following
      * conditions:
+     *
      * The above copyright notice and this permission notice shall be
      * included in all copies or substantial portions of the Software.
+     *
      * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
      * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
      * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
      * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
      * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
      * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
      * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
      * OTHER DEALINGS IN THE SOFTWARE.
      **/
     /**
      * @file motor.c
      * @brief Motors
+     *
      * Implementation of functions for controlling the motors.
+     *
      * @author Colony Project, CMU Robotics Club
      * Much of this is taken from FWR's library, author: Tom Lauwers
      **/
     #include "motor.h"
     /**
      * @defgroup motors Motors
      * @brief Functions for controlling the motors.
      * Functions for controlling the motors. Found in motor.h.
      * @{
      **/
     /**
      * Initializes both motors so that they can be used with future
      * calls to motor1_set and motor2_set.
+     *
      * @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;
     	//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;
+    }
     /**
      * Sets the speed and direction of motor1.
      * motors_init must be called before this function can be used.
+     *
      * @param direction Either FORWARD or BACKWARD to set the direction of rotation.
      * @param speed The speed the motor will run at, in the range 0-255.
+     *
      * @see motor2_set, motors_init
      **/
     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;
+    	}
     	// Set the timer to count up to speed, an 8-bit value
     	OCR1AL = speed;
+    }
     /**
      * Sets the speed and direction of motor2.
      * motors_init must be called before this function can be used.
+     *
      * @param direction Either FORWARD or BACKWARD to set the direction of rotation.
      * @param speed The speed the motor will run at, in the range 0-255.
+     *
      * @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;
+    		}
     		PORTA = (PORTA & 0x3F) | 0x80;
+    	}
     	else {
     //		PORTD |= 0x80;
     //		PORTD &= 0xDF;
     	    // turn off PWM first if switching directions
     		if((PORTA & 0xC0) != 0x40)
+    		{
     		  OCR1B = 0;
+    		}
     		PORTA = (PORTA & 0x3F) | 0x40;
+    	}
     	OCR1BL = speed;
+    }
     /**
      * Turns off both motors.
+     *
      * @see motors_init
      **/
     void motors_off( void ) {
     	OCR1AL = 0x0;

Project

General

Profile

Colony

Revision 336