Project

General

Profile

Revision 1444

committed using svnmucc

View differences:

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

  
26

  
27
/**
28
 * @file motor.h
29
 * @brief Contains definitions for controlling the motors
30
 *
31
 * Contains definitions and functions for controlling
32
 * the motors.
33
 *
34
 * @author Colony Project, CMU Robotics Club
35
 * Based on Tom Lauwer's Firefly Library
36
 **/
37

  
38
#ifndef _MOTOR_H
39
#define _MOTOR_H
40

  
41
#include <avr/io.h>
42
/**
43
 * @addtogroup motors
44
 * @{
45
 **/
46

  
47
/** @brief make the motors go forwards **/
48
#define FORWARD 1
49
/** @brief make the motors go backwards **/
50
#define BACKWARD 0
51

  
52
/** @brief Initialize the motors **/
53
void motors_init(void);
54
/** @brief Set speed and direction of motor1 
55
 *  @deprecated use the left motor function instead. it's more intuitive and easier to read.**/
56
void motor1_set(int direction, int speed);
57
/** @brief Set speed and direction of motor2 
58
 *  @deprecated use the right motor function instead. it's more intuitive and easier to read.**/
59
void motor2_set(int direction, int speed);
60
/** @brief Set speed and direction of left motor **/
61
void motor_l_set(int direction, int speed);
62
/** @brief Set speed and direction of right motor **/
63
void motor_r_set(int direction, int speed);
64
/** @brief Turn the motors off **/
65
void motors_off(void);
66

  
67
/**@}**/ // end addtogroup
68

  
69
#endif
70

  
branches/colonetmk2/code/lib/include/libdragonfly/encoders.h
1
/**
2
 * 
3
 * @file encoders.h
4
 * @brief Contains functions for reading encoder values.
5
 *
6
 * Contains high and low level functions for reading encoders
7
 * including reading out total distance covered, and 
8
 * eventually velocity.
9
 *	
10
 * @author Colony Project, CMU Robotics Club
11
*/
12

  
13
/**
14
 * @addtogroup encoders
15
 * @{
16
 **/
17

  
18
#ifndef __ENCODERS_H__
19
#define __ENCODERS_H__
20

  
21

  
22
#ifndef LEFT
23
	/** @brief Left wheel **/
24
	#define LEFT 0
25
#endif
26
#ifndef RIGHT
27
	/** @brief Right wheel **/
28
	#define RIGHT 1
29
#endif
30

  
31
/** @brief Max value of valid encoder reading. **/
32
#define ENCODER_MAX 1024
33

  
34
/** @brief Magnet misaligned - likely distance from encoder problem. **/
35
#define ENCODER_MAGNET_FAILURE 1025
36
/** @brief Encoder misaligned - likely on XY plane. **/
37
#define ENCODER_MISALIGNED 1027
38
/** @brief Not enough time has passed - encoders not initialized in hardware. **/
39
#define ENCODER_DATA_NOT_READY 1026
40

  
41
/** @brief delay_ms argument after a full read is complete **/
42
#define ENCODER_DELAY 20
43

  
44
//Data invalid flags (hardware failure):
45
#define OCF _BV(4)
46
#define COF _BV(3)
47

  
48
//Data invalid alarm (May be invalid):
49
#define LIN _BV(2)
50

  
51
#define MagINCn _BV(1)
52
#define MagDECn _BV(0)
53

  
54
/** @brief Buffer size **/
55
#define BUFFER_SIZE 46
56

  
57
#define ERR_VEL 1024
58

  
59
/** @brief Initialize encoders. **/
60
void encoders_init(void);
61
/** @brief Read instantaneous encoder value. **/
62
int encoder_read(char encoder);
63

  
64
/** @brief Get total distance traveled.
65
 *  @note  Simply calls encoder_get_dx.
66
 **/
67
int encoder_get_x(char encoder);
68

  
69
/** @brief Get instantaneous velocity. **/
70
int encoder_get_v(char encoder);
71

  
72
/** @brief Get total distance traveled. **/
73
int encoder_get_dx(char encoder);
74
/** @brief Reset distance counter. **/
75
void encoder_rst_dx(char encoder);
76
/** @brief Get time count: The number of encoder reads that have occurred. **/
77
int encoder_get_tc(void);
78
/** @brief Reset the time count. **/
79
void encoder_rst_tc(void);
80

  
81
/** @brief Waits for the next n encoder reading, then returns. **/
82
void encoder_wait( int nReadings );
83

  
84
/**@}**/ //end group
85

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

  
26

  
27
/**
28
 * @file dragonfly_lib.h
29
 * @brief Contains other include files
30
 * 
31
 * Include this file for all the functionality of libdragonfly.
32
 *
33
 * @author Colony Project, CMU Robotics Club
34
 **/
35

  
36
#ifndef _DRAGONFLY_LIB_H_
37
#define _DRAGONFLY_LIB_H_
38

  
39
/**
40
 * @addtogroup dragonfly
41
 * @{
42
 **/
