/ - Diff - Colony - Robotics Club

     #include "queue.h"
     #include <wl_defs.h>
     #include <stdlib.h>
     #include <stdio.h>
     /**
      * @struct node_def
      * A node in the queue.
      **/
     typedef struct node_def
+    {
     	/** The item at this point in the queue. **/
     	void* val;
     	/** The next node in the queue. **/
     	struct node_def* next;
     } Node;
     /**
      * Create a queue.
+     *
      * @return the newly created queue.
      **/
     Queue* queue_create()
+    {
     	Queue* q = (Queue*)malloc(sizeof(Queue));
     	q->head = NULL;
     	q->size = 0;
     	return q;
+    }
     /**
      * Destroys a queue, freeing memory.
+     *
      * @param q the queue to destroy
      **/
     void queue_destroy(Queue* q)
+    {
     	Node* t = q->head;
     	while (t != NULL)
+    	{
     		Node* t2 = t->next;
     		free(t);
     		t = t2;
+    	}
     	free(q);
+    }
     /**
      * Add an element to a queue.
+     *
      * @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)
+    {
     	Node* n = (Node*)malloc(sizeof(Node));
     	n->val = item;
     	n->next = NULL;
     	if (q->head == NULL)
+    	{
     		q->head = n;
     		q->tail = n;
+    	}
     	else
+    	{
     		q->tail->next = n;
     		q->tail = n;
+    	}
     	q->size++;
+    }
     /**
      * Remove an element from the front of a queue.
+     *
      * @param q the queue to remove the element from
+     *
      * @return the element which was removed
      **/
     void* queue_remove(Queue* q)
+    {
     	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));
+    	}
     	void* ret = first->val;
     	q->head = first->next;
     	if (q->tail == first)
     		q->tail = NULL;
     	free(first);
     	q->size--;
     	return ret;
+    }
     /**
      * Remove all instances of a given element from a queue.
+     *
      * @param q the queue to remove the elements from
      * @param item the element to remove all instances of
      **/
     void queue_remove_all(Queue* q, void* item)
+    {
     	Node* curr = q->head;
     	Node* prev = NULL;
     	while (curr != NULL)
+    	{
     		Node* next = curr->next;
     		if (curr->val == item)
+    		{
     			if (q->head == curr)
     				q->head = next;
     			if (q->tail == curr)
     				q->tail = prev;
     			if (prev != NULL)
     				prev->next = next;
     			free(curr);
     			q->size--;
+    		}
     		else
     			prev = curr;
     		curr = next;
+    	}
+    }
     /**
      * Get the number of elements in the queue.
+     *
      * @param q the queue to get the size of
      * @return the size of the queue
      **/
     int queue_size(Queue* q)
+    {
     	return q->size;
+    }
     /**
      * Check if the queue is empty.
+     *
      * @param q the queue to check
      * @return nonzero if the queue is empty, 0 otherwise
      **/
     int queue_is_empty(Queue* q)
+    {
     	return q->size == 0;
+    }

     /**
      * @file queue.h
      * @brief A queue implementation
+     *
      * Implements a queue, a first in, first out data structure.
+     *
      * @author Brian Coltin, Colony Project
      **/
     struct node_def;
     /**
      * @defgroup queue Queue
      * @brief A queue implementation
+     *
      * A queue implementation.
+     *
      * @{
      **/
     /**
      * @struct Queue
      * Represents a queue, a first in, first out data structure.
      **/
     typedef struct
+    {
     	/**
     	 * The head of the queue, the next item to be removed.
     	 **/
     	struct node_def* head;
     	/**
     	 * The tail of the queue, the last item added.
     	 **/
     	struct node_def* tail;
     	/**
     	 * The number of elements in the queue.
     	 **/
     	int size;
     } Queue;
     /** @brief Create a new queue **/
     Queue* queue_create(void);
     /** @brief Destroy a queue **/
     void queue_destroy(Queue* q);
     /** @brief Add an element to a queue **/
     void 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 **/
     void queue_remove_all(Queue* q, void* item);
     /** @brief Get the size of a queue **/
     int queue_size(Queue* q);
     /** @brief Check if the queue is empty **/
     int queue_is_empty(Queue* q);
     /** @} **/

     			j++;
+    		}
+    	}
     	int packetSize = 2 * j * sizeof(char);
     	WL_DEBUG_PRINT("Passing the token to robot ");
     	WL_DEBUG_PRINT_INT(nextRobot);
-...
     	WL_DEBUG_PRINT("Our BOM has been flashed.\r\n");
     	wl_send_global_packet(WL_TOKEN_RING_GROUP, WL_TOKEN_BOM_ON, NULL, 0, 0);
     	//bom_on_function();
     	bom_on_function();
     	#ifdef ROBOT
     	delay_ms(BOM_DELAY);
     	#endif

     	 * is in the token ring and false otherwise.
     	 **/
     	unsigned char joined[MAXIMUM_XBEE_ID];
     	// on the bayboard, we don't include the matrix to save memory.
     #ifndef BAYBOARD
     	/**
     	 * The matrix. Each row represents the readings of one
     	 * robot.
     	 **/
     	unsigned char matrix[MAXIMUM_XBEE_ID][MAXIMUM_XBEE_ID];
     #endif
     } SensorMatrix;
     /**@brief Create a sensor matrix **/

branches/autonomous_recharging/code/projects/libwireless/lib/sensor_matrix.c
55	55	for (i = 0; i < MAXIMUM_XBEE_ID; i++)
56	56	{
57	57	m.joined[i] = 0;
	58	#ifndef BAYBOARD
	59	for (j = 0; j < MAXIMUM_XBEE_ID; j++)
	60	m.matrix[i][j] = READING_UNKNOWN;
	61	#endif
58	62	}
59	63	}
60	64
...	...
67	71	*/
68	72	void sensor_matrix_set_reading(int observer, int robot, int reading)
69	73	{
	74	#ifndef BAYBOARD
	75	if (robot >= MAXIMUM_XBEE_ID \|\| observer >= MAXIMUM_XBEE_ID)
	76	{
	77	WL_DEBUG_PRINT("ID too large.");
	78	return;
	79	}
70	80
	81	m.matrix[observer][robot] = (unsigned char)reading;
	82	#endif
71	83	}
72	84
73	85	/**
...	...
80	92	**/
81	93	int sensor_matrix_get_reading(int observer, int robot)
82	94	{
	95	#ifndef BAYBOARD
	96	if (observer >= MAXIMUM_XBEE_ID \|\| robot >= MAXIMUM_XBEE_ID)
	97	return -1;
	98
	99	return (int)m.matrix[observer][robot];
	100	#else
83	101	return -1;
	102	#endif
84	103	}
85	104
86	105	/**
...	...
93	112	{
94	113	if (robot >= MAXIMUM_XBEE_ID)
95	114	{
96		usb_puts("ID too large.\n\r");
97	115	WL_DEBUG_PRINT("ID too large.");
98	116	return;
99	117	}

     	rtc_init(PRESCALE_DIV_256, 32, &timer_handler);
     #else
     	//TODO: FIX THIS
     	#ifdef BAYBOARD
     	rtc_init(10 * HALF_SECOND, &timer_handler);
     	#else
     	rtc_init(HALF_SECOND, &timer_handler);
     	#endif
     #endif
     #else

Project

General

Profile

Colony

Revision 886