Colony

# Hey Emacs, this is a -*- makefile -*-

#----------------------------------------------------------------------------

# WinAVR Makefile Template written by Eric B. Weddington, J?rg Wunsch, et al.

#

# Released to the Public Domain

#

# Additional material for this makefile was written by:

# Peter Fleury

# Tim Henigan

# Colin O'Flynn

# Reiner Patommel

# Markus Pfaff

# Sander Pool

# Frederik Rouleau

#

#----------------------------------------------------------------------------

# On command line:

#

# make all = Make software.

#

# make clean = Clean out built project files.

#

# make coff = Convert ELF to AVR COFF.

#

# make extcoff = Convert ELF to AVR Extended COFF.

#

# make program = Download the hex file to the device, using avrdude.

#                Please customize the avrdude settings below first!

#

# make debug = Start either simulavr or avarice as specified for debugging, 

#              with avr-gdb or avr-insight as the front end for debugging.

#

# make filename.s = Just compile filename.c into the assembler code only.

#

# make filename.i = Create a preprocessed source file for use in submitting

#                   bug reports to the GCC project.

#

# To rebuild project do "make clean" then "make all".

#----------------------------------------------------------------------------

# MCU name

MCU = atmega128

# Processor frequency.

#     This will define a symbol, F_CPU, in all source code files equal to the 

#     processor frequency. You can then use this symbol in your source code to 

#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done

#     automatically to create a 32-bit value in your source code.

F_CPU = 16000000

# Output format. (can be srec, ihex, binary)

FORMAT = ihex

# Target file name (without extension).

TARGET = robot_routine_reg_test

# List C source files here. (C dependencies are automatically generated.)

SRC = $(wildcard *.c)

#$(TARGET).c 

# List Assembler source files here.

#     Make them always end in a capital .S.  Files ending in a lowercase .s

#     will not be considered source files but generated files (assembler

#     output from the compiler), and will be deleted upon "make clean"!

#     Even though the DOS/Win* filesystem matches both .s and .S the same,

#     it will preserve the spelling of the filenames, and gcc itself does

#     care about how the name is spelled on its command-line.

ASRC = 

# Optimization level, can be [0, 1, 2, 3, s]. 

#     0 = turn off optimization. s = optimize for size.

#     (Note: 3 is not always the best optimization level. See avr-libc FAQ.)

OPT = s

# Debugging format.

#     Native formats for AVR-GCC's -g are dwarf-2 [default] or stabs.

#     AVR Studio 4.10 requires dwarf-2.

#     AVR [Extended] COFF format requires stabs, plus an avr-objcopy run.

DEBUG = dwarf-2

# List any extra directories to look for include files here.

#     Each directory must be seperated by a space.

#     Use forward slashes for directory separators.

#     For a directory that has spaces, enclose it in quotes.

EXTRAINCDIRS = c:/roboclub_repository/emarinel/code/colonet/lib c:/roboclub_repository/emarinel/code/firefly_plus_lib 

# Compiler flag to set the C Standard level.

#     c89   = "ANSI" C

#     gnu89 = c89 plus GCC extensions

#     c99   = ISO C99 standard (not yet fully implemented)

#     gnu99 = c99 plus GCC extensions

CSTANDARD = -std=gnu99

# Place -D or -U options here

CDEFS = -DF_CPU=$(F_CPU)UL

# Place -I options here

CINCS =

#---------------- Compiler Options ----------------

#  -g*:          generate debugging information

#  -O*:          optimization level

#  -f...:        tuning, see GCC manual and avr-libc documentation

#  -Wall...:     warning level

#  -Wa,...:      tell GCC to pass this to the assembler.

#    -adhlns...: create assembler listing

CFLAGS = -g$(DEBUG)

CFLAGS += $(CDEFS) $(CINCS)

CFLAGS += -O$(OPT)

CFLAGS += -funsigned-char -funsigned-bitfields -fpack-struct -fshort-enums

CFLAGS += -Wall -Wstrict-prototypes

CFLAGS += -Wa,-adhlns=$(<:.c=.lst)

CFLAGS += $(patsubst %,-I%,$(EXTRAINCDIRS))

CFLAGS += $(CSTANDARD)

#---------------- Assembler Options ----------------

#  -Wa,...:   tell GCC to pass this to the assembler.

#  -ahlms:    create listing

#  -gstabs:   have the assembler create line number information; note that

#             for use in COFF files, additional information about filenames

#             and function names needs to be present in the assembler source

#             files -- see avr-libc docs [FIXME: not yet described there]

ASFLAGS = -Wa,-adhlns=$(<:.S=.lst),-gstabs 

#---------------- Library Options ----------------

# Minimalistic printf version

PRINTF_LIB_MIN = -Wl,-u,vfprintf -lprintf_min

# Floating point printf version (requires MATH_LIB = -lm below)

PRINTF_LIB_FLOAT = -Wl,-u,vfprintf -lprintf_flt

# If this is left blank, then it will use the Standard printf version.

PRINTF_LIB = 

#PRINTF_LIB = $(PRINTF_LIB_MIN)

#PRINTF_LIB = $(PRINTF_LIB_FLOAT)

# Minimalistic scanf version

SCANF_LIB_MIN = -Wl,-u,vfscanf -lscanf_min

# Floating point + %[ scanf version (requires MATH_LIB = -lm below)

SCANF_LIB_FLOAT = -Wl,-u,vfscanf -lscanf_flt

# If this is left blank, then it will use the Standard scanf version.

SCANF_LIB = 

#SCANF_LIB = $(SCANF_LIB_MIN)

#SCANF_LIB = $(SCANF_LIB_FLOAT)

MATH_LIB = -lm

#---------------- External Memory Options ----------------

# 64 KB of external RAM, starting after internal RAM (ATmega128!),

