Project

General

Profile

Revision 8

Added libdragonfly project folder.

View differences:

trunk/code/projects/libdragonfly/time.c
1
/*
2
time.c
3
anything that requires a delay
4
mostly delay_ms
5

  
6
author: Robotics Club, Colony Project
7

  
8
Change Log:
9
	2.5.07 - Kevin
10
		Aaron fixed the orb/servo code and made them use timer3 but compare registers B and C. He hard set the prescaler
11
		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.
12
		You now count how many 16ths of a second you want until you trigger your actual interrupt. Works. Changed defines
13
		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
14
		etc. Read that section in the time.h file for more information. Tested and works, though the clock drifts more than
15
		it used to
16
	1.30.07 - Kevin
17
		Modified the clock to run on timer3 on the Dragonfly. Works with decent accuracy. Using a prescaler of 256
18
	the timer counts up to a precomputer value which will trigger an interrupt and reset the timer. Multiples of
19
	256 change it by that multiple. Refer to the time.h file for all possible prescalers.
20
		The interrupt will call a specified function _rtc_func every pulse.
21
		All of it has been tested and it works.
22

  
23
*/
24
#include <avr/interrupt.h>
25
#include <util/delay.h>
26
#include <time.h>
27
#include <serial.h>
28

  
29
static volatile int _rtc_val = 0;
30
static volatile int _rtc_pulse = 0;
31
static volatile int _rtc_scale = 32;	//Defaults to 1 Second per pulse
32
static void (*_rtc_f)(void) = 0;
33

  
34
/**
35
 * @defgroup time Time
36
 * @brief Time functions
37
 * 
38
 * Functions dealing with time.
39
 * 
40
 * @{
41
 **/
42

  
43
/**
44
 * Delays for the specified number of milliseconds.
45
 * The accuracy of this function is unknown.
46
 *
47
 * @param ms the number of milliseconds to delay for
48
 **/
49
void delay_ms(int ms) 
50
{
51
	for(; ms > 15; ms-=15)
52
		_delay_ms(15);
53
	_delay_ms(ms);
54
}
55

  
56

  
57
/* 	Prescales defined in time.h. SECOND will give you 1 second.
58
	More scales are defined in the time.h file.
59
	rtc_func is the address to a function that you want called every clock tick. */
60
/**
61
 * Initializes the real time clock. Prescales are defined in time.h.
62
 * For example, SECOND will give 1 second. The specified function is
63
 * called every clock tick. For the real time clock to activate,
64
 * interrupts must be enabled. (through sei() )
65
 *
66
 * @param prescale_opt the period with which the timer is triggered
67
 * @param rtc_func the function called when the timer is triggered
68
 *
69
 * @see rtc_get, rtc_reset
70
 *
71
 **/
72
void rtc_init(int prescale_opt, void (*rtc_func)(void)) {
73
	
74
	//Clear timer register for Timer 3
75
	TCNT3 = 0;
76
	
77
	/* 	This sets the Waveform Generation Module to CTC (Clear Timer on Compare) Mode (100)
78
		See page135 in Atmega128 Docs for more modes and explanations */
79
	TCCR3B |= _BV(WGM32);
80
	
81
	/* 	This sets the prescaler for the system clock (8MHz) ie: divides the clock by some number.
82
		Currently set to a prescaler of 8 because that is what the orb and servos use (they are on this timer as well)
83
		See page137 in Atemga128 Docs for all the available prescalers */
84
	TCCR3B |= _BV(CS31);
85
	
86
	/* 	Sets the two regsiters that we compare against. So the timer counts up to this number and
87
		then resets back to 0 and calls the compare match interrupt.
88
		8x10^6 / 8 = 1/16 Second. All values are based off of this number. Do not change it unless you
89
		are l337*/
90
		
91
	OCR3A = 0xF424;	
92

  
93
	/* 	Enable Output Compare A Interrupt. When OCR3A is met by the timer TCNT3 this interrupt will be
94
		triggerd. (See page140 in Atmega128 Docs for more information */
95
	ETIMSK |= _BV(OCIE3A);
96
	
97
	/*	Store the pointer to the function to be used in the interrupt */
98
	_rtc_f = rtc_func;
99
	
100
	/*	Store how many 1/16ths of a second you want to let by before triggering an interrupt */
101
	_rtc_scale = prescale_opt;
102
}
103

  
104
/**
105
 * Returns the time elapsed in seconds since the last call to
106
 * rtc_init or rtc_reset.
107
 *
108
 * @return the number of seconds since the last call to rtc_init or rtc_reset
109
 *
110
 * @see rtc_init, rtc_reset
111
 **/
112
int rtc_get(void){
113
	return _rtc_val;
114
}
115

  
116
/**
117
 * Resets the real time clock counter to 0.
118
 *
119
 * @see rtc_init, rtc_get
120
 **/
