Project

General

Profile

Revision 1784

commit smart run around demo

View differences:

demos/smart_run_around_fsm/lib/src/libwireless/wl_token_ring.c
1
/**
2
 * Copyright (c) 2007 Colony Project
3
 *
4
 * Permission is hereby granted, free of charge, to any person
5
 * obtaining a copy of this software and associated documentation
6
 * files (the "Software"), to deal in the Software without
7
 * restriction, including without limitation the rights to use,
8
 * copy, modify, merge, publish, distribute, sublicense, and/or sell
9
 * copies of the Software, and to permit persons to whom the
10
 * Software is furnished to do so, subject to the following
11
 * conditions:
12
 *
13
 * The above copyright notice and this permission notice shall be
14
 * included in all copies or substantial portions of the Software.
15
 *
16
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
17
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
18
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
19
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
20
 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
21
 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
22
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
23
 * OTHER DEALINGS IN THE SOFTWARE.
24
 **/
25

  
26
/**
27
 * @file wl_token_ring.c
28
 * @brief Token Ring Implementation
29
 *
30
 * Implementation of the token ring packet group.
31
 *
32
 * @author Brian Coltin, Colony Project, CMU Robotics Club
33
 **/
34

  
35
#include <wl_token_ring.h>
36

  
37
#include <stdlib.h>
38

  
39
#include <wl_defs.h>
40
#include <wireless.h>
41
#include <sensor_matrix.h>
42

  
43
#ifdef ROBOT
44
#ifndef FIREFLY
45
#include <bom.h>
46
#endif
47
#include <time.h>
48
#endif
49

  
50

  
51
//#define DEFAULT_SENSOR_MATRIX_SIZE 20
52

  
53
/*Ring States*/
54

  
55
#define NONMEMBER 0
56
#define MEMBER 1
57
#define JOINING 2
58
#define ACCEPTED 3
59
#define LEAVING 4
60

  
61
/*Frame Types*/
62
#define TOKEN_JOIN_ACCEPT_FRAME	1
63
#define WL_TOKEN_PASS_FRAME	2
64

  
65
/*Function Prototypes*/
66

  
67
/*Wireless Library Prototypes*/
68
static void wl_token_ring_timeout_handler(void);
69
static void wl_token_ring_response_handler(int frame, int received);
70
static void wl_token_ring_receive_handler(char type, int source, unsigned char* packet, int length);
71
static void wl_token_ring_cleanup(void);
72

  
73
/*Helper Functions*/
74
static int wl_token_pass_token(void);
75
static int get_token_distance(int robot1, int robot2);
76
static void wl_token_get_token(void);
77

  
78
/*Packet Handling Routines*/
79
static void wl_token_pass_receive(int source);
80
static void wl_token_sensor_matrix_receive(int source, unsigned char* sensorData, int sensorDataLength);
81
static void wl_token_bom_on_receive(int source);
82
static void wl_token_join_receive(int source);
83
static void wl_token_join_accept_receive(int source);
84

  
85
/*Global Variables*/
86

  
87
//the robot we are waiting to say it has received the token. -1 if unspecified
88
static int wl_token_next_robot = -1;
89

  
90
//true if the robot should be in the token ring, 0 otherwise
91
static int ringState = NONMEMBER;
92
//the id of the robot who accepted us into the token ring, only used in ACCEPTED state
93
static int acceptor = -1;
94
//id of the robot we are accepting
95
static int accepted = -1;
96

  
97
//the counter for when we assume a robot is dead
98
static int deathDelay = -1;
99
//the counter for joining, before we form our own token ring
100
static int joinDelay = -1;
101

  
102
//current robot to check in the iterator
103
static int iteratorCount = 0;
104

  
105
// the amount of time a robot has had its BOM on for
106
static int bom_on_count = 0;
107

  
108
#ifndef ROBOT
109
static void do_nothing(void) {}
110
static int get_nothing(void) {return -1;}
111
#endif
112

  
113
#ifdef ROBOT
114
#ifndef FIREFLY
115
static void (*bom_on_function) (void) = bom_on;
116
static void (*bom_off_function) (void) = bom_off;
117
static int (*get_max_bom_function) (void) = get_max_bom;
118
#else
119
static void (*bom_on_function) (void) = do_nothing;
120
static void (*bom_off_function) (void) = do_nothing;
121
static int (*get_max_bom_function) (void) = get_nothing;
122
#endif
123
#else
124
static void (*bom_on_function) (void) = do_nothing;
125
static void (*bom_off_function) (void) = do_nothing;
126
static int (*get_max_bom_function) (void) = get_nothing;
127
#endif
128

  
129
static PacketGroupHandler wl_token_ring_handler =
130
	{WL_TOKEN_RING_GROUP, wl_token_ring_timeout_handler,
131
		wl_token_ring_response_handler, wl_token_ring_receive_handler,
132
		wl_token_ring_cleanup};
133

  
134
/**
135
 * Causes the robot to join an existing token ring, or create one
136
 * if no token ring exists. The token ring uses global and robot to robot
137
 * packets, and does not rely on any PAN.
138
 **/
139
int wl_token_ring_join()
140
{
141
	WL_DEBUG_PRINT("Joining the token ring.\r\n");
142

  
143
	ringState = JOINING;
144
	joinDelay = DEATH_DELAY * 2;
145
	if (wl_send_global_packet(WL_TOKEN_RING_GROUP, WL_TOKEN_JOIN, NULL, 0, 0) != 0) {
146
		return -1;
147
	}
148

  
149
	return 0;
150
}
151

  
152
/**
153
 * Causes the robot to leave the token ring. The robot stops
154
 * alerting others of its location, but continues storing the
155
 * locations of other robots.
156
 **/
157
void wl_token_ring_leave()
158
{
159
	ringState = LEAVING;
160
}
161

  
162
/**
163
 * Initialize the token ring packet group and register it with the
164
 * wireless library. The robot will not join a token ring.
165
 **/
166
int wl_token_ring_register()
167
{
168
	if (wl_get_xbee_id() > 0xFF)
169
	{
170
		//Note: if this becomes an issue (unlikely), we could limit sensor information
171
		//to half a byte and use 12 bits for the id
172
		WL_DEBUG_PRINT("XBee ID must be single byte for token ring, is ");
173
		WL_DEBUG_PRINT_INT(wl_get_xbee_id());
174
		WL_DEBUG_PRINT(".\r\n");
175
		return -1;
176
	}
177

  
178
	sensor_matrix_create();
179
	//add ourselves to the sensor matrix
180
	sensor_matrix_set_in_ring(wl_get_xbee_id(), 0);
181

  
182
	wl_register_packet_group(&wl_token_ring_handler);
183

  
184
	return 0;
185
}
186

  
187
/**
188
 * Removes the packet group from the wireless library.
189
 **/
190
void wl_token_ring_unregister()
191
{
192
	wl_unregister_packet_group(&wl_token_ring_handler);
193
}
194

  
195
/**
196
 * Sets the functions that are called when the BOM ought to be
197
 * turned on or off. This could be used for things such as
198
 * charging stations, which have multiple BOMs.
199
 *
200
 * @param on_function the function to be called when the BOM
201
 * should be turned on
202
 * @param off_function the function to be called when the BOM
203
 * should be turned off
204
 * @param max_bom_function the function to be called when a
205
 * measurement of the maximum BOM reading is needed.
206
 **/