# used for variables (.data/.bss) and heap (malloc()).

#EXTMEMOPTS = -Wl,-Tdata=0x801100,--defsym=__heap_end=0x80ffff

# 64 KB of external RAM, starting after internal RAM (ATmega128!),

# only used for heap (malloc()).

#EXTMEMOPTS = -Wl,--defsym=__heap_start=0x801100,--defsym=__heap_end=0x80ffff

EXTMEMOPTS =

#---------------- Linker Options ----------------

#  -Wl,...:     tell GCC to pass this to linker.

#    -Map:      create map file

#    --cref:    add cross reference to  map file

LDFLAGS = -Wl,-Map=$(TARGET).map,--cref

LDFLAGS += $(EXTMEMOPTS)

LDFLAGS += $(PRINTF_LIB) $(SCANF_LIB) $(MATH_LIB)

#---------------- Programming Options (avrdude) ----------------

# Programming hardware: alf avr910 avrisp bascom bsd 

# dt006 pavr picoweb pony-stk200 sp12 stk200 stk500

#

# Type: avrdude -c ?

# to get a full listing.

#

AVRDUDE_PROGRAMMER = avrisp

# com1 = serial port. Use lpt1 to connect to parallel port.

AVRDUDE_PORT = com1

# programmer connected to serial device

AVRDUDE_WRITE_FLASH = -b 9600 -U flash:w:$(TARGET).hex

#AVRDUDE_WRITE_EEPROM = -U eeprom:w:$(TARGET).eep

# Uncomment the following if you want avrdude's erase cycle counter.

# Note that this counter needs to be initialized first using -Yn,

# see avrdude manual.

#AVRDUDE_ERASE_COUNTER = -y

# Uncomment the following if you do /not/ wish a verification to be

# performed after programming the device.

AVRDUDE_NO_VERIFY = -V

# Increase verbosity level.  Please use this when submitting bug

# reports about avrdude. See <http://savannah.nongnu.org/projects/avrdude> 

# to submit bug reports.

#AVRDUDE_VERBOSE = -v -v

AVRDUDE_FLAGS = -F -p $(MCU) -P $(AVRDUDE_PORT) -c $(AVRDUDE_PROGRAMMER)

AVRDUDE_FLAGS += $(AVRDUDE_NO_VERIFY)

AVRDUDE_FLAGS += $(AVRDUDE_VERBOSE)

AVRDUDE_FLAGS += $(AVRDUDE_ERASE_COUNTER)

#---------------- Debugging Options ----------------

# For simulavr only - target MCU frequency.

DEBUG_MFREQ = $(F_CPU)

# Set the DEBUG_UI to either gdb or insight.

# DEBUG_UI = gdb

DEBUG_UI = insight

# Set the debugging back-end to either avarice, simulavr.

DEBUG_BACKEND = avarice

#DEBUG_BACKEND = simulavr

# GDB Init Filename.

GDBINIT_FILE = __avr_gdbinit

# When using avarice settings for the JTAG

JTAG_DEV = /dev/com1

# Debugging port used to communicate between GDB / avarice / simulavr.

DEBUG_PORT = 4242

# Debugging host used to communicate between GDB / avarice / simulavr, normally

#     just set to localhost unless doing some sort of crazy debugging when 

#     avarice is running on a different computer.

DEBUG_HOST = localhost

#============================================================================

# Define programs and commands.

SHELL = sh

CC = avr-gcc

OBJCOPY = avr-objcopy

OBJDUMP = avr-objdump

SIZE = avr-size

NM = avr-nm

AVRDUDE = avrdude

REMOVE = rm -f

COPY = cp

WINSHELL = cmd

# Define Messages

# English

MSG_ERRORS_NONE = Errors: none

MSG_BEGIN = -------- begin --------

MSG_END = --------  end  --------

MSG_SIZE_BEFORE = Size before: 

MSG_SIZE_AFTER = Size after:

MSG_COFF = Converting to AVR COFF:

MSG_EXTENDED_COFF = Converting to AVR Extended COFF:

MSG_FLASH = Creating load file for Flash:

MSG_EEPROM = Creating load file for EEPROM:

MSG_EXTENDED_LISTING = Creating Extended Listing:

MSG_SYMBOL_TABLE = Creating Symbol Table:

MSG_LINKING = Linking:

MSG_COMPILING = Compiling:

MSG_ASSEMBLING = Assembling:

MSG_CLEANING = Cleaning project:

# Define all object files.

OBJ = $(SRC:.c=.o) $(ASRC:.S=.o) 

# Define all listing files.

LST = $(SRC:.c=.lst) $(ASRC:.S=.lst) 

# Compiler flags to generate dependency files.

GENDEPFLAGS = -MD -MP -MF .dep/$(@F).d

# Combine all necessary flags and optional flags.

# Add target processor to flags.

ALL_CFLAGS = -mmcu=$(MCU) -I. $(CFLAGS) $(GENDEPFLAGS)

ALL_ASFLAGS = -mmcu=$(MCU) -I. -x assembler-with-cpp $(ASFLAGS)

# Default target.

all: begin gccversion sizebefore build sizeafter end

build: elf hex eep lss sym

elf: $(TARGET).elf

hex: $(TARGET).hex

eep: $(TARGET).eep

lss: $(TARGET).lss 

sym: $(TARGET).sym

# Eye candy.

# AVR Studio 3.x does not check make's exit code but relies on

# the following magic strings to be generated by the compile job.

begin:

	@echo

	@echo $(MSG_BEGIN)

end:

	@echo $(MSG_END)

	@echo

# Display size of file.

HEXSIZE = $(SIZE) --target=$(FORMAT) $(TARGET).hex

ELFSIZE = $(SIZE) -A $(TARGET).elf

AVRMEM = avr-mem.sh $(TARGET).elf $(MCU)