43

  
44
// Configuration definitions
45
/** @brief Initialize analog **/
46
#define ANALOG 0x01
47
/** @brief Initialize serial communications **/
48
#define SERIAL 0x02
49
/** @brief Initialize USB communications **/
50
#define USB    0x02
51
/** @brief Initialize communications **/
52
#define COMM   0x02
53
/** @brief Initialize the orb **/
54
#define ORB    0x04
55
/** @brief Initialize the motors **/
56
#define MOTORS 0x08
57
/** @brief Initialize I2C **/
58
#define I2C    0x20
59
/** @brief Initialize the buzzer **/
60
#define BUZZER 0x40
61
/** @brief Initialize the LCD screen **/
62
#define LCD    0x80
63
/** @brief Initialize the rangefinders **/
64
#define RANGE  0x0100
65
/** @brief Initialize the BOM **/
66
#define BOM  0x0200
67
/** @brief Initilize encoders **/
68
#define ENCODERS 0x400
69
/** @brief Initialize everything  **/
70
#define ALL_ON 0x07FF
71

  
72
/** @brief Initialize the board **/
73
void dragonfly_init(int config);
74

  
75
/** @} **/ //end addtogroup
76

  
77
#include <inttypes.h>
78
#include <stdio.h>
79
#include <stdlib.h>
80
#include <avr/io.h>
81
#include <avr/interrupt.h>
82
#include <util/delay.h>
83
#include <util/twi.h>
84

  
85
// This file is included from the libdragonfly directory because it seems to be
86
// missing from the AVR libc distribution.
87
#include "atomic.h"
88

  
89
#include <analog.h>
90
#include <dio.h>
91
#include <time.h>
92
#include <lcd.h>
93
#include <lights.h>
94
#include <motor.h>
95
#include <serial.h>
96
#include <buzzer.h>
97
#include <rangefinder.h>
98
#include <bom.h>
99
#include <encoders.h>
100
#include <move.h>
101
#include <reset.h>
102
#include <math.h>
103
#include <eeprom.h>
104
#include <stdbool.h>
105

  
106
/** @brief shortcut for ATOMIC_BLOCK(ATOMIC_RESTORESTATE) **/
107
#define SYNC ATOMIC_BLOCK(ATOMIC_RESTORESTATE)
108

  
109
/** @brief atomically grab a lock if it is free, return otherwise **/
110
#define REQUIRE_LOCK_OR_RETURN(LOCK) do { SYNC { if (LOCK) return; LOCK=1; } } while (0)
111

  
112
/** @brief atomically release a lock **/
113
#define RELEASE_LOCK(LOCK) do { LOCK=0; } while (0)
114

  
115

  
116

  
117
#endif
118

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

  
26

  
27
/**
28
 * @file bom.h
29
 * @brief Definitions for using the BOM
30
 * 
31
 * This file contains definitions for using the Bearing and 
32
 * Orientation Module (BOM).
33
 *
34
 * @author Colony Project, CMU Robotics Club
35
 *
36
 **/
37

  
38
#ifndef _BOM_H
39
#define _BOM_H
40

  
41
/**
42
 * @addtogroup bom
43
 * @{
44
 **/
45
 
46
/** @brief Include all elements in the 16-bit bitfield **/
47
#define BOM_ALL 0xFFFF
48

  
49
/** @brief Original BOM - No Range, No Individual LED control **/
50
#define BOM10     0
51

  
52
/** @brief BOM 1.5 - No Range, Individual LED control **/
53
#define BOM15   1
54

  
55
/** @brief RBOM - Range, Individual LED control **/
56
#define RBOM    2
57

  
58

  
59
/** @brief Initialize the bom according to bom type **/
60
void bom_init(char type);
61

  
62
/** @brief Refresh bom_val[] with new values from analog8.  analog_init and bom_init must be called for this to work. **/
63
void bom_refresh(int bit_field);
64

  
65
/** @brief Gets the bom reading from bom_val[which].  Call bom_refresh beforehand to read new bom values. **/
66
int bom_get(int which);
67

  
68
/** @brief Compares all the values in bom_val[] and returns the index to the highest value element. **/
69
int bom_get_max(void);
70

  
71
/** @brief Enables the selected bom leds on a BOM1.5 **/
72
void bom_set_leds(int bit_field);
73

  
74
/** @brief (DEPRECATED) Gets and compares all bom values.  Returns the index to the highest value element since last refresh. **/
75
int get_max_bom(void);
76

  
77
/** @brief Turns on all BOM leds, or turns on enabled leds on a BOM1.5. **/
78
void bom_on(void);
79

  
80
/** @brief Turns off all bom leds. **/
81
void bom_off(void);
82

  
83
/** @} **/
84

  
85
#endif
86

  
branches/colonetmk2/code/lib/include/libdragonfly/lights.h
1
// FIXME remove
2
typedef unsigned char uint8_t;
3

  
4

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

  
30

  
31
/**
32
 * @file lights.h
33
 * @brief Contains declarations for managing the orbs.
34
 *
35
 * Contains declarations for using the orbs and PWM.
36
 *
37
 * @author Colony Project, CMU Robotics Club
38
 * Based on Firefly Library, by Tom Lauwers and Steven Shamlian
39
 **/
40

  
41
#ifndef _LIGHTS_H_
42
#define _LIGHTS_H_
43

  
44
/**
45
 * @addtogroup orbs
46
 * @{
47
 **/