121
void rtc_reset(void){
122
	_rtc_val = 0;
123
}
124

  
125
/** @} **/ //end defgroup
126

  
127
/*	Called every pulse. Function in _rtc_f is called every _rtc_scale and also the counter is updated.
128
	Bascially, since the pulse is hard set at 1/16s  you want to count how many 16ths of a second have passed
129
	and when it reaches the amount of time you want, execute the code. */
130
SIGNAL(TIMER3_COMPA_vect) {
131

  
132
	if (_rtc_pulse ==  _rtc_scale) {
133
		//Increment the real time clock counter
134
		_rtc_val++;
135
		
136
		//Calls the function tied to the real time clock if defined
137
		if(_rtc_f != 0)
138
			_rtc_f();
139
		
140
		//Resets the pulse until the next scale is matched
141
		_rtc_pulse = 0;
142
	}	
143
	
144
	//Updates the amount of pulses seen since the last scale match
145
	_rtc_pulse++;
146
	
147
}
148

  
trunk/code/projects/libdragonfly/lights.h
1
/**
2
 * @file lights.h
3
 * @brief Contains declarations for managing the orbs.
4
 *
5
 * Contains declarations for using the orbs and PWM.
6
 *
7
 * @author Colony Project, CMU Robotics Club
8
 * Based on Firefly Library, by Tom Lauwers and Steven Shamlian
9
 **/
10

  
11
#ifndef _LIGHTS_H_
12
#define _LIGHTS_H_
13

  
14

  
15
/**
16
 * @addtogroup orbs
17
 * @{
18
 **/
19

  
20
//ORB Colors
21
/** @brief Red **/
22
#define RED       0xE0
23
/** @brief Orange **/
24
#define ORANGE    0xE4
25
/** @brief Yellow **/
26
#define YELLOW    0xE8
27
/** @brief Lime **/
28
#define LIME      0x68
29
/** @brief Green **/
30
#define GREEN     0x1C
31
/** @brief Cyan **/
32
#define CYAN      0x1F
33
/** @brief Blue **/
34
#define BLUE      0x03
35
/** @brief Pink **/
36
#define PINK      0xA6 
37
/** @brief Purple **/
38
#define PURPLE    0x41
39
/** @brief Magenta **/
40
#define MAGENTA   0xE3
41
/** @brief White **/
42
#define WHITE     0xFE
43
/** @brief Turn the orb off (White) **/
44
#define ORB_OFF   0xFE      //ORB_OFF->WHITE
45

  
46
/** @brief Enables the orbs **/
47
void orb_init(void);
48
/** @brief Set both orbs to a specified color **/
49
void orb_set(unsigned char red_led, unsigned char green_led,
50
	unsigned char blue_led);
51
/** @brief Set orb1 to a specified color **/
52
void orb1_set(unsigned char red_led, unsigned char green_led,
53
	unsigned char blue_led); 
54
/** @brief Set orb2 to a specified color **/
55
void orb2_set(unsigned char red_led, unsigned char green_led,
56
	unsigned char blue_led);
57

  
58
/** @brief Set both orbs to a specified color **/
59
void orb_set_color(int col);
60
/** @brief Set orb1 to a specified color **/
61
void orb1_set_color(int col);
62
/** @brief Set orb2 to a specified color **/
63
void orb2_set_color(int col);
64

  
65
/** @brief Disable the orbs **/
66
void orb_disable(void);
67
/** @brief Enable the orbs **/
68
void orb_enable(void);
69

  
70
/** @} **/ //end addtogroup
71

  
72
#endif
73

  
trunk/code/projects/libdragonfly/motor.c
1
/*
2
	motor.c - Contains functions necessary for activating and driving the 
3
	H-bridge
4
	
5
	
6
	author: Robotics Club, Colony project
7
	
8
	much of this is taken from FWR's library, author: Tom Lauwers
9
	
10
*/
11

  
12
#include "motor.h"
13

  
14
/**
15
 * @defgroup motors Motors
16
 * @brief Functions for controlling the motors.
17
 * Functions for controlling the motors. Found in motor.h.
18
 * @{
19
 **/
20

  
21
/**
22
 * Initializes both motors so that they can be used with future
23
 * calls to motor1_set and motor2_set.
24
 *
25
 * @see motors_off, motor1_set, motor2_set
26
 **/
27
void motors_init( void ) {
28
	// Configure counter such that we use phase correct
29
	// PWM with 8-bit resolution
30
	PORTA &= 0x0F;
31
	DDRA |= 0xF0;
32
	DDRB |= 0x60;
33

  
34
	//timer 1A and 1B
35
	TCCR1A = _BV(COM1A1) | _BV(COM1B1) | _BV(WGM10);
36
	TCCR1B = _BV(WGM12) | _BV(CS10);
37
//	TCCR1A = 0xA1;
38
//	TCCR1B = 0x04;
39
	OCR1AH=0;
40
	OCR1AL=0;
41
	OCR1BH=0;
42
	OCR1BL=0;
43
}
44

  
45
/**
46
 * Sets the speed and direction of motor1.
47
 * motors_init must be called before this function can be used.
48
 *
49
 * @param direction Either FORWARD or BACKWARD to set the direction of rotation.
50
 * @param speed The speed the motor will run at, in the range 0-255.
51
 * 
52
 * @see motor2_set, motors_init
53
 **/