207
void wl_token_ring_set_bom_functions(void (*on_function) (void),
208
	void (*off_function) (void), int (*max_bom_function) (void))
209
{
210
	bom_on_function = on_function;
211
	bom_off_function = off_function;
212
	get_max_bom_function = max_bom_function;
213
}
214

  
215
/**
216
 * Called to cleanup the token ring packet group.
217
 **/
218
static void wl_token_ring_cleanup()
219
{
220
}
221

  
222
/**
223
 * Called approximately every quarter second by the wireless library.
224
 **/
225
static void wl_token_ring_timeout_handler()
226
{
227
	//someone is not responding, assume they are dead
228
	if (deathDelay == 0)
229
	{
230
		//pass the token to the next robot if we think someone has died
231
		//also, declare that person dead, as long as it isn't us
232
		if (wl_token_next_robot != wl_get_xbee_id())
233
		{
234
			sensor_matrix_set_in_ring(wl_token_next_robot, 0);
235
			WL_DEBUG_PRINT("Robot ");
236
			WL_DEBUG_PRINT_INT(wl_token_next_robot);
237
			WL_DEBUG_PRINT(" has died.\r\n");
238
			wl_token_next_robot = -1;
239
			deathDelay = DEATH_DELAY;
240
		}
241

  
242
		// we may have been dropped from the ring when this is received
243
		if (ringState == MEMBER) {
244
			wl_token_pass_token();
245
		}
246
	}
247

  
248
	//we must start our own token ring, no one is responding to us
249
	if (joinDelay == 0)
250
	{
251
		if (sensor_matrix_get_joined() == 0)
252
		{
253
			WL_DEBUG_PRINT("Creating our own token ring, no robots seem to exist.\r\n");
254
			sensor_matrix_set_in_ring(wl_get_xbee_id(), 1);
255
			ringState = MEMBER;
256
			//this will make us pass the token to ourself
257
			//repeatedly, and other robots when they join
258
			deathDelay = DEATH_DELAY;
259
			wl_token_next_robot = wl_get_xbee_id();
260
		}
261
		else
262
		{
263
			WL_DEBUG_PRINT("Attempting to join the token ring again.\r\n");
264
			//attempt to rejoin with a random delay
265
      //TODO: should we use the constant JOIN_DELAY ?
266
			wl_token_ring_join();
267
			joinDelay = rand() / (RAND_MAX / JOIN_DELAY) + 1;
268
		}
269
	}
270

  
271
	if (deathDelay >= 0) {
272
		deathDelay--;
273
	}
274

  
275
	if (joinDelay >= 0) {
276
		joinDelay--;
277
	}
278

  
279
	if (bom_on_count >= 0) {
280
		bom_on_count++;
281
	}
282
}
283

  
284
/**
285
 * Called when the XBee tells us if a packet we sent has been received.
286
 *
287
 * @param frame the frame number assigned when the packet was sent
288
 * @param received 1 if the packet was received, 0 otherwise
289
 **/
290
static void wl_token_ring_response_handler(int frame, int received)
291
{
292
	if (!received)
293
	{
294
		WL_DEBUG_PRINT("FAILED.\r\n");
295
	}
296
}
297

  
298
/**
299
 * Called when we recieve a token ring packet.
300
 * @param type the type of the packet
301
 * @param source the id of the robot who sent the packet
302
 * @param packet the data in the packet
303
 * @param length the length of the packet in bytes
304
 **/
305
static void wl_token_ring_receive_handler(char type, int source, unsigned char* packet, int length)
306
{
307
	switch (type)
308
	{
309
		case WL_TOKEN_PASS:
310
			wl_token_pass_receive(source);
311
			break;
312
		case WL_TOKEN_SENSOR_MATRIX:
313
			wl_token_sensor_matrix_receive(source, packet, length);
314
			break;
315
		case WL_TOKEN_BOM_ON:
316
			//add the robot to the sensor matrix if it is not already there
317
			wl_token_bom_on_receive(source);
318
			break;
319
		case WL_TOKEN_JOIN:
320
			wl_token_join_receive(source);
321
			break;
322
		case WL_TOKEN_JOIN_ACCEPT:
323
			wl_token_join_accept_receive(source);
324
			break;
325
		default:
326
			WL_DEBUG_PRINT("Unimplemented token ring packet received.\r\n");
327
			break;
328
	}
329
}
330

  
331
/**
332
 * Returns the BOM reading robot source has for robot dest.
333
 *
334
 * @param source the robot that made the BOM reading
335
 * @param dest the robot whose relative location is returned
336
 *
337
 * @return a BOM reading from robot source to robot dest,
338
 * in the range 0-15, or -1 if it is unknown
339
 **/
340
int wl_token_get_sensor_reading(int source, int dest)
341
{
342
	if (wl_token_is_robot_in_ring(dest) &&
343
			(source == wl_get_xbee_id() || wl_token_is_robot_in_ring(source))) {
344
		return sensor_matrix_get_reading(source, dest);
345
	}
346

  
347
	return -1;
348
}
349

  
350
/**
351
 * Returns the BOM reading we have for robot dest.
352
 *
353
 * @param dest the robot whose relative location is returned
354
 *
355
 * @return a BOM reading from us to robot dest, in the range
356
 * 0-15, or -1 if it is unkown
357
 **/
358
int wl_token_get_my_sensor_reading(int dest)
359
{
360
	return wl_token_get_sensor_reading(wl_get_xbee_id(), dest);
361
}
362

  
363

  
364
/**
365
 * Returns the number of robots in the token ring.
366
 *
367
 * @return the number of robots in the token ring
368
 **/
369
int wl_token_get_robots_in_ring(void)
370
{
371
	return sensor_matrix_get_joined();
372
}
373

  
374
/**
375
 * Returns true if the specified robot is in the token ring, false
376
 * otherwise.
377
 *
378
 * @param robot the robot to check for whether it is in the token ring
379
 * @return nonzero if the robot is in the token ring, zero otherwise
380
 **/
381
int wl_token_is_robot_in_ring(int robot)
382
{
383
	return sensor_matrix_get_in_ring(robot);
384
}
385

  
386
/**
387
 * Begins iterating through the robots in the token ring.
388
 *
389
 * @see wl_token_iterator_has_next, wl_token_iterator_next
390
 **/
391
void wl_token_iterator_begin(void)
392
{
393
	int i = 0;
394
  //TODO: the compiler may or may not optimize this such that my comment is useless:
395
  // instead of calling sensor_matrix_get_size every iteration of the while loop and incurring
396
  // the overhead of a function call each iteration, call it only once before the loop and store
397
  // the value in a variable and check against that variable in the loop condition
398
	while (!sensor_matrix_get_in_ring(i) && i < sensor_matrix_get_size()) {
399
		i++;
400
	}
401

  
402
  //TODO: if you do the above comment, then you can compare this to the variable also
403
	if (i == sensor_matrix_get_size()) {
404
		i = -1;
405
	}
406

  
407
	iteratorCount = i;
408
}
409

  
410
/**
411
 * Returns true if there are more robots in the token ring
412
 * to iterate through, and false otherwise.
413
 *
414
 * @return nonzero if there are more robots to iterate through,
415
 * zero otherwise
416
 *
417
 * @see wl_token_iterator_begin, wl_token_iterator_next
418
 **/
