Project

General

Profile

Revision 1376

Added by James Kong over 14 years ago

Branched changes to analog: loop_running, stop_loop

View differences:

branches/analog/code/projects/hunter_prey/main.c
1
#include <dragonfly_lib.h>
2
#include <wireless.h>
3

  
4
#define CHAN 0xF
5
#define TAG_TIME 3000
6
#define TAG_RANGE 150
7

  
8
int main(void) {
9

  
10
  int frontRange;
11
  uint8_t angle;
12
  uint8_t i;
13
  uint8_t isPrey = 0;
14
  int onTarget = 0;
15
  uint8_t color;
16
  
17
  //intialize the robot and wireless
18
  dragonfly_init(ALL_ON);
19
  wl_init();
20

  
21
  analog_init(1);
22

  
23
  bom_init(BOM15);
24

  
25
  //use a specific channel to avoid interfering with other tasks
26
  wl_set_channel(CHAN);
27

  
28
  orb_set_color(BLUE);
29
  color = BLUE;
30

  
31
  while(1) {
32

  
33
    bom_refresh(BOM_ALL);
34

  
35
    frontRange = range_read_distance (IR2);
36

  
37
    usb_puti(frontRange);
38
    usb_putc('\n');
39

  
40
    //BUG: when get_max_bom is called, the rangefinder seems to stop
41
    //working
42
    angle = get_max_bom();
43
    angle = 4;
44

  
45
    if(angle == 4 && frontRange > 0 && frontRange < TAG_RANGE) {
46
      if(onTarget == 0) {
47
	onTarget = TAG_TIME;
48
	if(color != GREEN) {
49
	  color = GREEN;
50
	  orb_set_color(GREEN);
51
	}
52
	usb_puts("On target!\n");
53
      }
54
      else {
55
	if(--onTarget <= 0) {
56
	  orb_set_color(RED);
57
	  color = RED;
58
	  usb_puts("TAG!\n");
59
	  while(1);
60
	}
61
      }
62
    }
63
    else{
64
      if(color != BLUE) {
65
	color = BLUE;
66
	orb_set_color(BLUE);
67
      }
68

  
69
      //don't reset onTarget because the robot got too close
70
      if(frontRange > 0)
71
	onTarget = 0;
72
    }
73

  
74

  
75
    wl_do();
76
  }
77

  
78
  return 0;
79
}
branches/analog/code/projects/hunter_prey/Makefile
1
########Update This Section########
2
#
3
#
4

  
5
# Relative path to the root directory (containing lib directory)
6
ifndef COLONYROOT
7
COLONYROOT = ../../..
8
endif
9

  
10
# Target file name (without extension).
11
TARGET = main
12

  
13
# Uncomment this to use the wireless library
14
USE_WIRELESS = 1
15

  
16
# com1 = serial port. Use lpt1 to connect to parallel port.
17
AVRDUDE_PORT = $(shell if uname -s |grep -i w32 >/dev/null; then echo 'COM4:'; else echo '/dev/ttyUSB0'; fi)
18

  
19
#
20
###################################
21

  
22
# Hey Emacs, this is a -*- makefile -*-
23
#----------------------------------------------------------------------------
24
# WinAVR Makefile Template written by Eric B. Weddington, J?rg Wunsch, et al.
25
#
26
# Released to the Public Domain
27
#
28
# Additional material for this makefile was written by:
29
# Peter Fleury
30
# Tim Henigan
31
# Colin O'Flynn
32
# Reiner Patommel
33
# Markus Pfaff
34
# Sander Pool
35
# Frederik Rouleau
36
#
37
#----------------------------------------------------------------------------
38
# On command line:
39
#
40
# make all = Make software.
41
#
42
# make clean = Clean out built project files.
43
#
44
# make coff = Convert ELF to AVR COFF.
45
#
46
# make extcoff = Convert ELF to AVR Extended COFF.
47
#
48
# make program = Download the hex file to the device, using avrdude.
49
#                Please customize the avrdude settings below first!
50
#
51
# make debug = Start either simulavr or avarice as specified for debugging,
52
#              with avr-gdb or avr-insight as the front end for debugging.
53
#
54
# make filename.s = Just compile filename.c into the assembler code only.
55
#
56
# make filename.i = Create a preprocessed source file for use in submitting
57
#                   bug reports to the GCC project.
58
#
59
# To rebuild project do "make clean" then "make all".
60
#----------------------------------------------------------------------------
61

  
62
#if you want your code to work on the Firefly++ and not Firefly+
63
#then add the -DFFPP line to CDEFS
64
CDEFS =
65
#-DFFPP
66

  
67
# MCU name
68
MCU = atmega128
69

  
70
# Processor frequency.
71
#     This will define a symbol, F_CPU, in all source code files equal to the
72
#     processor frequency. You can then use this symbol in your source code to
73
#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
74
#     automatically to create a 32-bit value in your source code.
75
F_CPU = 8000000
76

  
77
# Output format. (can be srec, ihex, binary)
78
FORMAT = ihex
79

  
80
# List C source files here. (C dependencies are automatically generated.)
81
SRC = $(wildcard *.c)
82

  
83
# List Assembler source files here.
84
#     Make them always end in a capital .S.  Files ending in a lowercase .s
85
#     will not be considered source files but generated files (assembler
86
#     output from the compiler), and will be deleted upon "make clean"!
87
#     Even though the DOS/Win* filesystem matches both .s and .S the same,
88
#     it will preserve the spelling of the filenames, and gcc itself does
89
#     care about how the name is spelled on its command-line.
90
ASRC =
91

  
92
# Optimization level, can be [0, 1, 2, 3, s].
93
#     0 = turn off optimization. s = optimize for size.
94
#     (Note: 3 is not always the best optimization level. See avr-libc FAQ.)
95
OPT = s
96

  
97
# Debugging format.
98
#     Native formats for AVR-GCC's -g are dwarf-2 [default] or stabs.
99
#     AVR Studio 4.10 requires dwarf-2.
100
#     AVR [Extended] COFF format requires stabs, plus an avr-objcopy run.
101
DEBUG =
102

  
103
# Compiler flag to set the C Standard level.
104
#     c89   = "ANSI" C
105
#     gnu89 = c89 plus GCC extensions
106
#     c99   = ISO C99 standard (not yet fully implemented)
107
#     gnu99 = c99 plus GCC extensions
108
CSTANDARD = -std=gnu99
109

  
110
# Place -D or -U options here
111
CDEFS += -DF_CPU=$(F_CPU)UL
112
CDEFS += -DFFP
113
# for wireless library
114
ifdef USE_WIRELESS
115
	CDEFS += -DROBOT