54
void motor1_set(int direction, int speed) {
55

  
56
	if(direction == 0) {
57
	    // turn off PWM first if switching directions
58
		if((PORTA & 0x30) != 0x10)
59
		{
60
		  OCR1A = 0;
61
		}	
62
		PORTA = (PORTA & 0xCF) | 0x10;
63
//		PORTD |= 0x10;
64
//		PORTD &= 0xBF;
65
	}
66
	else {
67
	    // turn off PWM first if switching directions
68
		if((PORTA & 0x30) != 0x20)
69
		{
70
		  OCR1A = 0;
71
		}
72
		PORTA = (PORTA & 0xCF) | 0x20;
73
//		PORTD |= 0x40;
74
//		PORTD &= 0xEF;
75
	}
76
	
77
	// Set the timer to count up to speed, an 8-bit value
78
	OCR1AL = speed;
79
}
80

  
81
/**
82
 * Sets the speed and direction of motor2.
83
 * motors_init must be called before this function can be used.
84
 *
85
 * @param direction Either FORWARD or BACKWARD to set the direction of rotation.
86
 * @param speed The speed the motor will run at, in the range 0-255.
87
 *
88
 * @see motor1_set, motors_init
89
 **/
90
void motor2_set(int direction, int speed) {
91
	if(direction == 0) {
92
//		PORTD |= 0x20;
93
//		PORTD &= 0x7F;
94
	    // turn off PWM first if switching directions
95
		if((PORTA & 0xC0) != 0x80)
96
		{
97
		  OCR1B = 0;
98
		}		
99
		
100
		PORTA = (PORTA & 0x3F) | 0x80;
101
	}
102
	else {
103
//		PORTD |= 0x80;
104
//		PORTD &= 0xDF;
105

  
106
	    // turn off PWM first if switching directions
107
		if((PORTA & 0xC0) != 0x40)
108
		{
109
		  OCR1B = 0;
110
		}		
111
		
112
		PORTA = (PORTA & 0x3F) | 0x40;
113
	}
114
	OCR1BL = speed;
115
}
116

  
117
/**
118
 * Turns off both motors.
119
 *
120
 * @see motors_init
121
 **/
122
void motors_off( void ) {
123
	OCR1AL = 0x0;
124
	OCR1BL = 0x0;
125
}
126

  
127
/**@}**///end defgroup
128

  
trunk/code/projects/libdragonfly/analog.c
1
/*
2
 * analog.c - Contains the function implementations for manipulating the ADC
3
 * on the firefly+ board
4
 * 
5
 * author:  CMU Robotics Club, Colony Project
6
 * code mostly taken from fwr analog file (author: Tom Lauwers)
7
 */
8

  
9
#include <util/delay.h>
10
#include <avr/interrupt.h>
11
#include "analog.h"
12

  
13
// Internal Function Prototypes
14
void set_adc_mux(int which);
15

  
16
/**
17
 * @defgroup analog Analog
18
 * Functions for manipulation the ADC on the dragonfly board.
19
 * All definitions may be found in analog.h.
20
 *
21
 * @{
22
 **/
23

  
24

  
25
/**
26
 * Initializes the ADC.
27
 * Call analog_init before reading from the analog ports.
28
 *
29
 * @see analog8, analog10
30
 **/
31
void analog_init(void)
32
{
33
	// ADC Status Register A
34
	// Bit 7 - ADEN is set (enables analog)
35
	// Bit 6 - Start conversion bit is set (must be done once for free-running mode)
36
	// Bit 5 - Enable Auto Trigger (for free running mode)
37
	// Bit 4 - ADC interrupt flag, 0
38
	// Bit 3 - Enable ADC Interrupt (required to run free-running mode)
39
	// Bits 2-0 - Set to create a clock divisor of 128, to make ADC clock = 8,000,000/128
40
	ADCSRA |= 0xEF;
41

  
42
	// ADC Status Register B
43
	// Bit 7, 5-3 - Must be cleared
44
	// Bit 2:0 - Set mode, currently cleared for free running operation
45
	// Bit 6 - Analog comparator mode - cleared
46
//	ADCSRB = 0x00;
47
	
48
	// ADMUX register
49
	// Bit 7,6 - Set voltage reference to AVcc (0b01)
50
	// Bit 5 - Set ADLAR bit for left adjust to do simple 8-bit reads
51
	// Bit 4 - X
52
	// Bit 3:0 - Sets the current channel, set to ADC7 (the external mux)
53
	ADMUX = 0x67;
54

  
55
	// Set external mux lines to outputs
56
	DDRG |= 0x1C;
57
	set_adc_mux(0x07);
58
}	
59

  
60

  
61
/**
62
 * Reads an eight bit number from an analog port.
63
 * analog_init must be called before using this function.
64
 * 
65
 * @param which the analog port to read from. One of
66
 * the constants AN0 - AN7.
67
 *
68
 * @return the eight bit input to the specified port
69
 *
70
 * @see analog_init, analog10
71
 **/