419
int wl_token_iterator_has_next(void)
420
{
421
	return iteratorCount != -1;
422
}
423

  
424
/**
425
 * Returns the next robot ID in the token ring.
426
 *
427
 * @return the next robot ID in the token ring, or -1 if none exists
428
 *
429
 * @see wl_token_iterator_begin, wl_token_iterator_has_next
430
 **/
431
int wl_token_iterator_next(void)
432
{
433
	int result = iteratorCount;
434
	if (result < 0) {
435
		return result;
436
	}
437

  
438
  //TODO: the compiler may or may not optimize this such that my comment is useless:
439
  // instead of calling sensor_matrix_get_size every iteration of the while loop and incurring
440
  // the overhead of a function call each iteration, call it only once before the loop and store
441
  // the value in a variable and check against that variable in the loop condition
442
	iteratorCount++;
443
	while (!sensor_matrix_get_in_ring(iteratorCount)
444
		&& iteratorCount < sensor_matrix_get_size()) {
445
		iteratorCount++;
446
	}
447

  
448
  //TODO: if you do the above comment, then you can compare this to the variable also
449
	if (iteratorCount == sensor_matrix_get_size()) {
450
		iteratorCount = -1;
451
	}
452

  
453
	return result;
454
}
455

  
456
/**
457
 * Returns the number of robots currently in the token ring.
458
 *
459
 * @return the number of robots in the token ring
460
 **/
461
int wl_token_get_num_robots(void)
462
{
463
	return sensor_matrix_get_joined();
464
}
465

  
466
/**
467
 * Returns the number of robots in the sensor matrix.
468
 *
469
 * @return the number of robots in the sensor matrix
470
 **/
471
int wl_token_get_matrix_size(void)
472
{
473
	return sensor_matrix_get_size();
474
}
475

  
476
/**
477
 * This method is called when we receive a token pass packet.
478
 *
479
 * @param source the robot who passed the token to us.
480
 **/
481
static void wl_token_pass_receive(int source)
482
{
483
	WL_DEBUG_PRINT("Received token from ");
484
	WL_DEBUG_PRINT_INT(source);
485
	WL_DEBUG_PRINT(", expected ");
486
	WL_DEBUG_PRINT_INT(wl_token_next_robot);
487
	WL_DEBUG_PRINT(".\n");
488
	// this prevents two tokens from being passed around at a time (second clause is in case we are joining)
489
	if ((source != wl_token_next_robot && wl_get_xbee_id() != wl_token_next_robot) && bom_on_count <= DEATH_DELAY / 2 &&
490
		ringState != ACCEPTED)
491
	{
492
		WL_DEBUG_PRINT("Received token pass when a robot should not have died yet.\n");
493
		WL_DEBUG_PRINT("There are probably two tokens going around, packet ignored.\n");
494
		return;
495
	}
496
	bom_on_count = -1;
497
	deathDelay = -1;
498
	sensor_matrix_set_in_ring(source, 1);
499
	wl_token_get_token();
500
}
501

  
502
/**
503
 * This method is called when we receive a token pass packet.
504
 * @param source is the robot it came from
505
 * @param nextRobot is the robot the token was passed to
506
 * @param sensorData a char with an id followed by a char with the sensor
507
 *		reading for that robot, repeated for sensorDataLength bytes
508
 * @param sensorDataLength the length in bytes of sensorData
509
 */
510
static void wl_token_sensor_matrix_receive(int source, unsigned char* sensorData, int sensorDataLength)
511
{
512
	int i, j;
513
	char nextRobot;
514

  
515
	bom_on_count = -1;
516
	deathDelay = -1;
517
	sensor_matrix_set_in_ring(source, 1);
518

  
519
	//with this packet, we are passed the id of the next robot in the ring
520
	//and the sensor matrix, a list of id and sensor reading pairs (two bytes for both)
521
	j = 0;
522
  //TODO: the compiler may or may not optimize this such that my comment is useless:
523
  // instead of calling sensor_matrix_get_size every iteration of the while loop and incurring
524
  // the overhead of a function call each iteration, call it only once before the loop and store
525
  // the value in a variable and check against that variable in the loop condition
526
	for (i = 0; i < sensor_matrix_get_size(); i++)
527
	{
528
		if (i == source) {
529
			continue;
530
		}
531

  
532
		//set the sensor information we receive
533
		if (j < sensorDataLength / 2 && sensorData[2 * j] == i)
534
		{
535
			//the robot we were going to accept has already been accepted
536
			if (accepted == i)
537
			{
538
				accepted = -1;
539
				WL_DEBUG_PRINT("Someone accepted the robot we did.\r\n");
540
			}
541
			sensor_matrix_set_reading(source, i,
542
						sensorData[2 * j + 1]);
543
			if (!sensor_matrix_get_in_ring(i))
544
			{
545
				WL_DEBUG_PRINT("Robot ");
546
				WL_DEBUG_PRINT_INT(i);
547
				WL_DEBUG_PRINT(" has been added to the sensor matrix of robot ");
548
				WL_DEBUG_PRINT_INT(wl_get_xbee_id());
549
				WL_DEBUG_PRINT(" due to a packet from robot ");
550
				WL_DEBUG_PRINT_INT(source);
551
				WL_DEBUG_PRINT(".\r\n");
552
			}
553
			sensor_matrix_set_in_ring(i, 1);
554
			j++;
555
		}
556
		else
557
		{
558
			if (sensor_matrix_get_in_ring(i))
559
			{
560
				WL_DEBUG_PRINT("Robot ");
561
				WL_DEBUG_PRINT_INT(i);
562
				WL_DEBUG_PRINT(" has been removed from the sensor matrix of robot ");
563
				WL_DEBUG_PRINT_INT(wl_get_xbee_id());
564
				WL_DEBUG_PRINT(" due to a packet from robot ");
565
				WL_DEBUG_PRINT_INT(source);
566
				WL_DEBUG_PRINT(".\r\n");
567
				sensor_matrix_set_in_ring(i, 0);
568
			}
569

  
570
			if (i == wl_get_xbee_id() && ringState == MEMBER)
571
			{
572
				ringState = NONMEMBER;
573
				wl_token_ring_join();
574

  
575
				WL_DEBUG_PRINT("We have been removed from the ring ");
576
				WL_DEBUG_PRINT("and are rejoining.\r\n");
577
			}
578

  
579
			//the person who accepted us is dead... let's ask again
580
			if (i == acceptor)
581
			{
582
				sensor_matrix_set_in_ring(wl_get_xbee_id(), 0);
583
				ringState = NONMEMBER;
584
				acceptor = -1;
585
				wl_token_ring_join();
586
			}
587
		}
588
	}
589
	
590
	// get the next robot in the token ring
591
	i = source + 1;
592
	while (1)
593
	{
594
		if (i == sensor_matrix_get_size()) {
595
			i = 0;
596
		}
597

  
598
		if (sensor_matrix_get_in_ring(i) || i == source)
599
		{
600
			nextRobot = (char)i;
601
			break;
602
		}
603

  
604
		i++;
605
	}
606

  
607
	if (nextRobot != wl_get_xbee_id())
608
		wl_token_next_robot = nextRobot;
609

  
610
	deathDelay = get_token_distance(wl_get_xbee_id(), nextRobot) * DEATH_DELAY;
611

  
612
	if (sensor_matrix_get_joined() == 0 && ringState == JOINING)
613
		wl_send_robot_to_robot_global_packet(WL_TOKEN_RING_GROUP, WL_TOKEN_PASS, NULL, 0, nextRobot, WL_TOKEN_PASS_FRAME);
614
}
615

  
616
/**
617
 * Gets the distance in the token ring between two robots.
618
 *
619
 * @param robot1 the first robot
620
 * @param robot2 the second robot
621
 *
622
 * @return the number of passes before the token is expected
623
 * to reach robot2 from robot1
624
 **/
