Colony

/*

lights.h

most of this is shamelessly copied from FWR's orb.h (Tom Lauwers and Steven Shamlian)

author: CMU Robotics Club, Colony Project

*/

#ifndef _LIGHTS_H_

#define _LIGHTS_H_

//user LED

#ifdef FFPP

#define USERLED 15

#define USERLED1 15

#define USERLED2 31

#else

#define USERLED PING2

#define USERLED1 PING2

#define USERLED2 PING2 //only have 1

//LEDs are on bank E

#define REDLED   PE3

#define GREENLED PE4

#define BLUELED  PE5

#endif

//ORB

#define RED       0xE0

#define ORANGE    0xE8

#define YELLOW    0xFC

#define LIME      0x7C

#define GREEN     0x1C

#define CYAN      0x1F

#define BLUE      0x03

#define PINK      0x63

#define PURPLE    0x23

#define MAGENTA   0xE3

#define WHITE     0xFF

#define ORB_OFF   0x00

//?

#define COUNT_START 0x8000

//user LED

void led_init( void );

void led_user(int value);

// For function descriptions see orb.c 

void orb_init(void);

void orb_set(unsigned int red_led, unsigned int green_led, unsigned int blue_led); 

void orb_set_color(int col);

void orb_disable(void);

void orb_enable(void);

void orb_set_dio(int red, int green, int blue);

#ifdef FFPP

int orbs[32];

//send now

void orb_set_num(unsigned char num, unsigned int red_led, unsigned int green_led, unsigned int blue_led);

//no send

void orb_set_num_ns(unsigned char num, unsigned int red_led, unsigned int green_led, unsigned int blue_led);

//force send

void orb_send(void);

void tlc5940test(void);

void tlc_clock1(int data);//may not need these 2

void tlc_clock2(int data);

void tlc_send(void);

void tlc_latch(void);

void tlc5940init(void);

#endif

#endif

/*

	motor.c - Contains functions necessary for activating and driving the 

	H-bridge

	author: Robotics Club, Colony project

	much of this is taken from FWR's library, author: Tom Lauwers

*/

#include "motor.h"

/*

motor initialization

initializes both motors

*/

void motors_init( void ) {

#ifndef FFPP

	// Configure counter such that we use phase correct

	// PWM with 8-bit resolution

	DDRB |= 0x60;

	//timer 1A and 1B

	TCCR1A = 0xA1;

	TCCR1B = 0x04;

	OCR1AH=0;

	OCR1AL=0;

	OCR1BH=0;

	OCR1BL=0;

#else

	// Configure counter such that we use phase correct

	// PWM with 8-bit resolution at a frequency of

	// PWM is mode 1, Freq = Clock I/O/1024. 

	// OC1A and OC1B as pwm.

	OCR1A = 0x00;

	OCR1B = 0x00;

	PORTD &= 0x0F;

	DDRD |= 0xF0;

	DDRB |= 0x60;

	TCCR1A = 0xA1;

	TCCR1B = 0x05;

#endif

}

// The following functions set the motor direction and speed

void motor1_set(int direction, int speed) {

#ifndef FFPP

	if(direction == 0) {

		PORTD |= 0x10;

		PORTD &= 0xBF;

	}

	else {

		PORTD |= 0x40;

		PORTD &= 0xEF;

	}

	// Set the timer to count up to speed, an 8-bit value

	OCR1AL = speed;

#else

	if(direction == FORWARD) {

		PORTD = (PORTD & 0xCF) | 0x20;

	}

	else {

		PORTD = (PORTD & 0xCF) | 0x10;

	}

	// Set the timer to count up to speed, an 8-bit value

	OCR1A = speed;

#endif

}

void motor2_set(int direction, int speed) {

#ifndef FFPP

	if(direction == 0) {

		PORTD |= 0x20;

		PORTD &= 0x7F;

	}

	else {

		PORTD |= 0x80;

		PORTD &= 0xDF;

	}

	OCR1BL = speed;

#else

	if(direction != FORWARD) {

		PORTD = (PORTD & 0x3F) | 0x80;

	}

	else {

		PORTD = (PORTD & 0x3F) | 0x40;

	}

	OCR1B = speed;

#endif

}

// Just turns off both motors

void motors_off( void ) {

	OCR1AL = 0x0;

	OCR1BL = 0x0;

}

#include "firefly+_lib.h"

#include "follow.h"

#define FWD 0

#define BCK 1    

#define TOTAL 16

/*

int find_max

returns the index of the BOM with the highest reading

* note: index, not value

*/

void seek(int relative_position) 