72
unsigned int analog8(int which)
73
{
74
	if(which < EXT_MUX)
75
		ADMUX = 0x60 + which;
76
	else if(which == EXT_MUX)
77
		return 0;
78
	else
79
	{
80
		ADMUX = 0x60 + EXT_MUX;
81
		set_adc_mux(which - 8);
82
		_delay_ms(1);
83
	}
84
	
85
	_delay_ms(1); // need at least 130 us between conversions
86
	return ADCH;
87
}
88

  
89
/**
90
 * Reads a ten bit number from the specified port.
91
 * analog_init must be called before using this function.
92
 *
93
 * @param which the analog port to read from. Typically
94
 * a constant, one of AN0 - AN7.
95
 *
96
 * @return the ten bit number input to the specified port
97
 * 
98
 * @see analog_init, analog8
99
 **/
100
unsigned int analog10(int which)
101
{
102
	unsigned int adc_h = 0;
103
	unsigned int adc_l = 0;
104

  
105
	if(which < EXT_MUX)
106
		ADMUX = 0x60 + which;
107
	else if(which == EXT_MUX)
108
		return 0;
109
	else
110
	{
111
		ADMUX = 0x60 + EXT_MUX;
112
		set_adc_mux(which - 8);
113
		_delay_ms(1);
114
	}
115

  
116
	_delay_ms(1);
117
	adc_l = ADCL; /* highest 2 bits of ADCL -> least 2 bits of analog val */
118
	adc_h = ADCH; /* ADCH -> 8 highest bits of analog val */
119
	
120
	return (adc_h << 2) | (adc_l >> 6);
121
}
122

  
123
/**
124
 * Returns the current position of the wheel, as an integer
125
 * in the range 0 - 255.
126
 * analog_init must be called before using this function.
127
 *
128
 * @return the orientation of the wheel, as an integer in
129
 * the range 0 - 255.
130
 *
131
 * @see analog_init
132
 **/