48

  
49
/**
50
 * Quick start: call orb_init_pwm or orb_init_binary, depending on which mode you want to use. Call orb*set or
51
 * orb*set_color to set the orbs.
52
 * 
53
 * The orbs have two modes of operation: PWM mode and binary mode. In PWM mode, a pwm signal is generated by a hardware
54
 * timer and the orbs can be set to a value of 0 through 255. In binary mode, the orbs can only be turned on or off and
55
 * a value of 0 means "off" and any other value means "on". The mode can be chosen on initialization and can be changed
56
 * at runtime using the orb_set_mode function.
57
 *
58
 * Operation (PWM mode): On timer overflow, all LEDs with a value>0 are turned on and the output compare value for the
59
 * first LED is loaded. On compare match, the corresponding LED is turned off and the next output compare value is
60
 * loaded. All masks are precomputed and sorted by time when setting the values.
61
 *
62
 * The data structure (pwm_t) containing the PWM times and masks is triple buffered. This is because the buffer the ISR
63
 * is reading from may only be modified on timer overflow before the next PWM sequence is started, because otherwise the
64
 * next OCR value might be sed to a value smaller than the current timer value, resulting in the remaining channels not
65
 * being turned off in that PWM period (flash to on). When using two buffers, the page flip can only occur on a timer
66
 * overflow for the same reason. So after writing a buffer and marking it for page flip, neither of the buffers could be
67
 * modified because the front buffer is read by the ISR and the back buffer could be switched at any time. So the
68
 * calling thread would have to be delayed by up to one full PWM period (8ms in the current implementation, but
69
 * 20ms-50ms would be a reasonable value to expect here). To avoid this, triple buffering is used.
70
 *
71
 * The code for applying the orbs is fairly optimized. See the apply_orbs function for some time measurements and
72
 * further nodes.
73
 *
74
 * The PWM frequency is 120Hz (8ms period time). The next lower frequency (determined by the prescaler) is 30 Hz which
75
 * is too slow (orbs flicker).
76
 *
77
 * The orbs code is thread safe, which means that the functions may be called from another interrupt handler. If there
78
 * are multiple concurrent calls to the orb*set* functions, one of them is ignored and the orbs are never left in an
79
 * inconsistent state. For example, if the orbs are set to green by the main thread and to red by an interrupt handler,
80
 * the resulting color will be either red or green, but never yellow.
81
 * Thread safety is achieved by grabbing a lock at the beginning of all functions that modify the orb code and releasing
82
 * the lock at the end. If the lock is already taken, the function just returns doing nothing.
83
 *
84
 * Some performance measurements:
85
 *   - Time for setting new orb values (PWM mode):       35us-72us (depending on the degree to which the array is
86
 *                                                                  already in the correct order)
87
 *   - Time for setting new orb values (binary mode):        5.5us
88
 *
89
 *   - Interrupt time (PWM mode only):                         8us (overflow)
90
 *                                                            10us (output compare)
91
 *                                                             6us (last output compare)
92
 *                                                            30us (output compare, all value equal)
93
 *
94
 *   - Maximum total interrupt time per period:               64us
95
 *   - Maximum CPU usage for interrupts (PWM mode only):     <0.8%
96
 *
97
 *   - Maximum contiguous synchronized block:                 30us (output compare interrupt, all values equal)
98
 *
99
 * There are some potential optimizations left. See the source code for more information.
100
 *
101
 * A note on robustness: if the output compare interrupt is disabled for too long, either due to a long ISR or a long
102
 * synchronized code block, the orbs will flicker to brighter values for being turned off too late. With software PWM,
103
 * there's nothing at all to be done about that. The problem can be alleviated by using a lower PWM frequency, but then
104
 * the orbs will start flickering all the time due to the low update frequency.
105
 * Some measurements: with 100us synchronized blocks, the flickering is accepptably low. Longer synchronized blocks
106
 * mean more flickering. At 1ms synchronized blocks, the flickering is quite bad, especially for low orb values. Note
107
 * that orb value 0 never flickers at all because the corresponding channels are not turned on at all.
108
 * Test code (note the _delay_us restrictions!)
109
 *   orb_set (1,1,1); while (1) { SYNC { for (uint8_t m=0; m<10; ++m) { _delay_us(10); } } }
110
 **/
111

  
112
/** @} **/ //end addtogroup
113

  
114
/**
115
 * @addtogroup orbs
116
 * @{
117
 **/
118

  
119
// ***** Predefined colors *****
120
/** @brief Red **/
121
#define RED       0xE0
122
/** @brief Orange **/
123
#define ORANGE    0xE4
124
/** @brief Yellow **/
125
#define YELLOW    0xE8
126
/** @brief Lime **/
127
#define LIME      0x68
128
/** @brief Green **/
129
#define GREEN     0x1C
130
/** @brief Cyan **/
131
#define CYAN      0x1F
132
/** @brief Blue **/
133
#define BLUE      0x03
134
/** @brief Pink **/
135
#define PINK      0xA6 
136
/** @brief Purple **/
137
#define PURPLE    0x41
138
/** @brief Magenta **/
139
#define MAGENTA   0xE3
140
/** @brief White **/
141
#define WHITE     0xFE
142
/** @brief Turn the orb off **/
143
#define ORB_OFF   0x00
144

  
145

  
146

  
147
// ***** Initialization *****
148

  
149
/** @brief Enables the orbs in default mode **/
150
void orb_init(void);
151

  
152
/** @brief Enables the orbs in binary mode **/
153
void orb_init_binary (void);
154

  
155
/** @brief Enables the orbs in PWM mode **/
156
void orb_init_pwm (void);
157

  
158

  
159

  
160
// ***** Mode setting *****
161

  
162
/** Specification of the orb mode **/
163
typedef uint8_t orb_mode_t;
164

  
165
/** @brief PWM mode **/
166
#define orb_mode_pwm 0
167

  
168
/** @brief Binary mode **/
169
#define orb_mode_binary 1
170

  
171

  
172
/** @brief Switches the orbs to the specified mode **/
173
void orb_set_mode (orb_mode_t mode);
174

  
175
/** @brief Disables the orb timer, but does not change the mode **/
176
void orb_disable_timer (void);
177

  
178
/** @brief Enables the orb timer, but does not change the mode **/
179
void orb_enable_timer (void);
180

  
181

  
182

  
183
// ***** Setting RGB colors *****
184

  
185
/** @brief set the specified orb to a specified color
186
* 	@deprecated This function indexes from 0 instead of 1 **/
187
void orb_n_set (uint8_t num, uint8_t red, uint8_t green, uint8_t blue);
188

  
189
/** @brief Set both orbs to a specified color **/
190
void orb_set(uint8_t red, uint8_t green, uint8_t blue);
191

  
192
/** @brief Set orb1 to a specified color **/
193
void orb1_set(uint8_t red_led, uint8_t green_led, uint8_t blue_led); 
194

  
195
/** @brief Set orb2 to a specified color **/
196
void orb2_set(uint8_t red_led, uint8_t green_led, uint8_t blue_led);
197

  
198
void orbs_set (uint8_t red1, uint8_t green1, uint8_t blue1, uint8_t red2, uint8_t green2, uint8_t blue2);
199

  
200

  
201

  
202
// ***** Settings predefined colors *****
203

  
204
/** @brief set the specified orb to the specified color
205
* 	@deprecated This function indexes from 0 instead of 1 **/
206
void orb_n_set_color(uint8_t num, uint8_t col);
207

  
208
/** @brief Set orb1 to a specified color **/
209
void orb1_set_color(uint8_t col);
210

  
211
/** @brief Set orb2 to a specified color **/
212
void orb2_set_color(uint8_t col);
213

  
214
/** @brief set the orbs to specified colors **/
215
void orbs_set_color(uint8_t col1, uint8_t col2);
216

  
217
/** @brief Set both orbs to a specified color **/
218
void orb_set_color(uint8_t col);
219

  
220

  
221

  
222
/** @} **/ //end addtogroup
223

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

  
26
/**
27
 * 
28
 * @file analog.h
29
 * @brief Contains functions and definitions for using the ADC
30
 * 
31
 * Contains definitions and function prototypes for using the
32
 * ADC to detect analog signals on pins AN0 - AN7.
33
 * AN6 and AN7 are used for the wheel and battery.
34
	
35
 * The pins labeled E6 and E7 are external interrupt pins and are not related 
36
 * to analog.
37
	
38
 * @author Colony Project, CMU Robotics Club, based on firefly
39
 * originally taken from fwr analog file (author: Tom Lauwers)
40
 * loop code written by Kevin Woo and James Kong
41
 */