625
static int get_token_distance(int robot1, int robot2)
626
{
627
	int curr = robot1 + 1;
628
	int count = 1;
629
	while (1)
630
	{
631
    //TODO: the compiler may or may not optimize this such that my comment is useless:
632
    // instead of calling sensor_matrix_get_size every iteration of the while loop and incurring
633
    // the overhead of a function call each iteration, call it only once before the loop and store
634
    // the value in a variable and check against that variable in the loop condition
635
		if (curr == sensor_matrix_get_size())
636
			curr = 0;
637
		if (curr == robot2)
638
			break;
639
		if (sensor_matrix_get_in_ring(curr))
640
			count++;
641
		curr++;
642
	}
643
	return count;
644
}
645

  
646
/**
647
 * Passes the token to the next robot in the token ring.
648
 **/
649
static int wl_token_pass_token()
650
{
651
	char nextRobot = 0xFF;
652
	int i = wl_get_xbee_id() + 1;
653
	char buf[2 * sensor_matrix_get_size()];
654
	if (accepted == -1)
655
	{
656
		while (1)
657
		{
658
      //TODO: the compiler may or may not optimize this such that my comment is useless:
659
      // instead of calling sensor_matrix_get_size every iteration of the while loop and incurring
660
      // the overhead of a function call each iteration, call it only once before the loop and store
661
      // the value in a variable and check against that variable in the loop condition
662
			if (i == sensor_matrix_get_size()) {
663
				i = 0;
664
			}
665

  
666
			if (sensor_matrix_get_in_ring(i))
667
			{
668
				nextRobot = (char)i;
669
				break;
670
			}
671

  
672
			i++;
673
		}
674
	}
675
	else
676
	{
677
		WL_DEBUG_PRINT("Accepting new robot, sending it the token.\r\n");
678
		//add a new robot to the token ring
679
		sensor_matrix_set_in_ring(accepted, 1);
680
		nextRobot = accepted;
681
		accepted = -1;
682
	}
683

  
684
	int j = 0;
685
  //TODO: the compiler may or may not optimize this such that my comment is useless:
686
  // instead of calling sensor_matrix_get_size every iteration of the while loop and incurring
687
  // the overhead of a function call each iteration, call it only once before the loop and store
688
  // the value in a variable and check against that variable in the loop condition
689
	for (i = 0; i < sensor_matrix_get_size(); i++) {
690
		if (sensor_matrix_get_in_ring(i) && i != wl_get_xbee_id())
691
		{
692
			buf[2*j] = i;
693
			buf[2*j + 1] = sensor_matrix_get_reading(wl_get_xbee_id(), i);
694
			j++;
695
		}
696
	}
697

  
698
	int packetSize = 2 * j * sizeof(char);
699
	WL_DEBUG_PRINT("Passing the token to robot ");
700
	WL_DEBUG_PRINT_INT(nextRobot);
701
	WL_DEBUG_PRINT(".\r\n");
702
	if (wl_send_global_packet(WL_TOKEN_RING_GROUP, WL_TOKEN_SENSOR_MATRIX, buf, packetSize, 0) != 0)
703
		return -1;
704
	if (wl_send_robot_to_robot_global_packet(WL_TOKEN_RING_GROUP, WL_TOKEN_PASS, NULL, 0, nextRobot, WL_TOKEN_PASS_FRAME))
705
		return -1;
706

  
707
	wl_token_next_robot = nextRobot;
708
	deathDelay = DEATH_DELAY;
709

  
710
	return 0;
711
}
712

  
713
/**
714
 * Called when a packet is received stating that another robot has turned
715
 * its BOM on. Our BOM is then read, and the data is added to the sensor
716
 * matrix.
717
 *
718
 * @param source the robot whose BOM is on
719
 **/
720
static void wl_token_bom_on_receive(int source)
721
{
722
	int max;
723

  
724
	WL_DEBUG_PRINT("Robot ");
725
	WL_DEBUG_PRINT_INT(source);
726
	WL_DEBUG_PRINT(" has flashed its bom.\r\n");
727

  
728
	bom_on_count = 0;
729

  
730
	max = get_max_bom_function();
731
	sensor_matrix_set_reading(wl_get_xbee_id(),
732
		source, max);
733

  
734
	WL_DEBUG_PRINT("Max: ");
735
	WL_DEBUG_PRINT_INT(max);
736
	WL_DEBUG_PRINT("\n\n");
737
}
738

  
739
/**
740
 * This method is called when we receive the token. Upon receiving
741
 * the token, we must send a BOM_ON packet, flash the BOM, and send
742
 * the token to the next robot.
743
 *
744
 * If there is a pending request for the token, this is processed first.
745
 **/
746
static void wl_token_get_token()
747
{
748
	WL_DEBUG_PRINT("We have the token.\r\n");
749
	if (ringState == ACCEPTED)
750
	{
751
		sensor_matrix_set_in_ring(wl_get_xbee_id(), 1);
752
		WL_DEBUG_PRINT("Now a member of the token ring.\r\n");
753
		ringState = MEMBER;
754
		joinDelay = -1;
755
	}
756

  
757
	if (ringState == LEAVING || ringState == NONMEMBER)
758
	{
759
		sensor_matrix_set_in_ring(wl_get_xbee_id(), 0);
760
		if (ringState == NONMEMBER)
761
		{
762
			WL_DEBUG_PRINT("We should have left the token ring, but didn't.\r\n");
763
		}
764
		return;
765
	}
766

  
767
	WL_DEBUG_PRINT("Our BOM has been flashed.\r\n");
768
	wl_send_global_packet(WL_TOKEN_RING_GROUP, WL_TOKEN_BOM_ON, NULL, 0, 0);
769

  
770
	bom_on_function();
771
	#ifdef ROBOT
772
	delay_ms(BOM_DELAY);
773
	#endif
774
	bom_off_function();
775

  
776
	if (!sensor_matrix_get_in_ring(wl_get_xbee_id()))
777
	{
778
		WL_DEBUG_PRINT("Removed from sensor matrix while flashing BOM.\r\n");
779
		return;
780
	}
781

  
782
	wl_token_pass_token();
783
}
784

  
785
/**
786
 * Called when a request to join the token ring is received.
787
 * If we are the robot preceding the requester in the ring,
788
 * we respond with a JOIN_ACCEPT packet and pass the token to
789
 * this robot when we receive the token.
790
 *
791
 * @param source the robot who requested to join
792
 **/