133
int wheel(void)
134
{
135
	return analog8(WHEEL_PORT);
136
}
137

  
138
/**@}**/ //end defgroup
139

  
140
SIGNAL (SIG_ADC)
141
{
142
	// This is just here to catch ADC interrupts because ADC is free running.  
143
	// No code needs to be in here.
144
}
145

  
146
void set_adc_mux(int which)
147
{
148
  // FIX THIS IN NEXT REVISION
149
  // ADDR2 ADDR1 ADDR0
150
  // G2.G4.G3 set mux to port 0-7 via binary selection
151
  // math would be much cleaner if it was G4.G3.G2
152
  
153
  // mask so only proper bits are possible.  
154
  PORTG = (PORTG & 0xE3) | ((which & 0x03) << 3) | (which & 0x04);
155
}
156

  
trunk/code/projects/libdragonfly/lcd.c
1
/*
2

  
3
lcd-ar2.c - implementation for lcd functions
4

  
5
Author: CMU Robotics Club, Colony Project
6

  
7
This uses SPI.
8

  
9
lcd_init MUST be called before anything can be used.
10

  
11
*/
12

  
13
#include <avr/io.h>
14
#include <lcd.h>
15
#include <time.h>
16

  
17
#define LCD_RS    PB4 // Command/Data
18
#define LCD_RSTB  PE2 // reset line
19
#define LCD_CS    PB0
20

  
21
//////lcd defines
22
#define RST _BV(4)  // pd4 (GPIO)
23
#define SCE _BV(0)  // pb0 (~SS)
24
#define D_C _BV(5)  // pd5 (GPIO?)
25
#define SDI _BV(2)  // pb2 (MOSI)
26
#define SCK _BV(1) // pb1 (SCK)
27

  
28
#define LCDPORT PORTB
29
#define LCDDDR DDRB
30

  
31
#define LCDRESETPORT PORTD
32
#define LCDRESETDDR DDRD
33

  
34
// Internal Function Prototypes
35
// inialize OLED and SPI
36
void OLED_init(void);
37

  
38
// reset Controller
39
void Reset_SSD1339(void);
40

  
41
// write command or data
42
void write_c(unsigned char out_command);
43
void write_d(unsigned char out_data);
44

  
45
// these write data to the OLED on 8 bit data bus,  depends on MCU
46
void LCD_out(unsigned char cmd);
47

  
48
// these functions set / clear pins for OLED control lines.  they accecpt a 0 or 1 
49
void DC(char stat);
50
void RES(char stat);
51
void CS(char stat);
52

  
53
void lcd_putbyte(unsigned char b);
54

  
55
void crazycircle (void) {
56
/*  int i;
57
  // draw 100 random circles
58
  for(i = 0;i < 100;i++){
59
      write_c(0x86);    // draw circle command
60
      write_d(rand() % 130);
61
      write_d(rand() % 130);
62
      write_d(rand() % 64);
63
      write_d(rand());
64
      write_d(rand());
65
      write_d(rand());
66
      write_d(rand());
67

  
68
      delay_ms(10);
69
  }
70
*/
71
}
72

  
73
void OLEDtest (void) {
74
  //int   i = 0;
75

  
76
  // Initialize
77
  //Initialize();
78
  OLED_init();
79

  
80
  delay_ms(120);
81

  
82
  write_c(0x8e);    // clear window command
83
  write_d(0);
84
  write_d(0);
85
  write_d(130);
86
  write_d(130);
87

  
88
  delay_ms(100);
89
  
90
  write_c(0x92);    // fill enable command
91
  write_d(0x01); 
92
  
93
  delay_ms(10);
94

  
95
  crazycircle();
96
/*
97
  // write directly to ram,  this fills up bottom 1/3 of display with color pattern
98
  write_c(0x5c);
99
  for (i = 0; i < 2000; i++){
100
  write_c(0x5c);  
101
   write_d(i);
102
   write_d(i);
103
   write_d(i);
104
  }
105
  */
106
} 
107

  
108
/**********************************************************
109
                      Initialize
110
**********************************************************/
111

  
112
void OLED_init(void)
113
{
114
  // Setup SPI here
115
  SPCR = 0x5D; //  enable SPI, master, SPI mode 3
116
  DDRB |= 0x06; // enable MOSI and SCK as outputs
117

  
118
  LCD_out(0);
119
  DC(0);
120
  CS(0);
121
  Reset_SSD1339();
122
  write_c(0xa0); // Set Re-map / Color Depth
123
  write_d(0x34);//0xb4); // 262K 8bit R->G->B
124
  write_c(0xa1); // Set display start line
125
  write_d(0x00); // 00h start
126
  //write_c(0xa2); // Set display offset
127
  //write_d(0x80); // 80h start
128
  write_c(0xA6); // Normal display
129
  write_c(0xad); // Set Master Configuration
130
  write_d(0x8e); // DC-DC off & external VcomH voltage & external pre-charge voltage
131
  write_c(0xb0); // Power saving mode
132
  write_d(0x05);
133
  write_c(0xb1); // Set pre & dis_charge
134
  write_d(0x11); // pre=1h dis=1h
135
  write_c(0xb3); // clock & frequency
136
  write_d(0xf0); // clock=Divser+1 frequency=fh
137
  write_c(0xbb); // Set pre-charge voltage of color A B C
138
  write_d(0xff); // color A  was 1c
139
  write_d(0xff); // color B  was 1c
140
  write_d(0xff); // color C  was 1c
141
  write_c(0xbe); // Set VcomH
142
  write_d(0x1f); //
143
  write_c(0xc1); // Set contrast current for A B C
144
  write_d(0xCa); // Color A was AA
145
  write_d(0xD4); // Color B was B4
146
  write_d(0xF8); // Color C was C8
147
  write_c(0xc7); // Set master contrast
148
  write_d(0x0f); // no change
149
  write_c(0xca); // Duty
150
  write_d(0x7f); // 127+1
151
  write_c(0xaf); // Display on
152
}
153

  
154
void Reset_SSD1339(void)
155
{
156
  RES(0);
157
  delay_ms(100);
158
  RES(1);
159
}
160
void write_c(unsigned char out_command)
161
{
162
  DC(0);CS(0);
163
  //delay_ms(1);
164
  
165
  LCD_out(out_command);
166
 // delay_ms(1);
167
  
168
  DC(1);
169
  // potentially add NOP
170
  CS(1);
171

  
172
}
173

  
174
void write_d(unsigned char out_data)
175
{
176
  DC(1);CS(0);
177
 // delay_ms(1);
178
 
179
  LCD_out(out_data);
180
 // delay_ms(1);
181
  DC(1);
182
  //potentially add NOP
183
  CS(1);
184
}
185

  
186
// these functions set / clear pins for LCD control lines.  they accecpt a 0 or 1 
187
void DC(char stat)
188
{
189
	DDRB |= _BV(LCD_RS);				// RS is P0.30, set to output
190
	if (stat)	
191
		PORTB |= _BV(LCD_RS);
192
	else
193
		PORTB &= ~(_BV(LCD_RS));
194
}
195

  
196
void RES(char stat)
197
{
198
	DDRE |= _BV(LCD_RSTB);				// RSTB is P0.7, set to output
199
	if (stat)	
200
		PORTE |= _BV(LCD_RSTB);
201
	else
202
		PORTE &= ~(_BV(LCD_RSTB));
203
}
204

  
205
void CS(char stat)
206
{
207
	DDRB |= _BV(LCD_CS);				// RSTB is P0.7, set to output
208
	if (stat)	
209
		PORTB |= _BV(LCD_CS);
210
	else
211
		PORTB &= ~(_BV(LCD_CS));
212
}
213

  
214
// send to the LCD
215
void LCD_out(unsigned char cmd)
216
{
217
	SPDR = cmd;
218
    // could also do this via interrupts
219
	loop_until_bit_is_set(SPSR, SPIF);
220
}
221

  
222

  
223
//**************************************Old shit below!*****************
224
/*
225
FontLookup - a lookup table for all characters
226
*/
227
static const unsigned char FontLookup [][5] =
228
{
229
    { 0x00, 0x00, 0x00, 0x00, 0x00 },  // sp
230
    { 0x00, 0x00, 0x5f, 0x00, 0x00 },   // !
231
    { 0x00, 0x07, 0x00, 0x07, 0x00 },   // "
232
    { 0x14, 0x7f, 0x14, 0x7f, 0x14 },   // #
233
    { 0x24, 0x2a, 0x7f, 0x2a, 0x12 },   // $
234
    { 0x23, 0x13, 0x08, 0x64, 0x62 },   // %
235
    { 0x36, 0x49, 0x55, 0x22, 0x50 },   // &
236
    { 0x00, 0x05, 0x03, 0x00, 0x00 },   // '
237
    { 0x00, 0x1c, 0x22, 0x41, 0x00 },   // (
238
    { 0x00, 0x41, 0x22, 0x1c, 0x00 },   // )
239
    { 0x14, 0x08, 0x3E, 0x08, 0x14 },   // *
240
    { 0x08, 0x08, 0x3E, 0x08, 0x08 },   // +
241
    { 0x00, 0x00, 0x50, 0x30, 0x00 },   // ,
242
    { 0x10, 0x10, 0x10, 0x10, 0x10 },   // -
243
    { 0x00, 0x60, 0x60, 0x00, 0x00 },   // .
244
    { 0x20, 0x10, 0x08, 0x04, 0x02 },   // /
245
    { 0x3E, 0x51, 0x49, 0x45, 0x3E },   // 0
246
    { 0x00, 0x42, 0x7F, 0x40, 0x00 },   // 1
247
    { 0x42, 0x61, 0x51, 0x49, 0x46 },   // 2
248
    { 0x21, 0x41, 0x45, 0x4B, 0x31 },   // 3
249
    { 0x18, 0x14, 0x12, 0x7F, 0x10 },   // 4
250
    { 0x27, 0x45, 0x45, 0x45, 0x39 },   // 5
251
    { 0x3C, 0x4A, 0x49, 0x49, 0x30 },   // 6
252
    { 0x01, 0x71, 0x09, 0x05, 0x03 },   // 7
253
    { 0x36, 0x49, 0x49, 0x49, 0x36 },   // 8
254
    { 0x06, 0x49, 0x49, 0x29, 0x1E },   // 9
255
    { 0x00, 0x36, 0x36, 0x00, 0x00 },   // :
256
    { 0x00, 0x56, 0x36, 0x00, 0x00 },   // ;
257
    { 0x08, 0x14, 0x22, 0x41, 0x00 },   // <
258
    { 0x14, 0x14, 0x14, 0x14, 0x14 },   // =
259
    { 0x00, 0x41, 0x22, 0x14, 0x08 },   // >
260
    { 0x02, 0x01, 0x51, 0x09, 0x06 },   // ?
261
    { 0x32, 0x49, 0x59, 0x51, 0x3E },   // @
262
    { 0x7E, 0x11, 0x11, 0x11, 0x7E },   // A
263
    { 0x7F, 0x49, 0x49, 0x49, 0x36 },   // B
264
    { 0x3E, 0x41, 0x41, 0x41, 0x22 },   // C
265
    { 0x7F, 0x41, 0x41, 0x22, 0x1C },   // D
266
    { 0x7F, 0x49, 0x49, 0x49, 0x41 },   // E
267
    { 0x7F, 0x09, 0x09, 0x09, 0x01 },   // F
268
    { 0x3E, 0x41, 0x49, 0x49, 0x7A },   // G
269
    { 0x7F, 0x08, 0x08, 0x08, 0x7F },   // H
270
    { 0x00, 0x41, 0x7F, 0x41, 0x00 },   // I
271
    { 0x20, 0x40, 0x41, 0x3F, 0x01 },   // J
272
    { 0x7F, 0x08, 0x14, 0x22, 0x41 },   // K
273
    { 0x7F, 0x40, 0x40, 0x40, 0x40 },   // L
274
    { 0x7F, 0x02, 0x0C, 0x02, 0x7F },   // M
275
    { 0x7F, 0x04, 0x08, 0x10, 0x7F },   // N
276
    { 0x3E, 0x41, 0x41, 0x41, 0x3E },   // O
277
    { 0x7F, 0x09, 0x09, 0x09, 0x06 },   // P
278
    { 0x3E, 0x41, 0x51, 0x21, 0x5E },   // Q
279
    { 0x7F, 0x09, 0x19, 0x29, 0x46 },   // R
280
    { 0x46, 0x49, 0x49, 0x49, 0x31 },   // S
281
    { 0x01, 0x01, 0x7F, 0x01, 0x01 },   // T
282
    { 0x3F, 0x40, 0x40, 0x40, 0x3F },   // U
283
    { 0x1F, 0x20, 0x40, 0x20, 0x1F },   // V
284
    { 0x3F, 0x40, 0x38, 0x40, 0x3F },   // W
285
    { 0x63, 0x14, 0x08, 0x14, 0x63 },   // X
286
    { 0x07, 0x08, 0x70, 0x08, 0x07 },   // Y
287
    { 0x61, 0x51, 0x49, 0x45, 0x43 },   // Z
288
    { 0x00, 0x7F, 0x41, 0x41, 0x00 },   // [
289
    { 0x02, 0x04, 0x08, 0x10, 0x20 },   // backslash
290
    { 0x00, 0x41, 0x41, 0x7F, 0x00 },   // ]
291
    { 0x04, 0x02, 0x01, 0x02, 0x04 },   // ^
292
    { 0x40, 0x40, 0x40, 0x40, 0x40 },   // _
293
    { 0x00, 0x01, 0x02, 0x04, 0x00 },   // '
294
    { 0x20, 0x54, 0x54, 0x54, 0x78 },   // a
295
    { 0x7F, 0x48, 0x44, 0x44, 0x38 },   // b
296
    { 0x38, 0x44, 0x44, 0x44, 0x20 },   // c
297
    { 0x38, 0x44, 0x44, 0x48, 0x7F },   // d
298
    { 0x38, 0x54, 0x54, 0x54, 0x18 },   // e
299
    { 0x08, 0x7E, 0x09, 0x01, 0x02 },   // f
300
    { 0x0C, 0x52, 0x52, 0x52, 0x3E },   // g
301
    { 0x7F, 0x08, 0x04, 0x04, 0x78 },   // h
302
    { 0x00, 0x44, 0x7D, 0x40, 0x00 },   // i
303
    { 0x20, 0x40, 0x44, 0x3D, 0x00 },   // j
304
    { 0x7F, 0x10, 0x28, 0x44, 0x00 },   // k
305
    { 0x00, 0x41, 0x7F, 0x40, 0x00 },   // l
306
    { 0x7C, 0x04, 0x18, 0x04, 0x78 },   // m
307
    { 0x7C, 0x08, 0x04, 0x04, 0x78 },   // n
308
    { 0x38, 0x44, 0x44, 0x44, 0x38 },   // o
309
    { 0x7C, 0x14, 0x14, 0x14, 0x08 },   // p
310
    { 0x08, 0x14, 0x14, 0x18, 0x7C },   // q
311
    { 0x7C, 0x08, 0x04, 0x04, 0x08 },   // r
312
    { 0x48, 0x54, 0x54, 0x54, 0x20 },   // s
313
    { 0x04, 0x3F, 0x44, 0x40, 0x20 },   // t
314
    { 0x3C, 0x40, 0x40, 0x20, 0x7C },   // u
315
    { 0x1C, 0x20, 0x40, 0x20, 0x1C },   // v
316
    { 0x3C, 0x40, 0x30, 0x40, 0x3C },   // w
317
    { 0x44, 0x28, 0x10, 0x28, 0x44 },   // x
318
    { 0x0C, 0x50, 0x50, 0x50, 0x3C },   // y
319
    { 0x44, 0x64, 0x54, 0x4C, 0x44 },    // z
320
    { 0x00, 0x08, 0x36, 0x41, 0x41 },   // {
321
    { 0x00, 0x00, 0x7F, 0x00, 0x00 },   // |
322
    { 0x41, 0x41, 0x36, 0x08, 0x00 },   // }
323
    { 0x02, 0x01, 0x01, 0x02, 0x01 },   // ~
324
    { 0x55, 0x2A, 0x55, 0x2A, 0x55 },   // del
325
};
326

  
327

  
328
/**
329
 * @defgroup lcd LCD
330
 * @brief Functions for the LCD
331
 * Functions for writing to the LCD.
332
 * All functions may be found in lcd.h.
333
 *
334
 * @{
335
 **/