42

  
43
#ifndef _ANALOG_H
44
#define _ANALOG_H
45

  
46
#include <inttypes.h>
47

  
48
/**
49
 * @addtogroup analog
50
 * @{
51
 **/
52

  
53
/** @brief Analog port 0 **/
54
#define AN0 0x00
55
/** @brief Analog port 1 **/
56
#define AN1 0x01
57
/** @brief Analog port 2 **/
58
#define AN2 0x02
59
/** @brief Analog port 3 **/
60
#define AN3 0x03
61
/** @brief Analog port 4 **/
62
#define AN4 0x04
63
/** @brief Analog port 5 **/
64
#define AN5 0x05
65
/** @brief Analog port 6 **/
66
#define AN6 0x06
67
/** @brief Analog port 7 **/
68
#define AN7 0x07
69
/** @brief Analog port 8 **/
70
#define AN8 0x08
71
/** @brief Analog port 9 **/
72
#define AN9 0x09
73
/** @brief Analog port 10 **/
74
#define AN10 0x0A
75
/** @brief Analog port 11 **/
76
#define AN11 0x0B
77
/** @brief Analog port 12 **/
78
#define AN12 0x0C
79
/** @brief Analog port 13 **/
80
#define AN13 0x0D
81
/** @brief Analog port 14 **/
82
#define AN14 0x0E
83
/** @brief Analog port 15 **/
84
#define AN15 0x0F
85

  
86
/** @brief BOM_PORT analog port for BOM **/
87
#define BOM_PORT AN0
88
/** @brief EXT_MUX analog port **/
89
#define EXT_MUX AN7
90
/** @brief Analog port for the wheel **/
91
#define WHEEL_PORT AN10
92
/** @brief Analog port for the battery voltage detector **/
93
#define BATT_PORT  AN11
94

  
95
/** @brief Analog loop status. ADC conversion running. **/
96
#define ADC_LOOP_RUNNING 1
97
/** @brief Analog loop status.  No ADC conversion running.**/
98
#define ADC_LOOP_STOPPED 0
99

  
100
/** @brief Analog init parameter. Start the analog loop. **/
101
#define ADC_START 1
102
/** @brief Analog init parameter. Don't start the analog loop. **/
103
#define ADC_STOP  0
104

  
105
#define ADMUX_OPT 0x60
106

  
107
/** @brief Struct to hold the value of a particular analog port **/
108
typedef struct {
109
  uint8_t adc8;
110
  uint16_t adc10;
111
} adc_t;
112

  
113

  
114
/** @brief Initialize analog ports. Will start running a loop
115
    if start_conversion is ADC_START.**/
116
void analog_init(int start_conversion);
117
/** @brief starts the analog loop. Doesn't do anything if the loop is already running. **/
118
void analog_start_loop(void);
119
/** @brief Stops the analog loop. Doesn't do anything if the loop is already stopped. **/
120
void analog_stop_loop(void);
121
/** @brief Returns the status of the analog loop. **/
122
int analog_loop_status(void);
123
/** @brief Returns an 8-bit analog value from the look up table. Use this instead of analog_get8. **/
124
unsigned int analog8(int which);
125
/** @brief Returns an 10-bit analog value from the look up table. Use this instead of analog_get10. **/
126
unsigned int analog10(int which);
127
/** @brief Read the position of the wheel. **/
128
int wheel(void);
129
/** @brief Read an 8-bit number from an analog port. Loop must be stopped for this to work. **/
130
unsigned int analog_get8(int which);
131
/** @brief Read a 10-bit number from an analog port. Loop must be stopped for this to work. **/
132
unsigned int analog_get10(int which);
133

  
134

  
135
/**@}**/ //end group
136

  
137
#endif
138

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

  
26

  
27
/**
28
 * @file rangefinder.h
29
 * @brief Contains rangefinder declarations and functions
30
 * 
31
 * Contains functions and definitions for the use of
32
 * IR rangefinders.
33
 *
34
 * @author Colony Project, CMU Robotics Club
35
 **/