{

	int speed = 255;

	//MOTOR1 - left

	//MOTOR2 - right

	if(relative_position < 5 || relative_position > 13)

	{ //turn right

		motor2_set(BCK, 0);

		motor1_set(FWD, speed);

	}

	else if(relative_position > 5 && relative_position <= 13)

	{ //turn left

		motor2_set(FWD, speed);

		motor1_set(BCK, 0);

	}

	else 

	{ //go forward

		//turn_off_motors();

		motor1_set(FWD, speed);

		motor2_set(FWD, speed);

	}

}

void drive_forward (void)

{

    int speed = 255;

    motor1_set(FWD, speed);

    motor2_set(FWD, speed);

}

#ifndef WIRELESS_H

#define WIRELESS_H

/*

Wireless - wireless functions for Colony

Eugene Marinelli

7/22/06

*/

#define WL_MSG_MAX_LEN 16

#define WL_PACKET_MAX_LEN (WL_MSG_MAX_LEN+5)

#define GLOBAL_DEST 200

typedef struct {

  char prefix[2];

  char src;

  char dest;

  char msg[WL_MSG_MAX_LEN];

  char checksum;

} WL_Packet;

int wl_init(int msg_len, char listener_address);

int wl_send(char* msg, char dest);

int wl_recv(char* msgbuf, char* src, char* dest);

// get most recent valid message - implement message queue later

int wl_create_packet(char* msg, char src, char dest, WL_Packet* packet);

char wl_get_checksum(WL_Packet* packet);

#endif

/*

	motor.h - Contains the function prototypes for controlling motors

	author:  Tom Lauwers

*/

#ifndef _MOTOR_H

#define _MOTOR_H

#include <avr/io.h>

#define FORWARD 1

#define BACKWARD 0

#ifdef FFPP

#define IN1A PD4

#define IN1B PD5

#define IN2A PD6

#define IN2B PD7

/* truth table for this robot (w/ 17529 and nand gates)

PWM	!A	!B	M+	M-

L	X	X   Z	Z  - coast

H	0	0	Z	Z  - coast

H	0	1	1	0  - forward

H	1	0	0	1  - backward

H	1	1	0	0  - fast brake

*/

#endif

// Function descriptions can be found in motor.c

void motors_init(void);

void motor1_set(int direction, int speed);

void motor2_set(int direction, int speed);

void motors_off( void );

#endif

#ifndef _FOLLOW_H

#define _FOLLOW_H

void seek(int velocity);

void drive_forward (void);

#endif

/*

Eugene Marinelli 

7/22/06

*/

/* Includes */

#include <stdio.h>

#include <string.h>

#include <firefly+_lib.h>

#include "pindefs_ff.h"

#include <wireless.h>

void init_hardware(void);

/* Main */

int main(void){

  char buf[80];

  char src, dest;

  init_hardware();

  wl_init(15,1);

  orb_set_color(BLUE);

  while(1){

    if(wl_recv(buf, &src, &dest)){

      printf("%s", buf);

      orb_set_color(RED);

    }else{

      printf(".");

      orb_set_color(BLUE);

    }

    wl_send("ABC", 200); 

    delay_ms(500);

  }

  return 0;

}

void init_hardware(){

  motors_init();

  orb_init();

  led_init();

  analog_init();

  serial_init(BAUD9600);

  serial1_init(BAUD115200);

  lcd_init();

  fdevopen(&serial1_putchar, &serial1_getchar);

}

/*

	serial.c - Functions for using the RS232 serial port

	author: Robotics Club, Colony Project

	much code taken from FWR's library, author: Tom Lauwers

	general note - serial -> uart

				   serial1 -> uart1

		this is done for clarity purposes

*/

#include <avr/io.h>

#include <stdio.h>

#include "serial.h"

//setup uart0 (serial)

void serial_init(unsigned int ubrr)

{

	/*Set baud rate - baud rates under 4800bps unsupported */

	UBRR0H = 0x00;

	UBRR0L = (unsigned char)ubrr;

	/*Enable receiver and transmitter */

	UCSR0B |= (1<<RXEN0)|(1<<TXEN0);

	/* Set frame format: 8data, 1stop bit, asynchronous normal mode */

	UCSR0C |= (1<<UCSZ00) | (1<<UCSZ01);

}

// uart_putchar - Low-level function which puts a value into the 

// Tx buffer for transmission.  Automatically injects

// a \r before all \n's

int serial_putchar(char c)

{

    if (c == '\n')

		putchar('\r');

	// Wait until buffer is clear for sending

    loop_until_bit_is_set(UCSR0A, UDRE0);

	// Load buffer with your character

    UDR0 = c;

    return 0;

}

// uart_getchar - Low-level function which waits for the Rx buffer

// to be filled, and then reads one character out of it.

// Note that this function blocks on read - it will wait until

// something fills the Rx buffer.

int serial_getchar(void)

{

	char c;

	// Wait for the receive buffer to be filled

    loop_until_bit_is_set(UCSR0A, RXC0);

	// Read the receive buffer

    c = UDR0;

	return c;

}