336

  
337
/**
338
 * Initializes the LCD. Must be called before any other
339
 * LCD functions.
340
 **/
341
void lcd_init(void)
342
{
343
	LCDDDR |= (SCE | SDI | SCK);
344
	LCDRESETDDR |= (RST|D_C);
345

  
346
	LCDPORT &= ~( SCE | SDI | SCK);
347
	LCDRESETPORT &=~(D_C);
348
  
349
	SPCR |= 0x50;//0b01010000; // no SPI int, SPI en, Master, sample on rising edge, fosc/2
350
	SPSR |= 0x01;       // a continuation of the above
351

  
352
	LCDRESETPORT |= RST;
353
	delay_ms(10);
354
	LCDRESETPORT &= (~RST);
355
	delay_ms(100);
356
	LCDRESETPORT |= RST;
357
	
358
    lcd_putbyte( 0x21 );  // LCD Extended Commands.
359
    lcd_putbyte( 0xC8 );  // Set LCD Vop (Contrast).
360
    lcd_putbyte( 0x06 );  // Set Temp coefficent.
361
    lcd_putbyte( 0x13 );  // LCD bias mode 1:48.
362
    lcd_putbyte( 0x20 );  // LCD Standard Commands, Horizontal addressing mode.
363
    lcd_putbyte( 0x0C );  // LCD in normal mode.
364
	
365
	LCDRESETPORT |= D_C;		//put it in init instead of main
366
	
367
	lcd_clear_screen();
368
}
369

  
370
/**
371
 * Clears the LCD screen. lcd_init must be called first.
372
 * 
373
 * @see lcd_init
374
 **/