sizebefore:

	@if test -f $(TARGET).elf; then echo; echo $(MSG_SIZE_BEFORE); $(ELFSIZE); \

	$(AVRMEM) 2>/dev/null; echo; fi

sizeafter:

	@if test -f $(TARGET).elf; then echo; echo $(MSG_SIZE_AFTER); $(ELFSIZE); \

	$(AVRMEM) 2>/dev/null; echo; fi

# Display compiler version information.

gccversion : 

	@$(CC) --version

# Program the device.  

program: $(TARGET).hex $(TARGET).eep

	$(AVRDUDE) $(AVRDUDE_FLAGS) $(AVRDUDE_WRITE_FLASH) $(AVRDUDE_WRITE_EEPROM)

# Generate avr-gdb config/init file which does the following:

#     define the reset signal, load the target file, connect to target, and set 

#     a breakpoint at main().

gdb-config: 

	@$(REMOVE) $(GDBINIT_FILE)

	@echo define reset >> $(GDBINIT_FILE)

	@echo SIGNAL SIGHUP >> $(GDBINIT_FILE)

	@echo end >> $(GDBINIT_FILE)

	@echo file $(TARGET).elf >> $(GDBINIT_FILE)

	@echo target remote $(DEBUG_HOST):$(DEBUG_PORT)  >> $(GDBINIT_FILE)

ifeq ($(DEBUG_BACKEND),simulavr)

	@echo load  >> $(GDBINIT_FILE)

endif	

	@echo break main >> $(GDBINIT_FILE)

debug: gdb-config $(TARGET).elf

ifeq ($(DEBUG_BACKEND), avarice)

	@echo Starting AVaRICE - Press enter when "waiting to connect" message displays.

	@$(WINSHELL) /c start avarice --jtag $(JTAG_DEV) --erase --program --file \

	$(TARGET).elf $(DEBUG_HOST):$(DEBUG_PORT)

	@$(WINSHELL) /c pause

else

	@$(WINSHELL) /c start simulavr --gdbserver --device $(MCU) --clock-freq \

	$(DEBUG_MFREQ) --port $(DEBUG_PORT)

endif

	@$(WINSHELL) /c start avr-$(DEBUG_UI) --command=$(GDBINIT_FILE)

# Convert ELF to COFF for use in debugging / simulating in AVR Studio or VMLAB.

COFFCONVERT=$(OBJCOPY) --debugging \

--change-section-address .data-0x800000 \

--change-section-address .bss-0x800000 \

--change-section-address .noinit-0x800000 \

--change-section-address .eeprom-0x810000 

coff: $(TARGET).elf

	@echo

	@echo $(MSG_COFF) $(TARGET).cof

	$(COFFCONVERT) -O coff-avr $< $(TARGET).cof

extcoff: $(TARGET).elf

	@echo

	@echo $(MSG_EXTENDED_COFF) $(TARGET).cof

	$(COFFCONVERT) -O coff-ext-avr $< $(TARGET).cof

# Create final output files (.hex, .eep) from ELF output file.

%.hex: %.elf

	@echo

	@echo $(MSG_FLASH) $@

	$(OBJCOPY) -O $(FORMAT) -R .eeprom $< $@

%.eep: %.elf

	@echo

	@echo $(MSG_EEPROM) $@

	-$(OBJCOPY) -j .eeprom --set-section-flags=.eeprom="alloc,load" \

	--change-section-lma .eeprom=0 -O $(FORMAT) $< $@

# Create extended listing file from ELF output file.

%.lss: %.elf

	@echo

	@echo $(MSG_EXTENDED_LISTING) $@

	$(OBJDUMP) -h -S $< > $@

# Create a symbol table from ELF output file.

%.sym: %.elf

	@echo

	@echo $(MSG_SYMBOL_TABLE) $@

	$(NM) -n $< > $@

# Link: create ELF output file from object files.

.SECONDARY : $(TARGET).elf

.PRECIOUS : $(OBJ)

%.elf: $(OBJ)

	@echo

	@echo $(MSG_LINKING) $@

	$(CC) $(ALL_CFLAGS) $^ --output $@ $(LDFLAGS)

# Compile: create object files from C source files.

%.o : %.c

	@echo

	@echo $(MSG_COMPILING) $<

	$(CC) -c $(ALL_CFLAGS) $< -o $@ 

# Compile: create assembler files from C source files.

%.s : %.c

	$(CC) -S $(ALL_CFLAGS) $< -o $@

# Assemble: create object files from assembler source files.

%.o : %.S

	@echo

	@echo $(MSG_ASSEMBLING) $<

	$(CC) -c $(ALL_ASFLAGS) $< -o $@

# Create preprocessed source for use in sending a bug report.

%.i : %.c

	$(CC) -E -mmcu=$(MCU) -I. $(CFLAGS) $< -o $@ 

# Target: clean project.

clean: begin clean_list end

clean_list :

	@echo

	@echo $(MSG_CLEANING)

	$(REMOVE) $(TARGET).hex

	$(REMOVE) $(TARGET).eep

	$(REMOVE) $(TARGET).cof

	$(REMOVE) $(TARGET).elf

	$(REMOVE) $(TARGET).map

	$(REMOVE) $(TARGET).sym

	$(REMOVE) $(TARGET).lss

	$(REMOVE) $(OBJ)

	$(REMOVE) $(LST)

	$(REMOVE) $(SRC:.c=.s)

	$(REMOVE) $(SRC:.c=.d)

	$(REMOVE) .dep/*

# Include the dependency files.

-include $(shell mkdir .dep 2>/dev/null) $(wildcard .dep/*)

# Listing of phony targets.

.PHONY : all begin finish end sizebefore sizeafter gccversion \

build elf hex eep lss sym coff extcoff \

clean clean_list program debug gdb-config

#ifndef _LOCALIZATION_H_

#define _LOCALIZATION_H_

// Max number of robots possible

#define MAX_ROBOTS 4

unsigned char sensors[MAX_ROBOTS][MAX_ROBOTS];

typedef struct{

  //actual row of sensor values -- need to be able to have up to

  //max_robots

  unsigned char row[MAX_ROBOTS];

  //actual length of the row

  unsigned char len;

  //'index' value of the row -- which robot it's for

  unsigned char row_num;

} SensorRow;

void addSensor (int maxBom, int self, int other, int NUM_BOTS);

unsigned char getSelfSensor (unsigned char self, unsigned char other, 

			     int NUM_BOTS);

#endif

/*

time.c

anything that requires a delay

mostly delay_ms

author: Robotics Club, Colony Project

*/