116
endif
117

  
118
# Place -I, -L options here
119
CINCS = -I$(COLONYROOT)/code/lib/include/libdragonfly
120
CINCS += -L$(COLONYROOT)/code/lib/bin
121
ifdef USE_WIRELESS
122
	CINCS += -I$(COLONYROOT)/code/lib/include/libwireless
123
endif
124

  
125
#---------------- Compiler Options ----------------
126
#  -g*:          generate debugging information
127
#  -O*:          optimization level
128
#  -f...:        tuning, see GCC manual and avr-libc documentation
129
#  -Wall...:     warning level
130
#  -Wa,...:      tell GCC to pass this to the assembler.
131
#    -adhlns...: create assembler listing
132
CFLAGS =
133
# CFLAGS = -g$(DEBUG)
134
CFLAGS += $(CDEFS) $(CINCS)
135
CFLAGS += -O$(OPT)
136
CFLAGS += -funsigned-char -funsigned-bitfields -fpack-struct -fshort-enums
137
CFLAGS += -Wall -Wstrict-prototypes
138
CFLAGS += -Wa,-adhlns=$(<:.c=.lst)
139
CFLAGS += $(CSTANDARD)
140

  
141
#---------------- Assembler Options ----------------
142
#  -Wa,...:   tell GCC to pass this to the assembler.
143
#  -ahlms:    create listing
144
#  -gstabs:   have the assembler create line number information; note that
145
#             for use in COFF files, additional information about filenames
146
#             and function names needs to be present in the assembler source
147
#             files -- see avr-libc docs [FIXME: not yet described there]
148
ASFLAGS = -Wa,-adhlns=$(<:.S=.lst),-gstabs
149

  
150

  
151
#---------------- Library Options ----------------
152
# Minimalistic printf version
153
PRINTF_LIB_MIN = -Wl,-u,vfprintf -lprintf_min
154

  
155
# Floating point printf version (requires MATH_LIB = -lm below)
156
PRINTF_LIB_FLOAT = -Wl,-u,vfprintf -lprintf_flt
157

  
158
# If this is left blank, then it will use the Standard printf version.
159
#PRINTF_LIB =
160
#PRINTF_LIB = $(PRINTF_LIB_MIN)
161
PRINTF_LIB = $(PRINTF_LIB_FLOAT)
162

  
163

  
164
# Minimalistic scanf version
165
SCANF_LIB_MIN = -Wl,-u,vfscanf -lscanf_min
166

  
167
# Floating point + %[ scanf version (requires MATH_LIB = -lm below)
168
SCANF_LIB_FLOAT = -Wl,-u,vfscanf -lscanf_flt
169

  
170
# If this is left blank, then it will use the Standard scanf version.
171
SCANF_LIB =
172
#SCANF_LIB = $(SCANF_LIB_MIN)
173
#SCANF_LIB = $(SCANF_LIB_FLOAT)
174

  
175
MATH_LIB = -lm
176

  
177
#---------------- External Memory Options ----------------
178

  
179
# 64 KB of external RAM, starting after internal RAM (ATmega128!),
180
# used for variables (.data/.bss) and heap (malloc()).
181
#EXTMEMOPTS = -Wl,-Tdata=0x801100,--defsym=__heap_end=0x80ffff
182

  
183
# 64 KB of external RAM, starting after internal RAM (ATmega128!),
184
# only used for heap (malloc()).
185
#EXTMEMOPTS = -Wl,--defsym=__heap_start=0x801100,--defsym=__heap_end=0x80ffff
186

  
187
EXTMEMOPTS =
188

  
189
#---------------- Linker Options ----------------
190
#  -Wl,...:     tell GCC to pass this to linker.
191
#    -Map:      create map file
192
#    --cref:    add cross reference to  map file
193
LDFLAGS = -Wl,-Map=$(TARGET).map,--cref
194
LDFLAGS += $(EXTMEMOPTS)
195
LDFLAGS += $(PRINTF_LIB) $(SCANF_LIB) $(MATH_LIB)
196
ifdef USE_WIRELESS
197
	LDFLAGS += -lwireless