375
void lcd_clear_screen( void ) {
376
	int i;
377
	for (i = 0; i < 504; i++)
378
			lcd_putbyte(0x0);
379
	
380
	lcd_gotoxy(0,0);
381
}
382

  
383
/**
384
 * Prints a character on the LCD screen. lcd_init
385
 * must be called before this function may be used.
386
 *
387
 * @param c the character to print
388
 *
389
 * @see lcd_init
390
 **/
391
void lcd_putc(char c)
392
{
393
	int i;
394
	
395
	for (i = 0; i < 5; i++)
396
		lcd_putbyte(FontLookup[c-32][i]);
397
	lcd_putbyte(0);
398
}
399

  
400
/*
401
print an entire string to the lcd
402
*/
403
void lcd_puts(char *s)
404
{
405
	char *t = s;
406
	while (*t != 0)
407
	{
408
		lcd_putc(*t);
409
		t++;
410
	}
411
}
412

  
413
/*
414
go to coordinate x, y
415
y: vertically - 1 char
416
x: horizontally - 1 pixel
417

  
418
multiply x by 6 if want to move 1 entire character
419

  
420
origin (0,0) is at top left corner of lcd screen
421
*/
422
/**
423
 * Move the current cursor position to the one specified.
424
 * lcd_init must be called before this function may be used.
425
 * 
426
 * @param x The x coordinate of the new position
427
 * @param y The y coordinate of the new position
428
 *
429
 * @see lcd_init
430
 **/