36

  
37
#ifndef _RANGEFINDER_H_
38
#define _RANGEFINDER_H_
39

  
40
/**
41
 * @addtogroup rangefinder
42
 * @{
43
 **/
44

  
45
/** @brief IR Rangefinder 1 **/
46
#define IR1 6
47
/** @brief IR Rangefinder 2 **/
48
#define IR2 5
49
/** @brief IR Rangefinder 3 **/
50
#define IR3 4
51
/** @brief IR Rangefinder 4 **/
52
#define IR4 3
53
/** @brief IR Rangefinder 5 **/
54
#define IR5 2
55
/** @brief smallest meaningful rangefinder reading (logarithmic scale) **/
56
#define MIN_IR_ADC8 20
57
/** @brief largest meaningful rangefinder reading (logarithmic scale) **/
58
#define MAX_IR_ADC8 133
59

  
60
/** @brief Initialize the rangefinders **/
61
void range_init(void);
62
/** @brief Read the distance from a rangefinder **/
63
int range_read_distance(int range_id);
64
/** @brief Convert logarithmic-scale distance readings to a linear scale **/
65
int linearize_distance(int value);
66

  
67
/** @} **/ //end addtogroup
68

  
69
#endif
70

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

  
26

  
27
/**
28
 * @file serial.h
29
 * @brief Contains declarations for serial input and output
30
 *
31
 * Contains definitions for serial input and output.
32
 *
33
 * @author Colony Project, CMU Robotics Club
34
 * Based on Tom Lauwer's Firefly Library
35
 *
36
 **/
37

  
38
/*
39
  serial.h - Contains definitions and function prototypes for the RS232 serial port
40
  author(s): pkv
41
  
42
  Directions:
43
  Call the initialization function for the serial port you wish to use.  Then, use
44
  either the provided functions or the stdio functions (fprintf, etc) to read and
45
  write characters to the serial ports.
46
  
47
  UART Mapping:
48
  usb_*() -> UART0
49
  xbee_*() -> UART1
50
  
51
  Options: (Add the following defines to your code to configure this library)
52
  #define USB_BAUD { 115200 | 9600 } <= pick ONE value from in here
53
  #define XBEE_BAUD { 115200 | 9600 } <= pick ONE value from in here
54
  #define USE_STDIO
55
  
56
  Note: If you enable USE_STDIO, the first init function that is called will 
57
  automatically be linked to stdin, stdout, and stderr.  To use the baud rate 
58
  commands, add something like the following to your code:
59
  
60
  #define FOO_BAUD 9600
61
  
62
  **UNLESS YOU KNOW WHAT YOU ARE DOING, PLEASE DO NOT CHANGE THIS FILE**
63
  Many, many other people use this file in their code.  If you change it, you will
64
  probably break all of their nice code.  You should not need to change anything in
65
  here, except to accomodate new hardware.
66
*/
67

  
68
#ifndef _SERIAL_H
69
#define _SERIAL_H
70

  
71
#include <inttypes.h>
72
#include <avr/pgmspace.h>
73

  
74
/**
75
 * @defgroup usb USB Input / Output
76
 * @brief Functions for USB input / output
77
 *
78
 * Low level functions for USB input and output.
79
 *
80
 * @{
81
 **/
82

  
83
// if no baud rate is defined for usb, default is set here
84
#ifndef USB_BAUD
85
/** @brief the USB baud rate **/
86
#define USB_BAUD 115200
87
#endif
88

  
89
/** @brief Initialize the USB **/
90
void usb_init(void);
91
/** @brief Print a character to USB **/
92
int usb_putc(char c);
93
/** @brief Read a character from USB **/
94
int usb_getc(void);
95
/** @brief Read a character from USB without blocking **/
96
int usb_getc_nb(char *c);
97
/** @brief Print a string to USB **/
98
int usb_puts(char *s);
99
/** @brief Print a string from program space to USB **/
100
void usb_puts_P (PGM_P s);
101
/** @brief Print an integer to USB **/
102
int usb_puti(int value);
103
/** @brief Determine a hexadecimal digit **/
104
uint8_t hex_digit (uint8_t value);
105
/** @brief Print a fixed width hexadecimal representation to USB **/
106
void usb_puth16 (uint16_t value);
107
/** @brief Print a fixed width hexadecimal representation to USB **/
108
void usb_puth8(uint8_t value);
109
/** @brief Alias for usb_puth16 **/
110
static inline void usb_puth (uint16_t value) { usb_puth16 (value); };
111

  
112

  
113
/** @} **/ //end addtogroup
114

  
115
/**
116
 * @defgroup xbee XBee Input / Output
117
 * @brief Functions for XBee input / output
118
 *
119
 * Low level functions for XBee input and output.
120
 *
121
 * @{
122
 **/
123

  
124
// if no baud rate is defined for usb, default is set here
125

  
126
// if no baud rate is defined for xbee, default is set here
127
#ifndef XBEE_BAUD
128
/** @brief the XBee baud rate **/
129
#define XBEE_BAUD 9600
130
#endif
131

  
132
/** @brief Initialize the XBee **/
133
void xbee_init(void);
134
/** @brief Print a character to the XBee **/
135
int xbee_putc(char c);
136
/** @brief Read a character from the XBee **/
137
int xbee_getc(void);
138
/** @brief Read a character from the XBee without blocking **/
139
int xbee_getc_nb(char *c);
140

  
141

  
142

  
143
/** @} **/ //end addtogroup
144

  
145
#endif
146

  
branches/colonetmk2/code/lib/include/libdragonfly/atomic.h
1
/* This file is in the dragonfly library directory because it seems to be
2
   missing from the AVR libc distribution */