// uart_getchar_nb - Low-level function which checks if the Rx buffer

// is filled, and then reads one character out of it.

// This is a non blocking version uart_getchar

int serial_getchar_nb(void)

{

	char c;

	// Wait for the receive buffer to be filled

    //loop_until_bit_is_set(UCSR0A, RXC0);

	if (UCSR0A & _BV(RXC0)){

		// Read the receive buffer

		c = UDR0;

		return c;

	}

	return 0;

}

//setup uart1 (serial1)

void serial1_init( unsigned int ubrr)

{

	/*Set baud rate - baud rates under 4800bps unsupported */

	UBRR1H = 0x00;

	UBRR1L = (unsigned char)ubrr;

	/*Enable receiver and transmitter */

	UCSR1B |= (1<<RXEN1)|(1<<TXEN1);

	/* Set frame format: 8data, 1stop bit, asynchronous normal mode */

	UCSR1C |= (1<<UCSZ10) | (1<<UCSZ11);

  /* For use with fprintf() and related functions */

  serial1_stream = fdevopen(serial1_putchar, serial1_putchar);

  /* To use fprintf():

  After calling serial1_init(BAUD115200); 

  use the command fprintf(serial1_stream, "Hello World"); 

     This call to fdevopen() does give a compile warning

  but works fine.

  -Greg Tress

  */

}

//put to uart1 (serial1)

int serial1_putchar(char c)

{

    if (c == '\n')

		serial1_putchar('\r'); //changed from putchar aj

	// Wait until buffer is clear for sending

    loop_until_bit_is_set(UCSR1A, UDRE1);

	// Load buffer with your character

    UDR1 = c;

    return 0;

}

//get from uart1 (serial1)

int serial1_getchar(void)

{

	char c;

	// Wait for the receive buffer to be filled

    loop_until_bit_is_set(UCSR1A, RXC1);

	// Read the receive buffer

    c = UDR1;

	return c;

}

//get from uart1 non-block

int serial1_getchar_nb(void)

{

	char c;

	// Wait for the receive buffer to be filled

    //loop_until_bit_is_set(UCSR1A, RXC1);

	if (UCSR1A & _BV(RXC1)){

		// Read the receive buffer

		c = UDR1;

		return c;

	}

	return 0;

}

/*

	buzzer.c - Contains the functions necessary for running the buzzer

	author: Robotics Club, Colony Project

	much taken from FWR's firefly library (author: Tom Lauwers)

*/

#include <avr/io.h>

#include <buzzer.h>

#include <time.h>

/*

initializes buffer

this function must be called before the buzzer can be used

*/

void buzzer_init( void )

{

	// Set pin D7 to output - D7 is buzzer pin

	DDRB |= 0x80;

	// Set to Fast PWM mode, toggle the OC0A pin (D6) on output compare

	// matches, and select a clock prescalar of 64 for the counter.

	// Counter FREQ = 8000000/64 = 125000

	//01011000

	TCCR2 = 0x1B;

	OCR2=100;

}

// Set the buzzer value - takes a value from 0-255

// Higher values are lower frequency.  Take a look at 

// the buzzer frequency table to see how a given value

// correlates to a frequency.

void buzzer_set_val(unsigned int buzz_value)

{ 

	OCR2 = buzz_value;

}

// Set the buzzer frequency - takes any value and tries to find the nearest buzzer frequency

void buzzer_set_freq(unsigned int buzz_freq)

{

	int buzz_value;

	buzz_value = 62500/buzz_freq - 1;

	if(buzz_value > 255)

		buzz_value = 255;

	else if(buzz_value < 0)

		buzz_value = 0;

	buzzer_set_val(buzz_value);

}

// Chirps the buzzer for a number of milliseconds

void buzzer_chirp(unsigned int ms, unsigned int buzz_freq) 

{	

	buzzer_set_freq(buzz_freq);

	delay_ms(ms);

	buzzer_off();

}

// Disables timer0 clock counting, turning off the buzzer

void buzzer_off() 

{

	// Disable clock, to halt counter

	TCCR2 &= 0xF8;

	// Set buzzer pin low in case it's high

	PORTB &= 0x7F;

}

/*

	serial.h - Contains definitions and function prototypes for the RS232 serial port

*/

#ifndef _SERIAL_H

#define _SERIAL_H

// Tested baud rates

#define BAUD9600    103

#define BAUD115200  8  //Warning--3.5% error

// Untested baud rates that might be right --aaron

#define BAUD1M	     0

#define BAUD500K     1

#define BAUD250K     3

#define BAUD230400   3   //Warning--8.5% error

#define BAUD76800    12

#define BAUD57600    16  //Warning--2.1% error

#define BAUD38400    25

#define BAUD28800    34

#define BAUD19200    51

#define BAUD14400    68

#define BAUD4800     207