#include <avr/interrupt.h>

#include <avr/signal.h>

#include <avr/delay.h>

#include "time.h"

//#include "help.h"

#include "serial.h"

static volatile int _rtc_val = 0;

static void (*_rtc_f)(void) = 0;

/*

delay_ms

delays for ms milliseconds

accuracy is unknown (off by tens of nanoseconds every 15 ms)

*/

void delay_ms(int ms) 

{

	for(; ms > 15; ms-=15)

		_delay_ms(15);

	_delay_ms(ms);

}

void pause_ms(int ms)

{

	delay_ms(ms);

}

void pause(int ms)

{

	delay_ms(ms);

}

void sleep_ms(int ms)

{

	delay_ms(ms);

}

void sleep(int ms)

{

	delay_ms(ms);

}

/*

void rtc_init(void)

call this function to start the real time timer

use rtc() to get the time value and rtc_resest() to reset

requires global interrupts to be enabled for proper use

(I bit of SREG register should be set)

uses TIMER0 on asynchronous mode

*/

void rtc_init(int prescale_opt, unsigned char ocr_val, void (*rtc_func)(void)){

	int mask = _BV(TCN0UB) + _BV(OCR0UB) + _BV(TCR0UB);

	char tmp;

	TIMSK &= ~(_BV(OCIE0) + _BV(TOIE0)); //1. disable interrupts

	ASSR |= _BV(AS0); //2. selecting clock source (external)

	//3. writing new values to TCCR, TCNT, OCR

	TCNT0 = 0;

	OCR0 = ocr_val;

	TCCR0 = (0x01 << 3) + (prescale_opt & 0x07); //setting CTC mode, prescaler is lowest 3 bits

	//4. waiting for busy bits to clear

	tmp = ASSR;

	while( tmp & mask ){

		tmp = ASSR;

	}

	TIFR &= ~(_BV(OCF0) + _BV(TOV0)); //5. clearing the interrupt flags

	TIMSK |= _BV(OCIE0); // + _BV(TOIE0); //6. enabling interrupts

	_rtc_f = rtc_func;

}

int rtc(void){

	return _rtc_val;

}

void rtc_reset(void){

	_rtc_val = 0;

}

SIGNAL (SIG_OUTPUT_COMPARE0){

	_rtc_val++;

	if(_rtc_f != 0)

		_rtc_f();

}

/*  

	servo.c - Contains functions and interrupts necessary to activate servos

	author:  Tom Lauwers

	3/1/06 Iain

		Man, I don't know what a servo is. 

*/

#include <avr/io.h>

#include <avr/signal.h>

#include "servo.h"

#include "dio.h"

#include "lights.h"

#include "lcd.h"

//16000 c/ms

//i dunno must be 2^k

//9C40 ~ 20ms

//#A000 ~ 20.48 but prolly wont work

#define SERVO_PERIOD 0xA000

//needs be 1ms

//is 1.024ms

#define SERVO_CONSTANT 0x800

/* dirty dirty

unsigned int servo_vals[4] = {0,0,0,0}; // Stores the set servo values

int current_servo = 0;  // Stores which servo is current in the interrupt routine

*/

unsigned int servo_vals[8] = {0,0,0,0,0,0,0,0}; // Stores the set servo values

int phase_time=0;

int phase_base=0;

int servos_on = 0;      // Stores which servos are enabled

int servos_enabled=0; //which are high

int servo_flag = 0;     // Stores whether or not servos are enabled

/* Timer 1 output compare B interrupt.  Does the following:

	Checks to see if the current servo is 4, in which case just need

	to set low servo 3's signal and return.

	Else, check to see if the current servo is enabled, and set it's signal high

	Then, set the previous servo's signal low

	Now, set the next output compare to occur for some time from now 

	specified by the current servo's value

*/

SIGNAL (SIG_OUTPUT_COMPARE3B)

{

	lcd_putchar('i');

	if(servo_flag == 0)

		return;

	int i;

	if(phase_time == 0){

		lcd_putchar('p');

		for(i=0;i<8;i++){

			if(servos_on & _BV(i))

				digital_output((_PORT_E << 3) +i,1);

		}

		servos_enabled = servos_on;

		phase_base = OCR3B;

	}

	unsigned int min=~0;

	for(i=0;i<8;i++){

		if(_BV(i) & servos_enabled){

			if(SERVO_CONSTANT*servo_vals[i] <= phase_time){

				digital_output((_PORT_E << 3) + i,0);

				servos_enabled &= ~_BV(i);

			}

			else if(SERVO_CONSTANT*servo_vals[i] < min) {

				min = servo_vals[i];

			}

		}

	}

	if(!servos_enabled){

		OCR3B = phase_base + SERVO_PERIOD;

		phase_time = 0;

	}

	else {

		OCR3B = phase_base + min;

		phase_time = min;

	}

}	

//currently the light must be initted b4

void init_servo()