3
   
4
/* Copyright (c) 2007 Dean Camera
5
   All rights reserved.
6

  
7
   Redistribution and use in source and binary forms, with or without
8
   modification, are permitted provided that the following conditions are met:
9

  
10
   * Redistributions of source code must retain the above copyright
11
     notice, this list of conditions and the following disclaimer.
12

  
13
   * Redistributions in binary form must reproduce the above copyright
14
     notice, this list of conditions and the following disclaimer in
15
     the documentation and/or other materials provided with the
16
     distribution.
17

  
18
   * Neither the name of the copyright holders nor the names of
19
     contributors may be used to endorse or promote products derived
20
     from this software without specific prior written permission.
21

  
22
  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
23
  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24
  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25
  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
26
  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
27
  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
28
  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
29
  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
30
  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
31
  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
32
  POSSIBILITY OF SUCH DAMAGE.
33
*/
34

  
35
/* $Id: atomic.h,v 1.3 2007/12/20 14:17:56 joerg_wunsch Exp $ */
36

  
37
#ifndef _UTIL_ATOMIC_H_
38
#define _UTIL_ATOMIC_H_ 1
39

  
40
#include <avr/io.h>
41
#include <avr/interrupt.h>
42

  
43
#if !defined(__DOXYGEN__)
44
/* Internal helper functions. */
45
static __inline__ uint8_t __iSeiRetVal(void)
46
{
47
    sei();
48
    return 1;
49
}
50

  
51
static __inline__ uint8_t __iCliRetVal(void)
52
{
53
    cli();
54
    return 1;
55
}
56

  
57
static __inline__ void __iSeiParam(const uint8_t *__s)
58
{
59
    sei();
60
    __asm__ volatile ("" ::: "memory");
61
    (void)__s;
62
}
63

  
64
static __inline__ void __iCliParam(const uint8_t *__s)
65
{
66
    cli();
67
    __asm__ volatile ("" ::: "memory");
68
    (void)__s;
69
}
70

  
71
static __inline__ void __iRestore(const  uint8_t *__s)
72
{
73
    SREG = *__s;
74
    __asm__ volatile ("" ::: "memory");
75
}
76
#endif	/* !__DOXYGEN__ */
77

  
78
/** \file */
79
/** \defgroup util_atomic <util/atomic.h> Atomically and Non-Atomically Executed Code Blocks
80

  
81
    \code
82
    #include <util/atomic.h>
83
    \endcode
84

  
85
    \note The macros in this header file require the ISO/IEC 9899:1999
86
    ("ISO C99") feature of for loop variables that are declared inside
87
    the for loop itself.  For that reason, this header file can only
88
    be used if the standard level of the compiler (option --std=) is
89
    set to either \c c99 or \c gnu99.
90

  
91
    The macros in this header file deal with code blocks that are
92
    guaranteed to be excuted Atomically or Non-Atmomically.  The term
93
    "Atomic" in this context refers to the unability of the respective
94
    code to be interrupted.
95

  
96
    These macros operate via automatic manipulation of the Global
97
    Interrupt Status (I) bit of the SREG register. Exit paths from
98
    both block types are all managed automatically without the need
99
    for special considerations, i. e. the interrupt status will be
100
    restored to the same value it has been when entering the
101
    respective block.
102

  
103
    A typical example that requires atomic access is a 16 (or more)
104
    bit variable that is shared between the main execution path and an
105
    ISR.  While declaring such a variable as volatile ensures that the
106
    compiler will not optimize accesses to it away, it does not
107
    guarantee atomic access to it.  Assuming the following example:
108

  
109
    \code
110
#include <inttypes.h>
111
#include <avr/interrupt.h>
112
#include <avr/io.h>
113

  
114
volatile uint16_t ctr;
115

  
116
ISR(TIMER1_OVF_vect)
117
{
118
  ctr--;
119
}
120

  
121
...
122
int
123
main(void)
124
{
125
   ...
126
   ctr = 0x200;
127
   start_timer();
128
   while (ctr != 0)
129
     // wait
130
       ;
131
   ...
132
}
133
    \endcode
134

  
135
    There is a chance where the main context will exit its wait loop
136
    when the variable \c ctr just reached the value 0xFF.  This happens
137
    because the compiler cannot natively access a 16-bit variable
138
    atomically in an 8-bit CPU.  So the variable is for example at
139
    0x100, the compiler then tests the low byte for 0, which succeeds.
140
    It then proceeds to test the high byte, but that moment the ISR
141
    triggers, and the main context is interrupted.  The ISR will
142
    decrement the variable from 0x100 to 0xFF, and the main context
143
    proceeds.  It now tests the high byte of the variable which is
144
    (now) also 0, so it concludes the variable has reached 0, and
145
    terminates the loop.
146

  
147
    Using the macros from this header file, the above code can be
148
    rewritten like:
149

  
150
    \code
151
#include <inttypes.h>
152
#include <avr/interrupt.h>
153
#include <avr/io.h>
154
#include <util/atomic.h>
155

  
156
volatile uint16_t ctr;
157

  
158
ISR(TIMER1_OVF_vect)
159
{
160
  ctr--;
161
}
162

  
163
...
164
int
165
main(void)
166
{
167
   ...
168
   ctr = 0x200;
169
   start_timer();
170
   sei();
171
   uint16_t ctr_copy;
172
   do
173
   {
174
     ATOMIC_BLOCK(ATOMIC_FORCEON)
175
     {
176
       ctr_copy = ctr;
177
     }
178
   }
179
   while (ctr_copy != 0);
180
   ...
181
}
182
    \endcode
183

  
184
    This will install the appropriate interrupt protection before
185
    accessing variable \c ctr, so it is guaranteed to be consistently
186
    tested.  If the global interrupt state were uncertain before
187
    entering the ATOMIC_BLOCK, it should be executed with the
188
    parameter ATOMIC_RESTORESTATE rather than ATOMIC_FORCEON.
189

  
190
*/
191

  
192
/** \def ATOMIC_BLOCK(type)
193
    \ingroup util_atomic
194

  
195
    Creates a block of code that is guaranteed to be executed
196
    atomically. Upon entering the block the Global Interrupt Status
197
    flag in SREG is disabled, and re-enabled upon exiting the block
198
    from any exit path.
199

  
200
    Two possible macro parameters are permitted, ATOMIC_RESTORESTATE
201
    and ATOMIC_FORCEON.
202
*/
203
#if defined(__DOXYGEN__)
204
#define ATOMIC_BLOCK(type)
205
#else
206
#define ATOMIC_BLOCK(type) for ( type, __ToDo = __iCliRetVal(); \
207
	                       __ToDo ; __ToDo = 0 )