793
static void wl_token_join_receive(int source)
794
{
795
	WL_DEBUG_PRINT("Received joining request from robot ");
796
	WL_DEBUG_PRINT_INT(source);
797
	WL_DEBUG_PRINT(".\r\n");
798

  
799
	//we cannot accept the request if we are not a member
800
	if (ringState != MEMBER)
801
		return;
802
	//if they didn't get our response, see if we should respond again
803
	if (accepted == source)
804
		accepted = -1;
805
	//we can only accept one request at a time
806
	if (accepted != -1)
807
		return;
808

  
809
	//check if we are the preceding robot in the token ring
810
	int i = source - 1;
811
	while (1)
812
	{
813
		if (i < 0)
814
			i = sensor_matrix_get_size() - 1;
815

  
816
		//we must send a join acceptance
817
		if (i == wl_get_xbee_id())
818
			break;
819

  
820
		//another robot will handle it
821
		if (sensor_matrix_get_in_ring(i))
822
			return;
823

  
824
		i--;
825
	}
826

  
827
	accepted = source;
828
	wl_send_robot_to_robot_global_packet(WL_TOKEN_RING_GROUP, WL_TOKEN_JOIN_ACCEPT,
829
		NULL, 0, source, TOKEN_JOIN_ACCEPT_FRAME);
830

  
831
	WL_DEBUG_PRINT("Accepting robot ");
832
	WL_DEBUG_PRINT_INT(source);
833
	WL_DEBUG_PRINT(" into the token ring.\r\n");
834

  
835
	// the token ring has not started yet
836
	if (sensor_matrix_get_joined() == 1)
837
		wl_token_pass_token();
838
}
839

  
840
/**
841
 * Called when we receive a JOIN_ACCEPT packet in attempting to join
842
 * the token ring.
843
 * Our attempt to join the ring is stopped, and we wait for the token.
844
 *
845
 * @param source the robot who accepted us
846
 **/
847
static void wl_token_join_accept_receive(int source)
848
{
849
	WL_DEBUG_PRINT("Accepted into the token ring by robot ");
850
	WL_DEBUG_PRINT_INT(source);
851
	WL_DEBUG_PRINT(".\r\n");
852
	joinDelay = JOIN_DELAY;
853
	ringState = ACCEPTED;
854
	acceptor = source;
855

  
856
	//add ourselves to the token ring
857
	sensor_matrix_set_in_ring(wl_get_xbee_id(), 1);
858
}
demos/smart_run_around_fsm/lib/src/libwireless/Doxyfile
1
# Doxyfile 1.4.6
2
               
3
# This file describes the settings to be used by the documentation system
4
# doxygen (www.doxygen.org) for a project
5
#
6
# All text after a hash (#) is considered a comment and will be ignored
7
# The format is:
8
#       TAG = value [value, ...]
9
# For lists items can also be appended using:
10
#       TAG += value [value, ...]
11
# Values that contain spaces should be placed between quotes (" ")
12

  
13
#---------------------------------------------------------------------------
14
# Project related configuration options
15
#---------------------------------------------------------------------------
16

  
17
# The PROJECT_NAME tag is a single word (or a sequence of words surrounded 
18
# by quotes) that should identify the project.
19

  
20
PROJECT_NAME           = libwireless
21

  
22
# The PROJECT_NUMBER tag can be used to enter a project or revision number. 
23
# This could be handy for archiving the generated documentation or 
24
# if some version control system is used.
25

  
26
PROJECT_NUMBER         = 1.0
27

  
28
# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) 
29
# base path where the generated documentation will be put. 
30
# If a relative path is entered, it will be relative to the location 
31
# where doxygen was started. If left blank the current directory will be used.
32

  
33
OUTPUT_DIRECTORY       = docs
34
     