{

	//1010 1001

	TCCR3A = 0;  // COM## set to noninvert, WGM 1:0 set to 1

	//0000 1100

	TCCR3B = 0x02;  // High bits to 0, WGM 3:2 set to 1, prescaler to 8

	lcd_init();

	ETIMSK |= 0x08;

	servo_flag = 1;

	OCR3B = 0x80;

	lcd_putchar('i');

}

// Enable a servo specified by config

void enable_servo(int config)

{

	servos_on |= _BV(config);

}

// Disable a servo specified by config

void disable_servo(int config)

{

	servos_on &= (0xFF-_BV(config));

}

// Disables the timer1 interrupt, disabling the servos

void disable_servos()

{

	// Disables interrupts

	ETIMSK &= ~0x08;

	servo_flag=0;

}

// Enables the timer1 interrupt, enabling the servos

void enable_servos()

{

	// Enable interrupts on output compare B

	ETIMSK |= 0x08;

	servo_flag=1;

}

// Set a servo to a value.  Automatically enables the servo.

void set_servo(int servo, int value)

{

	enable_servo(servo);

	servo_vals[servo] = value;

}

#include "firefly+_lib.h"

void serial_test( void );

void lcd_test(void);

void orb_test( void );

void motor_test (void) {

}

void orb_test( void ) {

	int orbs[13] = { ORB_OFF, RED, ORANGE, YELLOW, LIME, GREEN, CYAN, BLUE, PURPLE, PINK, PURPLE, MAGENTA, WHITE };

	int orb_select = 0;

	orb_init();

	while(1) {

		orb_set_color(orbs[orb_select]);

		delay_ms(1000);

		orb_select++;

		if(orb_select == 14)

			orb_select = 0;

	}

	return;

}

void lcd_test(void) {

	int i;

	lcd_init();

	for(i = 32; i <= 126; i++) {

		lcd_putchar(i);

		delay_ms(250);

	}

	return;

}

/*

prints all printable characters to the serial

baud rate is 115200

*/

void serial_test( void ) {

	int i;

	serial_init(BAUD115200);

	for(i = 32; i <= 126; i++) {

		serial_putchar(i);

		delay_ms(250);

	}

	return;

}

/*

	analog.c - Contains the function implementations for manipulating the ADC

	on the firefly+ board

	author:  CMU Robotics Club, Colony Project

	code mostly taken from fwr analog file (author: Tom Lauwers)

*/

#include <avr/delay.h>

#include <avr/interrupt.h>

#include <avr/signal.h>

#include "analog.h"

void analog_init(void){

	/*

		ADC Status Register A

		Bit 7 - ADEN is set (enables analog)

		Bit 6 - Start conversion bit is set (must be done once for free-running mode)

		Bit 5 - Enable Auto Trigger (for free running mode)

		Bit 3 - Enable ADC Interrupt (required to run free-running mode)

		Bits 2-0 - Set to create a clock divisor of 128, to make ADC clock = 16,000,000/128

	*/

	ADCSRA |= 0xEF;

	/*

		ADMUX register

		Bit 7,6 - Set voltage reference to AVcc (0b01)

		Bit 5 - Set ADLAR bit for left adjust to do simple 8-bit reads

		Bit 4 - X

		Bit 3:0 - Sets the current channel

	*/

	ADMUX = 0x67;

}	

unsigned int analog8(int which){

	ADMUX = 0x60 + which;

	_delay_ms(1); // need at least 130 us between conversions (for fwr robot, how much for new avr?)

	return ADCH;

}

unsigned int analog10(int which){

	unsigned int adc_h = 0;

	unsigned int adc_l = 0;

	ADMUX = 0x60 + which;

	_delay_ms(1);

	adc_l = ADCL; /* highest 2 bits of ADCL -> least 2 bits of analog val */

	adc_h = ADCH; /* ADCH -> 8 highest bits of analog val */

	return (adc_h << 2) | (adc_l >> 6);

}

int wheel(void){

	return analog8(WHEEL_PORT);

}

int battery(void){

	return analog8(BATT_PORT) * 500 / 255; /* 5 volts is the max, 255 is the max 8bit number */

}

SIGNAL (SIG_ADC)

{

	// This is just here to catch ADC interrupts because ADC is free running.  

	// No code needs to be in here.

}

/*

lcd-ar2.c - implementation for lcd functions

Author: CMU Robotics Club, Colony Project

This uses SPI.

lcd_init MUST be called before anything can be used.

*/

#include <avr/io.h>

#include "lcd.h"

#include "time.h"

/*

FontLookup - a lookup table for all characters

*/

static const unsigned char FontLookup [][5] =