208
#endif	/* __DOXYGEN__ */
209

  
210
/** \def NONATOMIC_BLOCK(type)
211
    \ingroup util_atomic
212

  
213
    Creates a block of code that is executed non-atomically. Upon
214
    entering the block the Global Interrupt Status flag in SREG is
215
    enabled, and disabled upon exiting the block from any exit
216
    path. This is useful when nested inside ATOMIC_BLOCK sections,
217
    allowing for non-atomic execution of small blocks of code while
218
    maintaining the atomic access of the other sections of the parent
219
    ATOMIC_BLOCK.
220

  
221
    Two possible macro parameters are permitted,
222
    NONATOMIC_RESTORESTATE and NONATOMIC_FORCEOFF.
223
*/
224
#if defined(__DOXYGEN__)
225
#define NONATOMIC_BLOCK(type)
226
#else
227
#define NONATOMIC_BLOCK(type) for ( type, __ToDo = __iSeiRetVal(); \
228
	                          __ToDo ;  __ToDo = 0 )
229
#endif	/* __DOXYGEN__ */
230

  
231
/** \def ATOMIC_RESTORESTATE
232
    \ingroup util_atomic
233

  
234
    This is a possible parameter for ATOMIC_BLOCK. When used, it will
235
    cause the ATOMIC_BLOCK to restore the previous state of the SREG
236
    register, saved before the Global Interrupt Status flag bit was
237
    disabled. The net effect of this is to make the ATOMIC_BLOCK's
238
    contents guaranteed atomic, without changing the state of the
239
    Global Interrupt Status flag when execution of the block
240
    completes.
241
*/
242
#if defined(__DOXYGEN__)
243
#define ATOMIC_RESTORESTATE
244
#else
245
#define ATOMIC_RESTORESTATE uint8_t sreg_save \
246
	__attribute__((__cleanup__(__iRestore))) = SREG
247
#endif	/* __DOXYGEN__ */
248

  
249
/** \def ATOMIC_FORCEON
250
    \ingroup util_atomic
251

  
252
    This is a possible parameter for ATOMIC_BLOCK. When used, it will
253
    cause the ATOMIC_BLOCK to force the state of the SREG register on
254
    exit, enabling the Global Interrupt Status flag bit. This saves on
255
    flash space as the previous value of the SREG register does not
256
    need to be saved at the start of the block.
257

  
258
    Care should be taken that ATOMIC_FORCEON is only used when it is
259
    known that interrupts are enabled before the block's execution or
260
    when the side effects of enabling global interrupts at the block's
261
    completion are known and understood.
262
*/
263
#if defined(__DOXYGEN__)
264
#define ATOMIC_FORCEON
265
#else
266
#define ATOMIC_FORCEON uint8_t sreg_save \
267
	__attribute__((__cleanup__(__iSeiParam))) = 0
268
#endif	/* __DOXYGEN__ */
269

  
270
/** \def NONATOMIC_RESTORESTATE
271
    \ingroup util_atomic
272

  
273
    This is a possible parameter for NONATOMIC_BLOCK. When used, it
274
    will cause the NONATOMIC_BLOCK to restore the previous state of
275
    the SREG register, saved before the Global Interrupt Status flag
276
    bit was enabled. The net effect of this is to make the
277
    NONATOMIC_BLOCK's contents guaranteed non-atomic, without changing
278
    the state of the Global Interrupt Status flag when execution of
279
    the block completes.
280
*/
281
#if defined(__DOXYGEN__)
282
#define NONATOMIC_RESTORESTATE
283
#else
284
#define NONATOMIC_RESTORESTATE uint8_t sreg_save \
285
	__attribute__((__cleanup__(__iRestore))) = SREG
286
#endif	/* __DOXYGEN__ */
287

  
288
/** \def NONATOMIC_FORCEOFF
289
    \ingroup util_atomic
290

  
291
    This is a possible parameter for NONATOMIC_BLOCK. When used, it
292
    will cause the NONATOMIC_BLOCK to force the state of the SREG
293
    register on exit, disabling the Global Interrupt Status flag
294
    bit. This saves on flash space as the previous value of the SREG
295
    register does not need to be saved at the start of the block.
296

  
297
    Care should be taken that NONATOMIC_FORCEOFF is only used when it
298
    is known that interrupts are disabled before the block's execution
299
    or when the side effects of disabling global interrupts at the
300
    block's completion are known and understood.
301
*/
302
#if defined(__DOXYGEN__)
303
#define NONATOMIC_FORCEOFF
304
#else
305
#define NONATOMIC_FORCEOFF uint8_t sreg_save \
306
	__attribute__((__cleanup__(__iCliParam))) = 0
