Revision 8
Added libdragonfly project folder.
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 |
Also available in: Unified diff