35
# If the CREATE_SUBDIRS tag is set to YES, then doxygen will create 
36
# 4096 sub-directories (in 2 levels) under the output directory of each output 
37
# format and will distribute the generated files over these directories. 
38
# Enabling this option can be useful when feeding doxygen a huge amount of 
39
# source files, where putting all generated files in the same directory would 
40
# otherwise cause performance problems for the file system.
41

  
42
CREATE_SUBDIRS         = NO
43

  
44
# The OUTPUT_LANGUAGE tag is used to specify the language in which all 
45
# documentation generated by doxygen is written. Doxygen will use this 
46
# information to generate all constant output in the proper language. 
47
# The default language is English, other supported languages are: 
48
# Brazilian, Catalan, Chinese, Chinese-Traditional, Croatian, Czech, Danish, 
49
# Dutch, Finnish, French, German, Greek, Hungarian, Italian, Japanese, 
50
# Japanese-en (Japanese with English messages), Korean, Korean-en, Norwegian, 
51
# Polish, Portuguese, Romanian, Russian, Serbian, Slovak, Slovene, Spanish, 
52
# Swedish, and Ukrainian.
53

  
54
OUTPUT_LANGUAGE        = English
55

  
56
# This tag can be used to specify the encoding used in the generated output. 
57
# The encoding is not always determined by the language that is chosen, 
58
# but also whether or not the output is meant for Windows or non-Windows users. 
59
# In case there is a difference, setting the USE_WINDOWS_ENCODING tag to YES 
60
# forces the Windows encoding (this is the default for the Windows binary), 
61
# whereas setting the tag to NO uses a Unix-style encoding (the default for 
62
# all platforms other than Windows).
63

  
64
USE_WINDOWS_ENCODING   = NO
65

  
66
# If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will 
67
# include brief member descriptions after the members that are listed in 
68
# the file and class documentation (similar to JavaDoc). 
69
# Set to NO to disable this.
70

  
71
BRIEF_MEMBER_DESC      = YES
72

  
73
# If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend 
74
# the brief description of a member or function before the detailed description. 
75
# Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the 
76
# brief descriptions will be completely suppressed.
77

  
78
REPEAT_BRIEF           = YES
79

  
80
# This tag implements a quasi-intelligent brief description abbreviator 
81
# that is used to form the text in various listings. Each string 
82
# in this list, if found as the leading text of the brief description, will be 
83
# stripped from the text and the result after processing the whole list, is 
84
# used as the annotated text. Otherwise, the brief description is used as-is. 
85
# If left blank, the following values are used ("$name" is automatically 
86
# replaced with the name of the entity): "The $name class" "The $name widget" 
87
# "The $name file" "is" "provides" "specifies" "contains" 
88
# "represents" "a" "an" "the"
89

  
90
ABBREVIATE_BRIEF       = 
91

  
92
# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then 
93
# Doxygen will generate a detailed section even if there is only a brief 
94
# description.
95

  
96
ALWAYS_DETAILED_SEC    = NO
97

  
98
# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all 
99
# inherited members of a class in the documentation of that class as if those 
100
# members were ordinary class members. Constructors, destructors and assignment 
101
# operators of the base classes will not be shown.
102

  
103
INLINE_INHERITED_MEMB  = NO
104

  
105
# If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full 
106
# path before files name in the file list and in the header files. If set 
107
# to NO the shortest path that makes the file name unique will be used.
108

  
109
FULL_PATH_NAMES        = YES
110

  
111
# If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag 
112
# can be used to strip a user-defined part of the path. Stripping is 
113
# only done if one of the specified strings matches the left-hand part of 
114
# the path. The tag can be used to show relative paths in the file list. 
115
# If left blank the directory from which doxygen is run is used as the 
116
# path to strip.
117

  
118
STRIP_FROM_PATH        = 
119

  
120
# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of 
121
# the path mentioned in the documentation of a class, which tells 
122
# the reader which header file to include in order to use a class. 
123
# If left blank only the name of the header file containing the class 
124
# definition is used. Otherwise one should specify the include paths that 
125
# are normally passed to the compiler using the -I flag.
126

  
127
STRIP_FROM_INC_PATH    = 
128

  
129
# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter 
130
# (but less readable) file names. This can be useful is your file systems 
131
# doesn't support long names like on DOS, Mac, or CD-ROM.
132

  
133
SHORT_NAMES            = NO
134

  
135
# If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen 
136
# will interpret the first line (until the first dot) of a JavaDoc-style 
137
# comment as the brief description. If set to NO, the JavaDoc 
138
# comments will behave just like the Qt-style comments (thus requiring an 
139
# explicit @brief command for a brief description.
140

  
141
JAVADOC_AUTOBRIEF      = NO
142

  
143
# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make Doxygen 
144
# treat a multi-line C++ special comment block (i.e. a block of //! or /// 
145
# comments) as a brief description. This used to be the default behaviour. 
146
# The new default is to treat a multi-line C++ comment block as a detailed 
147
# description. Set this tag to YES if you prefer the old behaviour instead.
148

  
149
MULTILINE_CPP_IS_BRIEF = NO
150

  
151
# If the DETAILS_AT_TOP tag is set to YES then Doxygen 
152
# will output the detailed description near the top, like JavaDoc.
153
# If set to NO, the detailed description appears after the member 
154
# documentation.
155

  
156
DETAILS_AT_TOP         = NO
157

  
158
# If the INHERIT_DOCS tag is set to YES (the default) then an undocumented 
159
# member inherits the documentation from any documented member that it 
160
# re-implements.
161

  
162
INHERIT_DOCS           = YES
163

  
164
# If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce 
165
# a new page for each member. If set to NO, the documentation of a member will 
166
# be part of the file/class/namespace that contains it.
167

  
168
SEPARATE_MEMBER_PAGES  = NO
169

  
170
# The TAB_SIZE tag can be used to set the number of spaces in a tab. 
171
# Doxygen uses this value to replace tabs by spaces in code fragments.
172

  
173
TAB_SIZE               = 8
174

  
175
# This tag can be used to specify a number of aliases that acts 
176
# as commands in the documentation. An alias has the form "name=value". 
177
# For example adding "sideeffect=\par Side Effects:\n" will allow you to 
178
# put the command \sideeffect (or @sideeffect) in the documentation, which 
179
# will result in a user-defined paragraph with heading "Side Effects:". 
180
# You can put \n's in the value part of an alias to insert newlines.
181

  
182
ALIASES                = 
183

  
184
# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C 
185
# sources only. Doxygen will then generate output that is more tailored for C. 
186
# For instance, some of the names that are used will be different. The list 
187
# of all members will be omitted, etc.
188

  
189
OPTIMIZE_OUTPUT_FOR_C  = YES
190

  
191
# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java 
192
# sources only. Doxygen will then generate output that is more tailored for Java. 
193
# For instance, namespaces will be presented as packages, qualified scopes 
194
# will look different, etc.
195

  
196
OPTIMIZE_OUTPUT_JAVA   = NO
197

  
198
# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want to 
199
# include (a tag file for) the STL sources as input, then you should 
200
# set this tag to YES in order to let doxygen match functions declarations and 
201
# definitions whose arguments contain STL classes (e.g. func(std::string); v.s. 
202
# func(std::string) {}). This also make the inheritance and collaboration 
203
# diagrams that involve STL classes more complete and accurate.
204

  
205
BUILTIN_STL_SUPPORT    = NO
206

  
207
# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC 
208
# tag is set to YES, then doxygen will reuse the documentation of the first 
209
# member in the group (if any) for the other members of the group. By default 
210
# all members of a group must be documented explicitly.
211

  
212
DISTRIBUTE_GROUP_DOC   = NO
213

  
214
# Set the SUBGROUPING tag to YES (the default) to allow class member groups of 
215
# the same type (for instance a group of public functions) to be put as a 
216
# subgroup of that type (e.g. under the Public Functions section). Set it to 
217
# NO to prevent subgrouping. Alternatively, this can be done per class using 
218
# the \nosubgrouping command.
219

  
220
SUBGROUPING            = YES
221

  
222
#---------------------------------------------------------------------------
223
# Build related configuration options
224
#---------------------------------------------------------------------------
225

  
226
# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in 
227
# documentation are documented, even if no documentation was available. 
228
# Private class members and static file members will be hidden unless 
229
# the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES
230

  
231
EXTRACT_ALL            = NO
232

  
233
# If the EXTRACT_PRIVATE tag is set to YES all private members of a class 
234
# will be included in the documentation.
235

  
236
EXTRACT_PRIVATE        = NO
237

  
238
# If the EXTRACT_STATIC tag is set to YES all static members of a file 
239
# will be included in the documentation.
240

  
241
EXTRACT_STATIC         = NO
242

  
243
# If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs) 
244
# defined locally in source files will be included in the documentation. 
245
# If set to NO only classes defined in header files are included.
246

  
247
EXTRACT_LOCAL_CLASSES  = YES
248

  
249
# This flag is only useful for Objective-C code. When set to YES local 
250
# methods, which are defined in the implementation section but not in 
251
# the interface are included in the documentation. 
252
# If set to NO (the default) only methods in the interface are included.
253

  
254
EXTRACT_LOCAL_METHODS  = NO
255

  
256
# If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all 
257
# undocumented members of documented classes, files or namespaces. 
258
# If set to NO (the default) these members will be included in the 
259
# various overviews, but no documentation section is generated. 
260
# This option has no effect if EXTRACT_ALL is enabled.
261

  
262
HIDE_UNDOC_MEMBERS     = NO
263

  
264
# If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all 
265
# undocumented classes that are normally visible in the class hierarchy. 
266
# If set to NO (the default) these classes will be included in the various 
267
# overviews. This option has no effect if EXTRACT_ALL is enabled.
268

  
269
HIDE_UNDOC_CLASSES     = NO
270

  
271
# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, Doxygen will hide all 
272
# friend (class|struct|union) declarations. 
273
# If set to NO (the default) these declarations will be included in the 
274
# documentation.
275

  
276
HIDE_FRIEND_COMPOUNDS  = NO
277

  
278
# If the HIDE_IN_BODY_DOCS tag is set to YES, Doxygen will hide any 
279
# documentation blocks found inside the body of a function. 
280
# If set to NO (the default) these blocks will be appended to the 
281
# function's detailed documentation block.
282

  
283
HIDE_IN_BODY_DOCS      = NO
284

  
285
# The INTERNAL_DOCS tag determines if documentation 
286
# that is typed after a \internal command is included. If the tag is set 
287
# to NO (the default) then the documentation will be excluded. 
288
# Set it to YES to include the internal documentation.
289

  
290
INTERNAL_DOCS          = NO
291

  
292
# If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate 
293
# file names in lower-case letters. If set to YES upper-case letters are also 
294
# allowed. This is useful if you have classes or files whose names only differ 
295
# in case and if your file system supports case sensitive file names. Windows 
296
# and Mac users are advised to set this option to NO.
297

  
298
CASE_SENSE_NAMES       = YES
299

  
300
# If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen 
301
# will show members with their full class and namespace scopes in the 
302
# documentation. If set to YES the scope will be hidden.
303

  
304
HIDE_SCOPE_NAMES       = NO
305

  
306
# If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen 
307
# will put a list of the files that are included by a file in the documentation 
308
# of that file.
309

  
310
SHOW_INCLUDE_FILES     = YES
311

  
312
# If the INLINE_INFO tag is set to YES (the default) then a tag [inline] 
313
# is inserted in the documentation for inline members.
314

  
315
INLINE_INFO            = YES
316

  
317
# If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen 
318
# will sort the (detailed) documentation of file and class members 
319
# alphabetically by member name. If set to NO the members will appear in 
320
# declaration order.
321

  
322
SORT_MEMBER_DOCS       = YES
323

  
324
# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the 
325
# brief documentation of file, namespace and class members alphabetically 
326
# by member name. If set to NO (the default) the members will appear in 
327
# declaration order.
328

  
329
SORT_BRIEF_DOCS        = NO
330

  
331
# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be 
332
# sorted by fully-qualified names, including namespaces. If set to 
333
# NO (the default), the class list will be sorted only by class name, 
334
# not including the namespace part. 
335
# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES.
336
# Note: This option applies only to the class list, not to the 
337
# alphabetical list.
338

  
339
SORT_BY_SCOPE_NAME     = NO
340

  
341
# The GENERATE_TODOLIST tag can be used to enable (YES) or 
342
# disable (NO) the todo list. This list is created by putting \todo 
343
# commands in the documentation.
344

  
345
GENERATE_TODOLIST      = YES
346

  
347
# The GENERATE_TESTLIST tag can be used to enable (YES) or 
348
# disable (NO) the test list. This list is created by putting \test 
349
# commands in the documentation.
350

  
351
GENERATE_TESTLIST      = YES
352

  
353
# The GENERATE_BUGLIST tag can be used to enable (YES) or 
354
# disable (NO) the bug list. This list is created by putting \bug 
355
# commands in the documentation.
356

  
357
GENERATE_BUGLIST       = YES
358

  
359
# The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or 
360
# disable (NO) the deprecated list. This list is created by putting 
361
# \deprecated commands in the documentation.
362

  
363
GENERATE_DEPRECATEDLIST= YES
364

  
365
# The ENABLED_SECTIONS tag can be used to enable conditional 
366
# documentation sections, marked by \if sectionname ... \endif.
367

  
368
ENABLED_SECTIONS       = 
369

  
370
# The MAX_INITIALIZER_LINES tag determines the maximum number of lines 
371
# the initial value of a variable or define consists of for it to appear in 
372
# the documentation. If the initializer consists of more lines than specified 
373
# here it will be hidden. Use a value of 0 to hide initializers completely. 
374
# The appearance of the initializer of individual variables and defines in the 
375
# documentation can be controlled using \showinitializer or \hideinitializer 
376
# command in the documentation regardless of this setting.
377

  
378
MAX_INITIALIZER_LINES  = 30
379

  
380
# Set the SHOW_USED_FILES tag to NO to disable the list of files generated 
381
# at the bottom of the documentation of classes and structs. If set to YES the 
382
# list will mention the files that were used to generate the documentation.
383

  
384
SHOW_USED_FILES        = YES
385

  
386
# If the sources in your project are distributed over multiple directories 
387
# then setting the SHOW_DIRECTORIES tag to YES will show the directory hierarchy 
388
# in the documentation. The default is NO.
389

  
390
SHOW_DIRECTORIES       = NO
391

  
392
# The FILE_VERSION_FILTER tag can be used to specify a program or script that 
393
# doxygen should invoke to get the current version for each file (typically from the 
394
# version control system). Doxygen will invoke the program by executing (via 
395
# popen()) the command <command> <input-file>, where <command> is the value of 
396
# the FILE_VERSION_FILTER tag, and <input-file> is the name of an input file 
397
# provided by doxygen. Whatever the program writes to standard output 
398
# is used as the file version. See the manual for examples.
399

  
400
FILE_VERSION_FILTER    = 
401

  
402
#---------------------------------------------------------------------------
403
# configuration options related to warning and progress messages
404
#---------------------------------------------------------------------------
405

  
406
# The QUIET tag can be used to turn on/off the messages that are generated 
407
# by doxygen. Possible values are YES and NO. If left blank NO is used.
408

  
409
QUIET                  = NO
410

  
411
# The WARNINGS tag can be used to turn on/off the warning messages that are 
412
# generated by doxygen. Possible values are YES and NO. If left blank 
413
# NO is used.
414

  
415
WARNINGS               = YES
416

  
417
# If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings 
418
# for undocumented members. If EXTRACT_ALL is set to YES then this flag will 
419
# automatically be disabled.
420

  
421
WARN_IF_UNDOCUMENTED   = YES
422

  
423
# If WARN_IF_DOC_ERROR is set to YES, doxygen will generate warnings for 
424
# potential errors in the documentation, such as not documenting some 
425
# parameters in a documented function, or documenting parameters that 
426
# don't exist or using markup commands wrongly.
427

  
428
WARN_IF_DOC_ERROR      = YES
429

  
430
# This WARN_NO_PARAMDOC option can be abled to get warnings for 
431
# functions that are documented, but have no documentation for their parameters 
432
# or return value. If set to NO (the default) doxygen will only warn about 
433
# wrong or incomplete parameter documentation, but not about the absence of 
434
# documentation.
435

  
436
WARN_NO_PARAMDOC       = NO
437

  
438
# The WARN_FORMAT tag determines the format of the warning messages that 
439
# doxygen can produce. The string should contain the $file, $line, and $text 
440
# tags, which will be replaced by the file and line number from which the 
441
# warning originated and the warning text. Optionally the format may contain 
442
# $version, which will be replaced by the version of the file (if it could 
443
# be obtained via FILE_VERSION_FILTER)
444

  
445
WARN_FORMAT            = "$file:$line: $text"
446

  
447
# The WARN_LOGFILE tag can be used to specify a file to which warning 
448
# and error messages should be written. If left blank the output is written 
449
# to stderr.
450

  
451
WARN_LOGFILE           = 
452

  
453
#---------------------------------------------------------------------------
454
# configuration options related to the input files
455
#---------------------------------------------------------------------------
456

  
457
# The INPUT tag can be used to specify the files and/or directories that contain 
458
# documented source files. You may enter file names like "myfile.cpp" or 
459
# directories like "/usr/src/myproject". Separate the files or directories 
460
# with spaces.
461

  
462
INPUT                  = 
463

  
464
# If the value of the INPUT tag contains directories, you can use the 
465
# FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp 
466
# and *.h) to filter out the source-files in the directories. If left 
467
# blank the following patterns are tested: 
468
# *.c *.cc *.cxx *.cpp *.c++ *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh *.hxx 
469
# *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm *.py
470

  
471
FILE_PATTERNS          = 
472

  
473
# The RECURSIVE tag can be used to turn specify whether or not subdirectories 
474
# should be searched for input files as well. Possible values are YES and NO. 
475
# If left blank NO is used.
476

  
477
RECURSIVE              = NO
478

  
479
# The EXCLUDE tag can be used to specify files and/or directories that should 
480
# excluded from the INPUT source files. This way you can easily exclude a 
481
# subdirectory from a directory tree whose root is specified with the INPUT tag.
482

  
483
EXCLUDE                = 
484

  
485
# The EXCLUDE_SYMLINKS tag can be used select whether or not files or 
486
# directories that are symbolic links (a Unix filesystem feature) are excluded 
487
# from the input.
488

  
489
EXCLUDE_SYMLINKS       = NO
490

  
491
# If the value of the INPUT tag contains directories, you can use the 
492
# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude 
493
# certain files from those directories. Note that the wildcards are matched 
494
# against the file with absolute path, so to exclude all test directories 
495
# for example use the pattern */test/*
496

  
497
EXCLUDE_PATTERNS       = 
498

  
499
# The EXAMPLE_PATH tag can be used to specify one or more files or 
500
# directories that contain example code fragments that are included (see 
501
# the \include command).
502

  
503
EXAMPLE_PATH           = 
504

  
505
# If the value of the EXAMPLE_PATH tag contains directories, you can use the 
506
# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp 
507
# and *.h) to filter out the source-files in the directories. If left 
508
# blank all files are included.
509

  
510
EXAMPLE_PATTERNS       = 
511

  
512
# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be 
513
# searched for input files to be used with the \include or \dontinclude 
514
# commands irrespective of the value of the RECURSIVE tag. 
515
# Possible values are YES and NO. If left blank NO is used.
516

  
517
EXAMPLE_RECURSIVE      = NO
518

  
519
# The IMAGE_PATH tag can be used to specify one or more files or 
520
# directories that contain image that are included in the documentation (see 
521
# the \image command).
522

  
523
IMAGE_PATH             = 
524

  
525
# The INPUT_FILTER tag can be used to specify a program that doxygen should 
526
# invoke to filter for each input file. Doxygen will invoke the filter program 
527
# by executing (via popen()) the command <filter> <input-file>, where <filter> 
528
# is the value of the INPUT_FILTER tag, and <input-file> is the name of an 
529
# input file. Doxygen will then use the output that the filter program writes 
530
# to standard output.  If FILTER_PATTERNS is specified, this tag will be 
531
# ignored.
532

  
533
INPUT_FILTER           = 
534

  
535
# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern 
536
# basis.  Doxygen will compare the file name with each pattern and apply the 
537
# filter if there is a match.  The filters are a list of the form: 
538
# pattern=filter (like *.cpp=my_cpp_filter). See INPUT_FILTER for further 
539
# info on how filters are used. If FILTER_PATTERNS is empty, INPUT_FILTER 
540
# is applied to all files.
541

  
542
FILTER_PATTERNS        = 
543

  
544
# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using 
545
# INPUT_FILTER) will be used to filter the input files when producing source 
546
# files to browse (i.e. when SOURCE_BROWSER is set to YES).
547

  
548
FILTER_SOURCE_FILES    = NO
549

  
550
#---------------------------------------------------------------------------
551
# configuration options related to source browsing
552
#---------------------------------------------------------------------------
553

  
554
# If the SOURCE_BROWSER tag is set to YES then a list of source files will 
555
# be generated. Documented entities will be cross-referenced with these sources. 
556
# Note: To get rid of all source code in the generated output, make sure also 
557
# VERBATIM_HEADERS is set to NO.
558

  
559
SOURCE_BROWSER         = NO
560

  
561
# Setting the INLINE_SOURCES tag to YES will include the body 
562
# of functions and classes directly in the documentation.
563

  
564
INLINE_SOURCES         = NO
565

  
566
# Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct 
567
# doxygen to hide any special comment blocks from generated source code 
568
# fragments. Normal C and C++ comments will always remain visible.
569

  
570
STRIP_CODE_COMMENTS    = YES
571

  
572
# If the REFERENCED_BY_RELATION tag is set to YES (the default) 
573
# then for each documented function all documented 
574
# functions referencing it will be listed.
575

  
576
REFERENCED_BY_RELATION = YES
577

  
578
# If the REFERENCES_RELATION tag is set to YES (the default) 
579
# then for each documented function all documented entities 
580
# called/used by that function will be listed.
581

  
582
REFERENCES_RELATION    = YES
583

  
584
# If the USE_HTAGS tag is set to YES then the references to source code 
585
# will point to the HTML generated by the htags(1) tool instead of doxygen 
586
# built-in source browser. The htags tool is part of GNU's global source 
587
# tagging system (see http://www.gnu.org/software/global/global.html). You 
588
# will need version 4.8.6 or higher.
589

  
590
USE_HTAGS              = NO
591

  
592
# If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen 
593
# will generate a verbatim copy of the header file for each class for 
594
# which an include is specified. Set to NO to disable this.
595

  
596
VERBATIM_HEADERS       = YES
597

  
598
#---------------------------------------------------------------------------
599
# configuration options related to the alphabetical class index
600
#---------------------------------------------------------------------------
601

  
602
# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index 
603
# of all compounds will be generated. Enable this if the project 
604
# contains a lot of classes, structs, unions or interfaces.
605

  
606
ALPHABETICAL_INDEX     = NO
607

  
608
# If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then 
609
# the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns 
610
# in which this list will be split (can be a number in the range [1..20])
611

  
612
COLS_IN_ALPHA_INDEX    = 5
613

  
614
# In case all classes in a project start with a common prefix, all 
615
# classes will be put under the same header in the alphabetical index. 
616
# The IGNORE_PREFIX tag can be used to specify one or more prefixes that 
617
# should be ignored while generating the index headers.
618

  
619
IGNORE_PREFIX          = 
620

  
621
#---------------------------------------------------------------------------
622
# configuration options related to the HTML output
623
#---------------------------------------------------------------------------
624

  
625
# If the GENERATE_HTML tag is set to YES (the default) Doxygen will 
626
# generate HTML output.
627

  
628
GENERATE_HTML          = YES
629

  
630
# The HTML_OUTPUT tag is used to specify where the HTML docs will be put. 
631
# If a relative path is entered the value of OUTPUT_DIRECTORY will be 
632
# put in front of it. If left blank `html' will be used as the default path.
633

  
... This diff was truncated because it exceeds the maximum size that can be displayed.

Also available in: Unified diff