{

    { 0x00, 0x00, 0x00, 0x00, 0x00 },  // sp

    { 0x00, 0x00, 0x5f, 0x00, 0x00 },   // !

    { 0x00, 0x07, 0x00, 0x07, 0x00 },   // "

    { 0x14, 0x7f, 0x14, 0x7f, 0x14 },   // #

    { 0x24, 0x2a, 0x7f, 0x2a, 0x12 },   // $

	{ 0x23, 0x13, 0x08, 0x64, 0x62 },   // %

    { 0x36, 0x49, 0x55, 0x22, 0x50 },   // &

    { 0x00, 0x05, 0x03, 0x00, 0x00 },   // '

    { 0x00, 0x1c, 0x22, 0x41, 0x00 },   // (

    { 0x00, 0x41, 0x22, 0x1c, 0x00 },   // )

    { 0x14, 0x08, 0x3E, 0x08, 0x14 },   // *

    { 0x08, 0x08, 0x3E, 0x08, 0x08 },   // +

    { 0x00, 0x00, 0x50, 0x30, 0x00 },   // ,

    { 0x10, 0x10, 0x10, 0x10, 0x10 },   // -

    { 0x00, 0x60, 0x60, 0x00, 0x00 },   // .

    { 0x20, 0x10, 0x08, 0x04, 0x02 },   // /

    { 0x3E, 0x51, 0x49, 0x45, 0x3E },   // 0

    { 0x00, 0x42, 0x7F, 0x40, 0x00 },   // 1

    { 0x42, 0x61, 0x51, 0x49, 0x46 },   // 2

    { 0x21, 0x41, 0x45, 0x4B, 0x31 },   // 3

    { 0x18, 0x14, 0x12, 0x7F, 0x10 },   // 4

    { 0x27, 0x45, 0x45, 0x45, 0x39 },   // 5

    { 0x3C, 0x4A, 0x49, 0x49, 0x30 },   // 6

    { 0x01, 0x71, 0x09, 0x05, 0x03 },   // 7

    { 0x36, 0x49, 0x49, 0x49, 0x36 },   // 8

    { 0x06, 0x49, 0x49, 0x29, 0x1E },   // 9

    { 0x00, 0x36, 0x36, 0x00, 0x00 },   // :

    { 0x00, 0x56, 0x36, 0x00, 0x00 },   // ;

    { 0x08, 0x14, 0x22, 0x41, 0x00 },   // <

    { 0x14, 0x14, 0x14, 0x14, 0x14 },   // =

    { 0x00, 0x41, 0x22, 0x14, 0x08 },   // >

    { 0x02, 0x01, 0x51, 0x09, 0x06 },   // ?

    { 0x32, 0x49, 0x59, 0x51, 0x3E },   // @

    { 0x7E, 0x11, 0x11, 0x11, 0x7E },   // A

    { 0x7F, 0x49, 0x49, 0x49, 0x36 },   // B

    { 0x3E, 0x41, 0x41, 0x41, 0x22 },   // C

    { 0x7F, 0x41, 0x41, 0x22, 0x1C },   // D

    { 0x7F, 0x49, 0x49, 0x49, 0x41 },   // E

    { 0x7F, 0x09, 0x09, 0x09, 0x01 },   // F

    { 0x3E, 0x41, 0x49, 0x49, 0x7A },   // G

    { 0x7F, 0x08, 0x08, 0x08, 0x7F },   // H

    { 0x00, 0x41, 0x7F, 0x41, 0x00 },   // I

    { 0x20, 0x40, 0x41, 0x3F, 0x01 },   // J

    { 0x7F, 0x08, 0x14, 0x22, 0x41 },   // K

    { 0x7F, 0x40, 0x40, 0x40, 0x40 },   // L

    { 0x7F, 0x02, 0x0C, 0x02, 0x7F },   // M

    { 0x7F, 0x04, 0x08, 0x10, 0x7F },   // N

    { 0x3E, 0x41, 0x41, 0x41, 0x3E },   // O

    { 0x7F, 0x09, 0x09, 0x09, 0x06 },   // P

    { 0x3E, 0x41, 0x51, 0x21, 0x5E },   // Q

    { 0x7F, 0x09, 0x19, 0x29, 0x46 },   // R

    { 0x46, 0x49, 0x49, 0x49, 0x31 },   // S

    { 0x01, 0x01, 0x7F, 0x01, 0x01 },   // T

    { 0x3F, 0x40, 0x40, 0x40, 0x3F },   // U

    { 0x1F, 0x20, 0x40, 0x20, 0x1F },   // V

    { 0x3F, 0x40, 0x38, 0x40, 0x3F },   // W

    { 0x63, 0x14, 0x08, 0x14, 0x63 },   // X

    { 0x07, 0x08, 0x70, 0x08, 0x07 },   // Y

    { 0x61, 0x51, 0x49, 0x45, 0x43 },   // Z

    { 0x00, 0x7F, 0x41, 0x41, 0x00 },   // [

    { 0x02, 0x04, 0x08, 0x10, 0x20 },   // backslash

    { 0x00, 0x41, 0x41, 0x7F, 0x00 },   // ]

    { 0x04, 0x02, 0x01, 0x02, 0x04 },   // ^

    { 0x40, 0x40, 0x40, 0x40, 0x40 },   // _

    { 0x00, 0x01, 0x02, 0x04, 0x00 },   // '

    { 0x20, 0x54, 0x54, 0x54, 0x78 },   // a

    { 0x7F, 0x48, 0x44, 0x44, 0x38 },   // b

    { 0x38, 0x44, 0x44, 0x44, 0x20 },   // c

    { 0x38, 0x44, 0x44, 0x48, 0x7F },   // d

    { 0x38, 0x54, 0x54, 0x54, 0x18 },   // e

    { 0x08, 0x7E, 0x09, 0x01, 0x02 },   // f

    { 0x0C, 0x52, 0x52, 0x52, 0x3E },   // g

    { 0x7F, 0x08, 0x04, 0x04, 0x78 },   // h

    { 0x00, 0x44, 0x7D, 0x40, 0x00 },   // i

    { 0x20, 0x40, 0x44, 0x3D, 0x00 },   // j

    { 0x7F, 0x10, 0x28, 0x44, 0x00 },   // k

    { 0x00, 0x41, 0x7F, 0x40, 0x00 },   // l

    { 0x7C, 0x04, 0x18, 0x04, 0x78 },   // m

    { 0x7C, 0x08, 0x04, 0x04, 0x78 },   // n

    { 0x38, 0x44, 0x44, 0x44, 0x38 },   // o

    { 0x7C, 0x14, 0x14, 0x14, 0x08 },   // p

    { 0x08, 0x14, 0x14, 0x18, 0x7C },   // q

    { 0x7C, 0x08, 0x04, 0x04, 0x08 },   // r

    { 0x48, 0x54, 0x54, 0x54, 0x20 },   // s

    { 0x04, 0x3F, 0x44, 0x40, 0x20 },   // t

    { 0x3C, 0x40, 0x40, 0x20, 0x7C },   // u

    { 0x1C, 0x20, 0x40, 0x20, 0x1C },   // v

    { 0x3C, 0x40, 0x30, 0x40, 0x3C },   // w

    { 0x44, 0x28, 0x10, 0x28, 0x44 },   // x

    { 0x0C, 0x50, 0x50, 0x50, 0x3C },   // y

    { 0x44, 0x64, 0x54, 0x4C, 0x44 },    // z

    { 0x00, 0x08, 0x36, 0x41, 0x41 },   // {

    { 0x00, 0x00, 0x7F, 0x00, 0x00 },   // |

    { 0x41, 0x41, 0x36, 0x08, 0x00 },   // }

    { 0x02, 0x01, 0x01, 0x02, 0x01 },   // ~

    { 0x55, 0x2A, 0x55, 0x2A, 0x55 },   // del

};