198
endif
199
LDFLAGS += -ldragonfly
200

  
201

  
202

  
203
#---------------- Programming Options (avrdude) ----------------
204

  
205
# Programming hardware: alf avr910 avrisp bascom bsd
206
# dt006 pavr picoweb pony-stk200 sp12 stk200 stk500
207
#
208
# Type: avrdude -c ?
209
# to get a full listing.
210
#
211
AVRDUDE_PROGRAMMER = avrisp
212

  
213
# programmer connected to serial device
214

  
215
AVRDUDE_WRITE_FLASH = -b 57600 -U flash:w:$(TARGET).hex
216
#AVRDUDE_WRITE_EEPROM = -U eeprom:w:$(TARGET).eep
217

  
218

  
219
# Uncomment the following if you want avrdude's erase cycle counter.
220
# Note that this counter needs to be initialized first using -Yn,
221
# see avrdude manual.
222
#AVRDUDE_ERASE_COUNTER = -y
223

  
224
# Uncomment the following if you do /not/ wish a verification to be
225
# performed after programming the device.
226
#AVRDUDE_NO_VERIFY = -V
227

  
228
# Increase verbosity level.  Please use this when submitting bug
229
# reports about avrdude. See <http://savannah.nongnu.org/projects/avrdude>
230
# to submit bug reports.
231
#AVRDUDE_VERBOSE = -v -v
232

  
233
AVRDUDE_FLAGS = -p $(MCU) -P $(AVRDUDE_PORT) -c $(AVRDUDE_PROGRAMMER)
234
AVRDUDE_FLAGS += $(AVRDUDE_NO_VERIFY)
235
AVRDUDE_FLAGS += $(AVRDUDE_VERBOSE)
236
AVRDUDE_FLAGS += $(AVRDUDE_ERASE_COUNTER)
237

  
238
#don't check for device signature
239
AVRDUDE_FLAGS += -F
240

  
241

  
242

  
243
#---------------- Debugging Options ----------------
244

  
245
# For simulavr only - target MCU frequency.
246
DEBUG_MFREQ = $(F_CPU)
247

  
248
# Set the DEBUG_UI to either gdb or insight.
249
# DEBUG_UI = gdb
250
DEBUG_UI = insight
251

  
252
# Set the debugging back-end to either avarice, simulavr.
253
DEBUG_BACKEND = avarice
254
#DEBUG_BACKEND = simulavr
255

  
256
# GDB Init Filename.
257
GDBINIT_FILE = __avr_gdbinit
258

  
259
# When using avarice settings for the JTAG
260
JTAG_DEV = /dev/com1
261

  
262
# Debugging port used to communicate between GDB / avarice / simulavr.
263
DEBUG_PORT = 4242
264

  
265
# Debugging host used to communicate between GDB / avarice / simulavr, normally
266
#     just set to localhost unless doing some sort of crazy debugging when
267
#     avarice is running on a different computer.
268
DEBUG_HOST = localhost
269

  
270

  
271

  
272
#============================================================================
273

  
274

  
275
# Define programs and commands.
276
SHELL = sh
277
CC = avr-gcc
278
OBJCOPY = avr-objcopy
279
OBJDUMP = avr-objdump
280
SIZE = avr-size
281
NM = avr-nm
282
AVRDUDE = avrdude
283
REMOVE = rm -f
284
REMOVEDIR = rm -rf
285
COPY = cp
286
WINSHELL = cmd
287

  
288

  
289
# Define Messages
290
# English
291
MSG_ERRORS_NONE = Errors: none
292
MSG_BEGIN = -------- begin --------
293
MSG_END = --------  end  --------
294
MSG_SIZE_BEFORE = Size before:
295
MSG_SIZE_AFTER = Size after:
296
MSG_COFF = Converting to AVR COFF:
297
MSG_EXTENDED_COFF = Converting to AVR Extended COFF:
298
MSG_FLASH = Creating load file for Flash:
299
MSG_EEPROM = Creating load file for EEPROM:
300
MSG_EXTENDED_LISTING = Creating Extended Listing:
301
MSG_SYMBOL_TABLE = Creating Symbol Table:
302
MSG_LINKING = Linking:
303
MSG_COMPILING = Compiling:
304
MSG_ASSEMBLING = Assembling:
305
MSG_CLEANING = Cleaning project:
306

  
307

  
308

  
309

  
310
# Define all object files.
311
OBJ = $(SRC:.c=.o) $(ASRC:.S=.o)
312

  
313
# Define all listing files.
314
LST = $(SRC:.c=.lst) $(ASRC:.S=.lst)
315

  
316

  
317
# Compiler flags to generate dependency files.
318
GENDEPFLAGS = -MD -MP -MF .dep/$(@F).d
319

  
320

  
321
# Combine all necessary flags and optional flags.
322
# Add target processor to flags.
323
ALL_CFLAGS = -mmcu=$(MCU) -I. $(CFLAGS) $(GENDEPFLAGS)
324
ALL_ASFLAGS = -mmcu=$(MCU) -I. -x assembler-with-cpp $(ASFLAGS)
325

  
326

  
327

  
328

  
329

  
330
# Default target.
331
all: begin gccversion sizebefore build sizeafter end
332

  
333
build: elf hex eep lss sym
334

  
335
elf: $(TARGET).elf
336
hex: $(TARGET).hex
337
eep: $(TARGET).eep
338
lss: $(TARGET).lss
339
sym: $(TARGET).sym
340

  
341

  
342

  
343
# Eye candy.
344
# AVR Studio 3.x does not check make's exit code but relies on
345
# the following magic strings to be generated by the compile job.
346
begin:
347
	@echo
348
	@echo $(MSG_BEGIN)
349

  
350
end:
351
	@echo $(MSG_END)
352
	@echo
353

  
354

  
355
# Display size of file.
356
HEXSIZE = $(SIZE) --target=$(FORMAT) $(TARGET).hex
357
ELFSIZE = $(SIZE) -A $(TARGET).elf
358
AVRMEM = avr-mem.sh $(TARGET).elf $(MCU)
359

  
360
sizebefore:
361
	@if test -f $(TARGET).elf; then echo; echo $(MSG_SIZE_BEFORE); $(ELFSIZE); \
362
	$(AVRMEM) 2>/dev/null; echo; fi
363

  
364
sizeafter:
365
	@if test -f $(TARGET).elf; then echo; echo $(MSG_SIZE_AFTER); $(ELFSIZE); \
366
	$(AVRMEM) 2>/dev/null; echo; fi
367

  
368

  
369

  
370
# Display compiler version information.
371
gccversion :
372
	@$(CC) --version
373

  
374

  
375

  
376
# Program the device.
377
program: $(TARGET).hex $(TARGET).eep
378
	$(AVRDUDE) $(AVRDUDE_FLAGS) $(AVRDUDE_WRITE_FLASH) $(AVRDUDE_WRITE_EEPROM)
379

  
380

  
381
# Generate avr-gdb config/init file which does the following:
382
#     define the reset signal, load the target file, connect to target, and set
383
#     a breakpoint at main().
384
gdb-config:
385
	@$(REMOVE) $(GDBINIT_FILE)
386
	@echo define reset >> $(GDBINIT_FILE)