307
#endif	/* __DOXYGEN__ */
308

  
309
#endif
branches/colonetmk2/code/lib/include/libdragonfly/eeprom.h
1
/**
2
 * @file eeprom.h
3
 * @brief handles eeprom storage for persistent data
4
 *
5
 * Contains functions and definitions for reading and writing to eeprom
6
 *
7
 * @author Colony Project, Brad Neuman
8
 */
9
 
10
 #ifndef _EEPROM_H_
11
 #define _EEPROM_H_
12
 
13
 #include <bom.h>
14
 
15
 #define EEPROM_ROBOT_ID_ADDR 0x10
16
 #define EEPROM_BOM_TYPE_ADDR 0x14
17
 
18
 /** @brief store a byte to eeproem
19
  *  @return 0 if success, nonzero on failure
20
  */
21
 int eeprom_put_byte(unsigned int addr, unsigned char byte);
22
 
23
 /** @brief reads a byte from eeprom
24
  *
25
  *  Pass it thge address and a pointer to a byte where the byte at the
26
  *  address will be stored
27
  *
28
  *  @return 0 if successful (byte is set to the eeprom value at addr), 
29
  *  nonzero if there was a problem
30
   */
31
 int eeprom_get_byte(unsigned int addr, unsigned char *byte);
32
 
33
 /** @brief get stored robot ID
34
  *
35
  *  checks that EEPROM has been programed with an ID and returns it
36
  *
37
  *  @return the robot id, if it is stored. If it returns 0xFF it is probably invalid
38
  */
39
 unsigned char get_robotid(void);
40
  
41
   /** @brief get stored robot ID
42
  *
43
  * checks that EEPROM has been programed with an BOM type and returns it
44
  *
45
  *  @return the robot bom type as defined in bom.h, if it is stored. If it returns 0xFF it is probably invalid
46
  */
47
 unsigned char get_bom_type(void);
48
 
49
 #endif
branches/colonetmk2/code/lib/include/libdragonfly/odometry.h
1

  
2
/**
3
 * @file odometry.h
4
 * @brief Code for estimating the robots pose.
5
 * 
6
 * Offers simple position and orientation information.
7
 *
8
 * @author Colony Project, CMU Robotics Club
9
 **/
10

  
11
#ifndef __ODOMETRY_C__
12
#define __ODOMETRY_C__
13

  
14
/**
15
 * @addtogroup odometry 
16
 * @{
17
 **/
18

  
19
//Odometry resolution, *64 microseconds.
20
#define ODOMETRY_CLK 255u 
21
#define TIME_SCALE 64
22

  
23
//Wheel = 2.613 in.  
24
//Circumference = 208.508133 mm
25
//Distance per encoder click (circumference / 1024)  = 203.621224 um.
26
//Robot width = 5.3745 in. = 136.5123 mm
27

  
28
#define ROBOT_WIDTH_UM 137000  //um
29
#define CLICK_DISTANCE_UM 204 //um
30

  
31
#define DISTANCE_SCALE 2.10526316 //Magic constant.
32
#define ANGLE_SCALE 1.12823207 //Magic constant.
33

  
34
/** @brief Retrieve the robots estimated x position*/
35
long odometry_dx(void);
36

  
37
/** @brief Retrieve the robots estimated y position*/
38
long odometry_dy(void);
39

  
40
/** @brief Retrieve the robots estimated orientation*/
41
double odometry_angle(void);
42

  
43
/** @brief Initialize odometry. MUST be called before 
44
 * the other functions work.**/
45
void odometry_init(void);
46

  
47
/** @brief Reset position and orientation to the origin facing
48
 * the x axis.*/
49
void odometry_reset(void);
50

  
51
/** @brief Report estimated velocity [mm/s].*/
52
long odometry_velocity(void);
53

  
54
/**@}**/ //end group
55

  
56
#endif
branches/colonetmk2/code/lib/include/libdragonfly/spi.h
1
/**
2
 * @file spi.h
3
 * @brief Definitions for SPI
4
 * @author Colony Project, CMU Robotics Club
5
 **/
6

  
7
/**
8
 * @addtogroup spi
9
 * @{
10
 **/
11

  
12
#ifndef __SPI_H__
13
#define __SPI_H__
14

  
15
#define DOUBLE_SCK 1
16
#define SPR0_BIT 1
17

  
18
#define MASTER 1
19
#define SLAVE 0
20

  
21
#define MOSI _BV(PB2)
22
#define MISO _BV(PB3)
23
#define SS   _BV(PB0)
24
#define SCLK _BV(PB1)
25

  
26
typedef void (*spi_fun_recv_t)(char);
27
typedef void (*spi_fun_recv_complete_t)(void);
28

  
29
/** 
30
* @brief Initialize SPI
31
* 
32
* @param spi_fun_recv_t The function that handles SPI data, byte for byte.
33
* @param spi_fun_recv_complete_t  Called on a completed transmission - typically for cleaning up.
34
*/
35
void spi_init (spi_fun_recv_t, spi_fun_recv_complete_t);
36

  
37
/** 
38
* @brief Initialize SPI transfer.
39
* 
40
* @param char The number of bytes to transfer.
41
*/
42
void spi_transfer (char);
43

  
44
/**@}**/ //end group
45

  
46
#endif
branches/colonetmk2/code/lib/include/libdragonfly/dio.h
1
/**
2
 * Copyright (c) 2007 Colony Project
3
 * 
4
 * Permission is hereby granted, free of charge, to any person
5
 * obtaining a copy of this software and associated documentation
6
 * files (the "Software"), to deal in the Software without
7
 * restriction, including without limitation the rights to use,
8
 * copy, modify, merge, publish, distribute, sublicense, and/or sell
... This diff was truncated because it exceeds the maximum size that can be displayed.

Also available in: Unified diff