/*

initializes the LCD

*/

void lcd_init(void)

{

	LCDDDR |= (D_C | SCE | SDI | SCK);

	LCDRESETDDR |= RST;

	LCDPORT &= ~(D_C | SCE | SDI | SCK);

	SPCR |= 0b01010000; // no SPI int, SPI en, Master, sample on rising edge, fosc/2

	SPSR |= 0x01;       // a continuation of the above

	LCDRESETPORT |= RST;

	delay_ms(10);

	LCDRESETPORT &= (~RST);

	delay_ms(100);

	LCDRESETPORT |= RST;

    lcd_putbyte( 0x21 );  // LCD Extended Commands.

    lcd_putbyte( 0xC8 );  // Set LCD Vop (Contrast).

    lcd_putbyte( 0x06 );  // Set Temp coefficent.

    lcd_putbyte( 0x13 );  // LCD bias mode 1:48.

    lcd_putbyte( 0x20 );  // LCD Standard Commands, Horizontal addressing mode.

    lcd_putbyte( 0x0C );  // LCD in normal mode.

	LCDPORT |= D_C;		//put it in init instead of main

	lcd_clear_screen();

}

/*

clear the lcd screen

*/

void lcd_clear_screen( void ) {

	int i;

	for (i = 0; i < 504; i++)

			lcd_putbyte(0x0);

	lcd_gotoxy(0,0);

}

/*

print a byte on the lcd screen

*/

void lcd_putbyte(unsigned char b)

{

	SPDR = b;

	while (!(SPSR & 0x80)); /* Wait until SPI transaction is complete */

}

/*

print a character on the lcd

*/

void lcd_putchar(char c)

{

	int i;

	for (i = 0; i < 5; i++)

		lcd_putbyte(FontLookup[c-32][i]);

	lcd_putbyte(0);

}

/*

print an entire string to the lcd

*/

void lcd_putstr(char *s)

{

	char *t = s;

	while (*t != 0)

	{

		lcd_putchar(*t);

		t++;

	}

}

/*

go to coordinate x, y

y: vertically - 1 char

x: horizontally - 1 pixel

multiply x by 6 if want to move 1 entire character

origin (0,0) is at top left corner of lcd screen

*/

void lcd_gotoxy(int x, int y)

{

  LCDPORT &= ~(D_C);

  lcd_putbyte(0x40 | (y & 0x07));

  lcd_putbyte(0x80 | (x & 0x7f));

  LCDPORT |= D_C;

}

/*

prints an int to the lcd

code adapted from Chris Efstathiou's code (hendrix@otenet.gr)

*/

void lcd_putint(int value ) {

	unsigned char lcd_data[6]={'0','0','0','0','0','0' }, position=sizeof(lcd_data), radix=10; 

        /* convert int to ascii  */ 

        if(value<0) { lcd_putchar('-'); value=-value; }    

        do { position--; *(lcd_data+position)=(value%radix)+'0'; value/=radix;  } while(value); 

        /* start displaying the number */

        for(;position<=(sizeof(lcd_data)-1);position++)

          {

            lcd_putchar(lcd_data[position]);

          }

return;

}

/*  

	servo.h - Contains function prototypes for servo activation

	author:  Tom Lauwers

*/

#ifndef _SERVO_H_

#define _SERVO_H_

// Information on functions available in servo.c

void init_servo(void);

void enable_servos(void);

void enable_servo(int config);

void set_servo(int servo, int value);

void disable_servos(void);

void disable_servo(int );

#endif

/*

time.h

provisional (Suresh)

*/

#ifndef _TIME_H_

#define _TIME_H_

#define TIMER_OFF         0x00

#define PRESCALE_NONE     0x01

#define PRESCALE_DIV_8    0x02

#define PRESCALE_DIV_32   0x03

#define PRESCALE_DIV_64   0x04

#define PRESCALE_DIV_128  0x05

#define PRESCALE_DIV_256  0x06

#define PRESCALE_DIV_1024 0x07

/*

delay_ms(int ms)

pause_ms(int ms)

sleep_ms(int ms)

pause(int ms)

sleep(int ms)

all have the same behavior

pauses the calling process for the specified

amount of time in milliseconds

*/

void delay_ms(int ms) ;

void pause_ms(int ms);

void pause(int ms);

void sleep_ms(int ms);

void sleep(int ms);

/*

void rtc_init(void)

call this function to initialize the real time clock

real time clock requires global interrupts to be enabled

*/

void rtc_init(int prescale_opt, unsigned char ocr_val, void (*rtc_func)(void));

/*

void rtc_reset(void)

use this to reset the real time value

rtc_init() should be called beforehand

*/

void rtc_reset(void);

/*

int rtc(void)

returns the current value of the real time clock (in seconds)

rtc_init() should be called beforehand

the returned amount is the number of seconds that have past since the

last call to rtc_init() or rtc_reset()

*/

int rtc(void);

#endif

/** @file colonet.c

 * @brief Colonet library for colony robots

 * @author Eugene Marinelli

 * @date 10/26/06

 * 

 * @bug Handler registration not tested

 * @bug Request reponding not implemented - only accepts commands.

 */