431
void lcd_gotoxy(int x, int y)
432
{
433
  LCDRESETPORT &= ~(D_C);
434
  lcd_putbyte(0x40 | (y & 0x07));
435
  lcd_putbyte(0x80 | (x & 0x7f));
436
  LCDRESETPORT |= D_C;
437
}
438

  
439
/*
440
prints an int to the lcd
441

  
442
code adapted from Chris Efstathiou's code (hendrix@otenet.gr)
443
*/
444
/**
445
 * Print an integer to the LCD screen.
446
 * lcd_init must be called before this function may be used.
447
 * 
448
 * @param value the integer to print
449
 *
450
 * @see lcd_init
451
 **/
452
void lcd_puti(int value ) {
453
	unsigned char lcd_data[6]={'0','0','0','0','0','0' }, position=sizeof(lcd_data), radix=10; 
454

  
455
        /* convert int to ascii  */ 
456
        if(value<0) { lcd_putc('-'); value=-value; }    
457
        do { position--; *(lcd_data+position)=(value%radix)+'0'; value/=radix;  } while(value); 
458

  
459
    
460
        /* start displaying the number */
461
        for(;position<=(sizeof(lcd_data)-1);position++)
462
          {
463
            
464
            lcd_putc(lcd_data[position]);
465
          }
466

  
467
	return;
468
}
469

  
470
/** @} **/ //end defgroup
471

  
472
void lcd_putbyte(unsigned char b)
473
{
474
	SPDR = b;
475
	while (!(SPSR & 0x80)); /* Wait until SPI transaction is complete */
476
}
477

  
trunk/code/projects/libdragonfly/Doxyfile
1
# Doxyfile 1.4.7
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           = libdragonfly
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
... This diff was truncated because it exceeds the maximum size that can be displayed.

Also available in: Unified diff