387
	@echo SIGNAL SIGHUP >> $(GDBINIT_FILE)
388
	@echo end >> $(GDBINIT_FILE)
389
	@echo file $(TARGET).elf >> $(GDBINIT_FILE)
390
	@echo target remote $(DEBUG_HOST):$(DEBUG_PORT)  >> $(GDBINIT_FILE)
391
ifeq ($(DEBUG_BACKEND),simulavr)
392
	@echo load  >> $(GDBINIT_FILE)
393
endif
394
	@echo break main >> $(GDBINIT_FILE)
395

  
396
debug: gdb-config $(TARGET).elf
397
ifeq ($(DEBUG_BACKEND), avarice)
398
	@echo Starting AVaRICE - Press enter when "waiting to connect" message displays.
399
	@$(WINSHELL) /c start avarice --jtag $(JTAG_DEV) --erase --program --file \
400
	$(TARGET).elf $(DEBUG_HOST):$(DEBUG_PORT)
401
	@$(WINSHELL) /c pause
402

  
403
else
404
	@$(WINSHELL) /c start simulavr --gdbserver --device $(MCU) --clock-freq \
405
	$(DEBUG_MFREQ) --port $(DEBUG_PORT)
406
endif
407
	@$(WINSHELL) /c start avr-$(DEBUG_UI) --command=$(GDBINIT_FILE)
408

  
409

  
410

  
411

  
412
# Convert ELF to COFF for use in debugging / simulating in AVR Studio or VMLAB.
413
COFFCONVERT=$(OBJCOPY) --debugging \
414
--change-section-address .data-0x800000 \
415
--change-section-address .bss-0x800000 \
416
--change-section-address .noinit-0x800000 \
417
--change-section-address .eeprom-0x810000
418

  
419

  
420
coff: $(TARGET).elf
421
	@echo
422
	@echo $(MSG_COFF) $(TARGET).cof
423
	$(COFFCONVERT) -O coff-avr $< $(TARGET).cof
424

  
425

  
426
extcoff: $(TARGET).elf
427
	@echo
428
	@echo $(MSG_EXTENDED_COFF) $(TARGET).cof
429
	$(COFFCONVERT) -O coff-ext-avr $< $(TARGET).cof
430

  
431

  
432

  
433
# Create final output files (.hex, .eep) from ELF output file.
434
%.hex: %.elf
435
	@echo
436
	@echo $(MSG_FLASH) $@
437
	$(OBJCOPY) -O $(FORMAT) -R .eeprom $< $@
438

  
439
%.eep: %.elf
440
	@echo
441
	@echo $(MSG_EEPROM) $@
442
	-$(OBJCOPY) -j .eeprom --set-section-flags=.eeprom="alloc,load" \
443
	--change-section-lma .eeprom=0 -O $(FORMAT) $< $@
444

  
445
# Create extended listing file from ELF output file.
446
%.lss: %.elf
447
	@echo
448
	@echo $(MSG_EXTENDED_LISTING) $@
449
	$(OBJDUMP) -h -S $< > $@
450

  
451
# Create a symbol table from ELF output file.
452
%.sym: %.elf
453
	@echo
454
	@echo $(MSG_SYMBOL_TABLE) $@
455
	$(NM) -n $< > $@
456

  
457

  
458

  
459
# Link: create ELF output file from object files.
460
.SECONDARY : $(TARGET).elf
461
.PRECIOUS : $(OBJ)
462
%.elf: $(OBJ)
463
	@echo
464
	@echo $(MSG_LINKING) $@
465
	$(CC) $(ALL_CFLAGS) $^ --output $@ $(LDFLAGS)
466

  
467

  
468
# Compile: create object files from C source files.
469
%.o : %.c
470
	@echo
471
	@echo $(MSG_COMPILING) $<
472
	$(CC) -c $(ALL_CFLAGS) $< -o $@
473

  
474

  
475
# Compile: create assembler files from C source files.
476
%.s : %.c
477
	$(CC) -S $(ALL_CFLAGS) $< -o $@
478

  
479

  
480
# Assemble: create object files from assembler source files.
481
%.o : %.S
482
	@echo
483
	@echo $(MSG_ASSEMBLING) $<
484
	$(CC) -c $(ALL_ASFLAGS) $< -o $@
485

  
486
# Create preprocessed source for use in sending a bug report.
487
%.i : %.c
488
	$(CC) -E -mmcu=$(MCU) -I. $(CFLAGS) $< -o $@
489

  
490

  
491
# Target: clean project.
492
clean: begin clean_list end
493

  
494
clean_list :
495
	@echo
496
	@echo $(MSG_CLEANING)
497
	$(REMOVE) $(TARGET).hex
498
	$(REMOVE) $(TARGET).eep
499
	$(REMOVE) $(TARGET).cof
500
	$(REMOVE) $(TARGET).elf
501
	$(REMOVE) $(TARGET).map
502
	$(REMOVE) $(TARGET).sym
503
	$(REMOVE) $(TARGET).lss
504
	$(REMOVE) $(OBJ)
505
	$(REMOVE) $(LST)
506
	$(REMOVE) $(SRC:.c=.s)
507
	$(REMOVE) $(SRC:.c=.d)
508
	$(REMOVEDIR) .dep