#define BAUD2400     416  //Might not work, since it needs some high bits set

#include <stdio.h>

FILE *serial1_stream;  //For use with fprintf() and related functions

  /* NOTE: To use fprintf():

  After calling serial1_init(BAUD115200); 

  use the command fprintf(serial1_stream, "Hello World"); */

// Function descriptions are available in serial.c

//serial (serial0) is the ttl serial (wireless)

void serial_init( unsigned int ubrr);

int serial_putchar(char c);

int serial_getchar(void);

int serial_getchar_nb(void);

//serial1 is the rs-232 port (db9 connector) (except on robot0 where both are serial0)

void serial1_init( unsigned int ubrr);

int serial1_putchar(char c);

int serial1_getchar(void);

int serial1_getchar_nb(void);

#endif

/*

	buzzer.h - Contains function prototypes for running the buzzer

	author: Robotics Club, Colony Project

*/

#ifndef _BUZZER_H_

#define _BUZZER_H_

//Musical note definitions

//Source: http://www.answers.com/topic/piano-key-frequencies

#define	C4	260 //Middle C

#define	C4s	277 //C sharp

#define	D4	294

#define	D4s	311

#define	E4	330

#define	F4	349

#define	F4s	370

#define	G4	392

#define	G4s	415

#define	A4	440

#define	A4s	466

#define	B4	494

#define	C5	523

// Function descriptions can be found in buzzer.c

void buzzer_init(void);

void buzzer_set_val(unsigned int buzz_value);

void buzzer_set_freq(unsigned int buzz_freq);

void buzzer_chirp(unsigned int ms, unsigned int buzz_freq);

void buzzer_off(void); 

#endif

#include "localization.h"

#include "firefly+_lib.h"

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

{

    //make sure you don't add to the diagonal

    if(self == other) {

      //lcd_putchar('w');

      return;

    }

    if(self >= NUM_BOTS || other >= NUM_BOTS)

    {

      // lcd_putchar('y');

      return;

    }

    //lcd_putchar('a');

    //lcd_putchar(self+48);

    //lcd_putchar(':');

    //lcd_putchar(other+48);

    //lcd_putchar('.');

    //add this robot to your own row's sensor numbers

    //row = your index

    //column = robotNum (input)

    sensors[self][other] = maxBom;

}

unsigned char getSelfSensor (unsigned char self, unsigned char other, int NUM_BOTS)

{

    if(other < NUM_BOTS){

        return sensors[self][other];

    }

    else {

        return 9;

    }

}

/*

void printSensorsMatrix (void)

{

    //print table

    int y = 1;

    lcd_gotoxy(0, y);

    int i, j;

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

        for(j = 0; j < NUM_BOTS; j++) {

            lcd_putchar( getSelfSensor(i, j, NUM_BOTS) + 48);

            lcd_putchar(' ');

        }

        y++;

        lcd_gotoxy(0, y);

    }

    delay_ms(1000);

}

*/

/*

SensorRow getSelfSensorRow (int self)

{

    SensorRow sr;

    int i;

    sr.len = NUM_BOTS;

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

        sr.row[i] = sensors[

}

*/

# 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".

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

#if you want your code to work on the Firefly++ and not Firefly+

#then add the -DFFPP line to CDEFS

COLONYROOT = y:

CDEFS = 

#-DFFPP

# 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_receiver

# 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 = $(COLONYROOT)/code/firefly_plus_lib

#C:\WinAVR\include\fwr

# 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 = -p $(MCU) -P $(AVRDUDE_PORT) -c $(AVRDUDE_PROGRAMMER)

AVRDUDE_FLAGS += $(AVRDUDE_NO_VERIFY)

AVRDUDE_FLAGS += $(AVRDUDE_VERBOSE)

AVRDUDE_FLAGS += $(AVRDUDE_ERASE_COUNTER)

#don't check for device signature

#AVRDUDE_FLAGS += -F

#---------------- 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

REMOVEDIR = rm -rf

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)

	$(REMOVEDIR) .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

/*  

	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/interrupt.h>

#include <servo.h>

#include <dio.h>

#include <lights.h>

#include <lcd.h>

//1677.7216 c/ms

//i dunno must be 2^k

//250

//9C40 ~ 20ms

//#A000 ~ 20.48 but prolly wont work

//div by 256: 6.55078125 c/ms 80 ~ 19.5ms

#define SERVO_PERIOD 0x80

//needs be 1ms

//is 1.22ms

#define SERVO_CONSTANT 0x8

/* 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;

	}

}	

void init_servo()

{

	//1010 1001

	TCCR3A = 0; 

	//0000 0100

	TCCR3B = 0x4;  //prescaler to 256

	TCCR3C=0;

	lcd_init();

	ETIMSK |= 0x08;

	servo_flag = 1;

	OCR3B = 0x0;

	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