#include <firefly+_lib.h>

#include "colonet.h"

typedef struct {

  unsigned char msgId; //is this necessary?

  void (*handler)(void);

} UserHandler;

/* Globals (internal) */

static UserHandler user_handlers[USER_DEFINED_MSG_TOTAL];

/* Internal function prototypes */

void packet_string_to_struct(ColonetPacket* dest_pkt, char* pkt_buf);

unsigned int two_bytes_to_int(char high, char low);

/* Public functions */

int colonet_handle_message(unsigned char robot_id, char* pkt_buf)

{

  ColonetPacket pkt;

  unsigned char* args; //up to 7 char args

  unsigned int int_args[3]; //up to 3 int (2-byte) args

  packet_string_to_struct(&pkt, pkt_buf);

  if(pkt.msg_dest != GLOBAL_DEST && pkt.msg_dest != robot_id){ 

    //message not intended for us

    return 1;

  }

  args = pkt.data;

  /* Hack - could be done more 1337ly with casting, but this way we don't have

   * to worry about little/big endian stuff */

  int_args[0] = two_bytes_to_int(args[0], args[1]);

  int_args[1] = two_bytes_to_int(args[2], args[3]);

  int_args[2] = two_bytes_to_int(args[4], args[5]);

  if(pkt.msg_type == COLONET_REQUEST){

    switch(pkt.msg_code){

      //Sharp

    case READ_DISTANCE:

      break;

    case LINEARIZE_DISTANCE:

      break;

    case LOG_DISTANCE:

      break;

      //Serial

    case SERIAL_GETCHAR:

      break;

    case SERIAL_GETCHAR_NB:

      break;

    case SERIAL1_GETCHAR:

      break;

    case SERIAL1_GETCHAR_NB:

      break;

      //Analog

    case ANALOG8:

      break;

    case ANALOG10:

      break;

    case WHEEL:

      break;

    case BATTERY:

      break;

      //BOM

    case GETMAXBOM:

      break;

      //Dio

    case DIGITAL_INPUT:

      break;

    case BUTTON1_READ:

      break;

    case BUTTON2_READ:

      break;

      //Bumper

    case DETECT_BUMP:

      break;

    }

    /* TODO - send back data! */

  }else if(pkt.msg_type == COLONET_COMMAND){

    if(pkt.msg_code >= USER_DEFINED_MSG_ID_START && 

       pkt.msg_code <= USER_DEFINED_MSG_ID_END){

      if (user_handlers[pkt.msg_code - USER_DEFINED_MSG_ID_START].handler) {

        /* Call the user's handler function if it the function's address

         * is non-zero (has been set) */

        user_handlers[pkt.msg_code - USER_DEFINED_MSG_ID_START].handler();

      }

      return 0;

    }

    switch(pkt.msg_code){

    default:

      printf("%s: Error - message code %d not implemented\n", __FUNCTION__,

             pkt.msg_code);

      return -1;

      break;

      //Buzzer

    case BUZZER_INIT:

      buzzer_init();

      break;

    case BUZZER_SET_VAL:

      buzzer_set_val(args[0]);

      break;

    case BUZZER_SET_FREQ:

      buzzer_set_freq(args[0]);

      break;

    case BUZZER_CHIRP:

      buzzer_chirp(int_args[0], int_args[1]);

      break;

    case BUZZER_OFF:

      buzzer_off();

      break;

      //LCD

    case LCD_INIT:

      lcd_init();

      break;

    case LCD_CLEAR_SCREEN:

      lcd_clear_screen();

      break;

    case LCD_PUTBYTE:

      lcd_putbyte(args[0]);

      break;

    case LCD_PUTCHAR:

      lcd_putchar((char)args[0]);

      break;

    case LCD_PUTSTR:

      lcd_putstr((char*)args);

      break;

    case LCD_GOTOXY: 

      lcd_gotoxy(int_args[0], int_args[1]);

      break;

    case LCD_PUTINT: 

      lcd_putint(int_args[0]);

      break;

    case ORB_INIT:

      orb_init();

      break;

      //Orb

    case ORB_SET:

      orb_set(args[0], args[1], args[2]);

      break;

    case ORB_SET_COLOR:

      orb_set_color(int_args[0]);

      break;

    case ORB_DISABLE:

      orb_disable();

      break;

    case ORB_ENABLE:

      orb_enable();

      break;

    case ORB_SET_DIO:

      orb_set_dio(int_args[0], int_args[1], int_args[2]);

      break;

    case LED_INIT:

      led_init();

      break;

    case LED_USER:

      led_user(int_args[0]);

      break;

    case ORB_SEND:

      //orb_send();

      break;

      //Motors

    case MOTORS_INIT:

      motors_init();

      break;

    case MOTOR1_SET:

      motor1_set(int_args[0], int_args[1]);

      break;

    case MOTOR2_SET:

      motor2_set(int_args[0], int_args[1]);

      break;

    case MOTORS_OFF:

      motors_off();

      break;

      /*

    case MOVE:

      break;

      */

      //SERIAL

    case SERIAL_INIT:

      serial_init(int_args[0]);

      break;

    case SERIAL_PUTCHAR:

      serial_putchar((char)args[0]);

      break;

    case SERIAL1_INIT:

      serial1_init(int_args[0]);

      break;

    case SERIAL1_PUTCHAR:

      serial1_putchar((char)args[0]);

      break;

    case PRINTF:

      printf("%s", pkt.data);

      break;

    case KILL_ROBOT:

      motors_off();

      buzzer_off();

      exit(0); //kill the robot

      break;

      //Time

    case DELAY_MS:

      delay_ms(int_args[0]);

      break;

      //Analog

    case ANALOG_INIT:

      analog_init();

      break;