509

  
510

  
511

  
512
# Include the dependency files.
513
-include $(shell mkdir .dep 2>/dev/null) $(wildcard .dep/*)
514

  
515

  
516
# Listing of phony targets.
517
.PHONY : all begin finish end sizebefore sizeafter gccversion \
518
build elf hex eep lss sym coff extcoff \
519
clean clean_list program debug gdb-config
520

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

  
26

  
27
/**
28
 * @file rangefinder.c
29
 * @brief Rangefinders
30
 *
31
 * Implementation of functions for rangefinder use.
32
 *
33
 * @author Colony Project, CMU Robotics Club
34
 **/
35

  
36
/*
37
  Authors: James Kong and Greg Tress
38

  
39
  Last Modified: 4/30/06 by James
40
  -Started log_distance conversion function !!!NOT COMPLETE!!!
41
  -Cleaning up comments
42

  
43
  -----------------
44
  rangefinder.c
45
  Using Sharp GP2D02 IR Rangefinder
46

  
47
  Vin is the input to the rangefinder, designated RANGE_CTRL.
48
  Vout is the output from the rangefinder, designated RANGE_IN# where # is the rangefinder you are reading from
49

  
50
  Expected Initial Conditions:
51
  Vin is high and Vout should read high.
52

  
53
  Usage:
54
  1.) Set Vin low. Vout should read low.
55
  2.) Wait for high on Vout.
56
  3.) Begin clocking Vin and reading 8 bits from Vout (MSB first).
57
  4.) Set Vin high for 2ms or more to turn off rangefinder
58

  
59
*/
60

  
61
#include "dragonfly_lib.h"
62
#include "rangefinder.h"
63

  
64
/*
65
  read_distance returns the 8-bit reading from the rangefinder
66
  parameters:
67
  range_id - dio pin set as the rangefinder Vout [i.e. RANGE_IN0]
68

  
69
  NOTE:
70
  The Sharp GD2D02 returns values on a decreasing logrithmic scale.
71
  So higher values correspond to closer distances.  Use linearize_distance to convert to normal centimeter scale.
72
  Also, when reading distances closer than 8cm, the Sharp GD2D02 will return lower values than the values at 8cm.
73
  At this point, we are only reading from one rangefinder [RANGE_IN0].
74
*/
75

  
76
// constants
77
/* Nasty IR approximation table
78
   I'm using this for the heck of it.  We can do whatever.
79

  
80
   Note the minimum value is .4V (20), and the maximum is 2.6V (133).
81
   Gives distance in mm.
82

  
83
   excel formula(valid for inputs 20-133):  ROUND(2353.6*(E2^(-1.1146))*10,0)
84

  
85
   This is only valid for the GP2D12, with objects directly ahead and more than
86
   10cm from the detector.  See the datasheet for more information.
87
*/
88

  
89
static int IR_dist_conversion[114] = {
90
  800,791,751,714,681,651,623,597,574,552,531,512,494,478,462,447
91
  ,434,421,408,397,386,375,365,356,347,338,330,322,315,307,301,294
92
  ,288,282,276,270,265,260,255,250,245,241,237,232,228,224,221,217
93
  ,213,210,207,203,200,197,194,191,189,186,183,181,178,176,173,171
94
  ,169,166,164,162,160,158,156,154,152,151,149,147,145,144,142,140
95
  ,139,137,136,134,133,131,130,129,127,126,125,124,122,121,120,119
96
  ,118,117,115,114,113,112,111,110,109,108,107,106,105,105,104,103
97
  ,102,101
98
};
99

  
100
/**
101
 * @defgroup rangefinder Rangefinder
102
 * @brief Functions for using the IR rangefinders
103
 * 
104
 * Functions for using the IR rangefinders.
105
 *
106
 * @{
107
 **/
108

  
109
/**
110
 * Initializes the rangefinders. This must be called before
111
 * range_read_distance.
112
 *
113
 * @see range_read_distance
114
 **/
115
void range_init(void)
116
{
117
  digital_output(_PIN_B4,0);
118
}
119

  
120
/**
121
 * Reads the distance measured by one of the rangefinders.
122
 * This distance is in arbitrary units.
123
 *
124
 * @param range_id the rangefinder to use. This should be one
125
 * of the constants IR1 - IR5.
126
 *
127
 * @return the distance measured by the rangefinder
128
 *
129
 * @see range_init
130
 **/
131
int range_read_distance(int range_id) {
132
  return linearize_distance(analog8(range_id));
133
}
134

  
135
/**
136
 * Transforms distance readings from logarithmic to linear scale.
137
 * This probably isn't the function you are looking for.
138
 *
139
 * @param value the 8-bit analog value from rangefinder
140
 *
141
 * @return linearized distance reading from rangefinder (integer in [101,800])
142
 **/
143
int linearize_distance(int value) {
144
  if(value < MIN_IR_ADC8) {
145
    return -1;
146
  } else if(value > MAX_IR_ADC8) {
147
    return -1;
148
  } else {
149
    return IR_dist_conversion[value - MIN_IR_ADC8];
150
  }
151
}
152

  
153
/** @} **/ //end defgroup
branches/analog/code/projects/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/analog/code/projects/libdragonfly/encoders.c
1
#include "encoders.h"
2
#include "spi.h"
3
#include "dragonfly_lib.h"
4
#include "ring_buffer.h"
5

  
6
unsigned int left_data_buf;
7
unsigned int right_data_buf;
8
char encoder_buf_index;
9

  
10
unsigned int left_data;
11
unsigned int right_data;
12

  
13
unsigned int left_data_array[BUFFER_SIZE];
14
unsigned int right_data_array[BUFFER_SIZE];
15
int left_data_idx;
16
int right_data_idx;
17

  
18
int left_dx;
19
int right_dx;
20
long int timecount;
21

  
22
volatile short int data_ready;
23

  
24
void encoder_recv(char data);
25

  
26
//Helper Function Prototypes
27
inline void left_data_array_put(unsigned short int value);
28
inline unsigned int left_data_array_top(void);
29
inline unsigned int left_data_array_prev(void);
30
inline unsigned int left_data_array_bottom(void);
31

  
32
inline void right_data_array_put(unsigned short int value);
33
inline unsigned int right_data_array_top(void);
34
inline unsigned int right_data_array_prev(void);
35
inline unsigned int right_data_array_bottom(void);
36

  
37

  
38
void encoder_recv_complete(void){
39
  	encoder_buf_index = 0;
40
	data_ready++;
41
  
42
   	spi_transfer(5);
43
}
44

  
45
/** 
46
* @brief Initializes encoder variables and the hardware interface.
47
*/
48
void encoders_init(void){
49
	int i;
50
	
51
	data_ready=0;
52

  
53
	spi_init(encoder_recv, encoder_recv_complete);
54
	encoder_buf_index = 0;
55
	left_data_buf = 0;
56
	right_data_buf= 0;
57
	left_data = -1;
58
	right_data = -1;
59
	
60
	//RING_BUFFER_INIT(enc_buffer,BUFFER_SIZE);
61
	left_data_idx = 0;
62
	right_data_idx = 0;
63
	for(i = 0; i < BUFFER_SIZE; i++) {
64
		left_data_array[i] = 0;
65
	}
66
	for(i = 0; i < BUFFER_SIZE; i++) {
67
		right_data_array[i] = 0;
68
	}
69
	spi_transfer(5);
70
}
71

  
72
/**
73
 * @brief Returns the specified encoders value
74
 *
75
 * @param encoder this is the encoder that you want to read. Valid arguments
76
 *          are LEFT and RIGHT
77
 *
78
 * @return the value of the specified encoder
79
 **/
80
int encoder_read(char encoder){
81
	
82
	if(encoder==LEFT) return left_data;
83
	else if(encoder==RIGHT) return right_data;
84
	else return -1;
85
}
86

  
87
/**
88
 * Gets the total distance covered by the specified encoder (in encoder clicks)
89
 *
90
 * @param encoder the encoder that you want to read, use LEFT or RIGHT
91
 *
92
 * @return The distance covered by the specified encoder.
93
 **/
94
int encoder_get_dx(char encoder) {
95
	
96
	if(encoder==LEFT) return left_dx;
97
	else if(encoder==RIGHT) return right_dx;
98
	else return -1;
99
}
100

  
101
/**
102
 * Resets the distance accumulator for the specified
103
 *  encoder.
104
 *
105
 * @param encoder the encoder that you want to reset distance for
106
 **/
107
void encoder_rst_dx(char encoder) {
108
	
109
	if(encoder==LEFT) left_dx = 0;
110
	else if(encoder==RIGHT) right_dx = 0;
111
}
112

  
113
/** 
114
* @brief Returns the number of encoder reads that have occurred.
115
* 
116
* @return The time count.
117
*/
118
int encoder_get_tc(void) {
119
	return timecount;
120
}
121

  
122
/** 
123
* @brief Resets the encoder read counter.
124
*/
125
void encoder_rst_tc(void) {
126
	timecount = 0;
127
}
128

  
129
/** 
130
* @brief Waits until n encoder reads have occurred.
131
* Counter is reset on functions exit.
132
* 
133
* @param n 
134
*/
135
void encoder_wait(int n){
136
	while(data_ready<n);
137
	data_ready=0;
138
}
139

  
140

  
141
//Full reads occur every 40 microseconds. This function should be called
142
//every 8 microseconds.
143
void encoder_recv(char data){
144
	short int dx;
145
	
146
	//Parse the encoder data, comes in over 5 bytes 16 bits per encoder,
147
	// second is offset by 1 bit.
148
	switch(encoder_buf_index){	
149
	case 0: 
150
		right_data_buf |= ((short)data)<<8 & 0xff00;
151
		break;
152
	case 1:
153
		right_data_buf |= ((short)data) & 0xff;
154
		break;
155
	case 2:
156
		left_data_buf |= (((short)data) << 9) & (0x7F << 9);
157
		break;
158
	case 3:
159
		left_data_buf |= (((short)data) << 1) & (0xFF<<1);
160
		break;
161
	case 4: left_data_buf |= (((short)data)>>7) & 0x1;
162
	}	
163
		
164
	encoder_buf_index = (encoder_buf_index + 1) % 5;
165

  
166
	if(encoder_buf_index==0) {
167
		
168
		/*Error handling for the left encoder*/ 
169
		if(!(left_data_buf & OCF)) 
170
			left_data = ENCODER_DATA_NOT_READY; 
171
		if(left_data_buf & (COF | LIN))  
172
			left_data = ENCODER_MISALIGNED;
173
		else if((left_data_buf & MagINCn) && (left_data_buf & MagDECn)) 
174
			left_data = ENCODER_MAGNET_FAILURE;
175
		else left_data = (left_data_buf>>5) & 1023;
176
			
177
		/*Error handling for the right encoder*/ 
178
	 	if(!(right_data_buf & OCF))
179
			right_data = ENCODER_DATA_NOT_READY;	
180
		if(right_data_buf & (COF | LIN)) 
181
			right_data = ENCODER_MISALIGNED;
182
		else if ((right_data_buf & MagINCn)  && (right_data_buf & MagDECn)) 
183
			right_data = ENCODER_MAGNET_FAILURE;
184
		else right_data = (right_data_buf>>5) & 1023;
185
			
186
  		left_data_buf = 0;
187
		right_data_buf = 0;
188

  
189
		/*Note: Above 1023 is invalid data*/	
190
		if(!(left_data > 1023)) {
191
			//Reverse the left wheel since encoders are necessarily mounted backwards.
192
			left_data = 1023 - left_data;
193
			left_data_array_put(left_data);
194

  
195
			//Adjust left accumulator
196
			dx = left_data - left_data_array_prev();
197
			
198
			if(left_data_array_prev()==0)  dx=0;
199

  
200
			if(dx > 512) left_dx += dx - 1023; //Underflow
201
			else if(dx < -512) left_dx += dx + 1023; //Overflow
202
			else left_dx += dx;
203
		}
204

  
205
		/*Above 1023 is invalid data*/	
206
		if(!(right_data > 1023)) {
207
			right_data_array_put(right_data);
208

  
209
			//Adjust right accumulator
210
			dx = right_data - right_data_array_prev();
211

  
212
			if(right_data_array_prev()==0) dx=0;
213
			  
214
			if(dx > 512) right_dx += dx - 1023; //underflow
215
			else if(dx < -512) right_dx += dx + 1023; //overflow 
216
			else right_dx += dx;
217
		}
218
	}
219

  
220
	//Increment timecount accumulator
221
	timecount++;
222
}
223

  
224

  
225
//Helper Functions
226
inline void left_data_array_put(unsigned short int value) {
227
	if(left_data_idx == BUFFER_SIZE-1)
228
		left_data_idx = 0;
229
	else
230
		left_data_idx++;
231
	left_data_array[left_data_idx] = value;
232
}
233

  
234
inline unsigned int left_data_array_top(void) {
235
	return left_data_array[left_data_idx];
236
}
237

  
238
inline unsigned int left_data_array_prev(void) {
239
	if(left_data_idx == 0)
240
		return left_data_array[BUFFER_SIZE-1];
241
	else
242
		return left_data_array[left_data_idx - 1];
243
}
244

  
245
inline unsigned int left_data_array_bottom(void) {
246
	if(left_data_idx == BUFFER_SIZE-1)
247
		return left_data_array[0];
248
	else
249
		return left_data_array[left_data_idx + 1];
250
}
251

  
252
inline void right_data_array_put(unsigned short int value) {
253
	if(right_data_idx == BUFFER_SIZE-1)
254
		right_data_idx = 0;
255
	else
256
		right_data_idx++;
257
	right_data_array[right_data_idx] = value;
258
}
259

  
260
inline unsigned int right_data_array_top(void) {
261
	return right_data_array[right_data_idx];
262
}
263

  
264
inline unsigned int right_data_array_prev(void) {
265
	if(right_data_idx == 0)
266
		return right_data_array[BUFFER_SIZE-1];
267
	else
268
		return right_data_array[right_data_idx - 1];
269
}
270

  
271
inline unsigned int right_data_array_bottom(void) {
272
	if(right_data_idx == BUFFER_SIZE-1)
273
		return right_data_array[0];
274
	else
275
		return right_data_array[right_data_idx + 1];
276
}
277

  
branches/analog/code/projects/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 Magnet misaligned - likely distance from encoder problem. **/
32
#define ENCODER_MAGNET_FAILURE 1025
33
/** @brief Encoder misaligned - likely on XY plane. **/
34
#define ENCODER_MISALIGNED 1027
35
/** @brief Not enough time has passed - encoders not initialized in hardware. **/
36
#define ENCODER_DATA_NOT_READY 1026
37

  
38
/** @brief delay_ms argument after a full read is complete **/
39
#define ENCODER_DELAY 20
40

  
41
//Data invalid flags (hardware failure):
42
#define OCF _BV(4)
43
#define COF _BV(3)
44

  
45
//Data invalid alarm (May be invalid):
46
#define LIN _BV(2)
47

  
48
#define MagINCn _BV(1)
49
#define MagDECn _BV(0)
50

  
51
/** @brief Buffer size **/
52
#define BUFFER_SIZE 23
53

  
54
/** @brief Initialize encoders. **/
55
void encoders_init(void);
56
/** @brief Read instantaneous encoder value. **/
57
int encoder_read(char encoder);
58

  
59
/** @brief Get total distance traveled. **/
60
int encoder_get_dx(char encoder);
61
/** @brief Reset distance counter. **/
62
void encoder_rst_dx(char encoder);
63
/** @brief Get time count: The number of encoder reads that have occurred. **/
64
int encoder_get_tc(void);
65
/** @brief Reset the time count. **/
66
void encoder_rst_tc(void);
67

  
68
/** @brief Waits for the next n encoder reading, then returns. **/
69
void encoder_wait( int nReadings );
70

  
71
/**@}**/ //end group
72

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

  
26

  
27
/**
28
 * @file serial.c
29
 * @brief Serial Input and Output
30
 *
31
 * Implementation of functions for serial input and output.
32
 *
33
 * @author Colony Project, CMU Robotics Club
34
 **/
35

  
36
#include <avr/io.h>
37
#include <stdio.h>
38
#include "serial.h"
39

  
40
/**
41
 * For use with fprintf() and related stdio functions
42
 **/
43
FILE *usb_fd;
44

  
45
/**
46
 * For use with fprintf() and related stdio functions
47
 **/
48
FILE *xbee_fd;
49

  
50
/**
51
 * Initializes communication over the USB serial port.
52
 * This must be called before any other usb function
53
 * may be used.
54
 **/
55
void usb_init() {
56
  //Set baud rate
57
  // - 115200 (both wired and wireless) is UBRR=8, U2X=1
58
  // - 9600 is U2X =1, UBRR = 107.
59
#if (USB_BAUD == 115200)
60
  UBRR0H = 0x00;
61
  UBRR0L = 8;
62
  UCSR0A |= _BV(U2X0);
63
#elif (USB_BAUD == 9600)
64
  UBRR0H = 0x00;
65
  UBRR0L = 103;
66
  UCSR0A |= _BV(U2X0);
67
#else //Baud rate is defined in the header file, we should not get here
68
  return;
69
#endif
70

  
71
  /*Enable receiver and transmitter */
72
  UCSR0B |= (1<<RXEN0)|(1<<TXEN0);
73
	
74
  /* Set frame format: 8data, 1stop bit, asynchronous normal mode */
75
  UCSR0C |= (1<<UCSZ00) | (1<<UCSZ01);
76
  
77
  // if we have enabled the stdio stuff, then we init it here
78
#ifdef USE_STDIO
79
  /* Open the stdio stream corresponding to this port */
80
  usb_fd = fdevopen(usb_putc, usb_getc);
81
#endif
82
}
83

  
84
/**
85
 * Initializes communication over the XBee.
86
 * This must be called before any other xbee function
87
 * may be used.
88
 **/
89
void xbee_init() {
90
  //Set baud rate
91
  // - 115200 (both wired and wireless) is UBRR=8, U2X=1
92
  // - 9600 is U2X =1, UBRR = 107.
93
#if (XBEE_BAUD == 115200)
94
  UBRR1H = 0x00;
95
  UBRR1L = 8;
96
  UCSR1A |= _BV(U2X1);
97
#elif (XBEE_BAUD == 9600)
98
  UBRR1H = 0x00;
99
  UBRR1L = 103;
100
  UCSR1A |= _BV(U2X1);
101
#else //Baud rate is defined in the header file, we should not get here
102
  return;
103
#endif
104

  
105
  //Enable receiver and transmitter
106
  UCSR1B |= (1<<RXEN1)|(1<<TXEN1);
107
	
108
  // Set frame format: 8data, 1stop bit, asynchronous normal mode
109
  UCSR1C |= (1<<UCSZ10) | (1<<UCSZ11);
110
  
111
  // if we have enabled the stdio stuff, then we init it here
112
#ifdef USE_STDIO
113
  /* Open the stdio stream corresponding to this port */
114
  xbee_fd = fdevopen(xbee_putc, xbee_getc);
115
#endif
116
}
117

  
118
/**
119
 * Sends a character over USB.
120
 *
121
 * @param c the character to send
122
 * @return 0 for success, nonzero for failure
123
 **/
124
int usb_putc(char c) {
125
  // Wait until buffer is clear for sending
126
  loop_until_bit_is_set(UCSR0A, UDRE0);
127
	
128
  // Load buffer with your character
129
  UDR0 = c;
130
  return 0;
131
}
132

  
133
/**
134
 * Sends a character to the XBee.
135
 *
136
 * @param c the character to send
137
 * @return 0 for success, nonzero for failure
138
 **/
139
int xbee_putc(char c) {
140
  // Wait until buffer is clear for sending
141
  loop_until_bit_is_set(UCSR1A, UDRE1);
142
	
143
  // Load buffer with your character
144
  UDR1 = c;
145
  return 0;
146
}
147

  
148
/**
149
 * Sends a sequence of characters over USB.
150
 *
151
 * @param s the string to send
152
 * @return 0 for success, nonzero for failure
153
 **/
154
int usb_puts(char *s) {
155
  char *t = s;
156
  while (*t != 0) {
157
    usb_putc(*t);
158
    t++;
159
  }
160
  return 0;
161
}
162

  
163
/**
164
 * Sends a sequence of characters from program space over USB.
165
 *
166
 * @param s the string to send
167
 **/
168
void usb_puts_P (PGM_P s) {
169
    char buf;
170
	
171
    while (memcpy_P (&buf, s, sizeof (char)), buf!=0) {
172
        usb_putc (buf);
173
        s++;
174
    }
175
}
176

  
177

  
178

  
179
/**
180
 * Returns the first character in the buffer received from USB.
181
 * This function blocks execution until a character has been received.
182
 * xbee_init must be called before this function may be used.
183
 * 
184
 * @return the first character in the usb buffer
185
 *
186
 * @see usb_init, usb_getc_nb
187
 **/
188
int usb_getc(void) {
189
  // Wait for the receive buffer to be filled
190
  loop_until_bit_is_set(UCSR0A, RXC0);
191
	
192
  // Read the receive buffer
193
  return UDR0;
194
}
195

  
196
/**
197
 * Returns the first character in the buffer received from USB.
198
 * This function blocks execution until a character has been
199
 * received. xbee_init must be called before this function
200
 * may be used.
201
 * 
202
 * @return the first character in the xbee buffer
203
 * 
204
 * @see xbee_init, xbee_getc_nb
205
 **/
206
int xbee_getc(void) {
207
  // Wait for the receive buffer to be filled
208
  loop_until_bit_is_set(UCSR1A, RXC1);
209
	
210
  // Read the receive buffer
211
  return UDR1;
212
}
213

  
214
/**
215
 * Non blocking version of usb_getc. If a character is present in the buffer,
216
 * it is returned, otherwise -1 is returned immediately. usb_init must be
217
 * called before this function can be used.
218
 *
219
 * @param c the received character. This will be set if a character has
220
 * been received.
221
 * 
222
 * @return -1 if no character is available, 0 otherwise
223
 * 
224
 * @see usb_init, usb_getc
225
 **/
226
int usb_getc_nb(char *c) {
227
  // check if the receive buffer is filled
228
  if (UCSR0A & _BV(RXC0)) {
229
    // Read the receive buffer
230
    (*c) = UDR0;
231
    return 0;
232
  } else {
233
    // Return empty
234
    return -1;
235
  }
236
}
237

  
238
/**
239
 * Non blocking version of xbee_getc. If a character is present in the buffer,
240
 * it is returned, otherwise -1 is returned immediately. xbee_init
241
 * must be called before this function can be used.
242
 *
243
 * @param c the received character. This will be set if a character has
244
 * been received.
245
 * 
246
 * @return -1 if no character is available, 0 otherwise
247
 *
248
 * @see xbee_init, xbee_getc
249
 **/
250
int xbee_getc_nb(char *c) {
251
  // check if the receive buffer is filled
252
  if (UCSR1A & _BV(RXC1)) {
253
    // Read the receive buffer
254
    (*c) = UDR1;
255
    return 0;
256
  } else {
257
    // Return empty
258
    return -1;
259
  }
260
}
261

  
262

  
263
/*
264
  prints an int to serial
265

  
266
  code adapted from Chris Efstathiou's code (hendrix@otenet.gr)
267
  uses usb_putc
268
*/
269
/**
270
 * Prints an integer, converted to ASCII, to usb. usb_init must be called
271
 * before this function can be used.
272
 *
273
 * @param value the integer to print
274
 * 
275
 * @return 0 if successful, nonzero otherwise
276
 *
277
 * @see usb_init, usb_putc
278
 **/
279
int usb_puti(int value ) {
280
  unsigned char usb_data[6]={'0','0','0','0','0','0' }, position=sizeof(usb_data), radix=10; 
281

  
282
  /* convert int to ascii  */ 
283
  if(value<0) { 
284
    usb_putc('-'); 
285
    value=-value; 
286
  }    
287
  do { 
288
    position--; 
289
    *(usb_data+position)=(value%radix)+'0'; 
290
    value/=radix;  
291
  } while(value); 
292

  
293
    
294
  /* start displaying the number */
... This diff was truncated because it exceeds the maximum size that can be displayed.

Also available in: Unified diff