Colony

#include <dragonfly_lib.h>

//#include "smart_run_around_fsm.h"

// Martin "deffi" Herrmann Test

static void oset(uint8_t r,uint8_t g,uint8_t b)

{

	orbs_set(r,g,b,255-r,255-g,255-b);

}

static void color_circle (void)

{

   while(1)

   {

		for (uint8_t part=0; part<6; ++part)

		{

			for (uint8_t up=0; up<255; ++up)

			{

				uint8_t dn=255-up;

				uint8_t on=255;

				uint8_t of=0;

				if (1)

				{

					// Maximum brightness mode

					switch (part)

					{

						case 0: oset (on, up, of); break;

						case 1: oset (dn, on, of); break;

						case 2: oset (of, on, up); break;

						case 3: oset (of, dn, on); break;

						case 4: oset (up, of, on); break;

						case 5: oset (on, of, dn); break;

					}

				}

				else

				{

					// Constant brightness mode (not very constant though)

					switch (part%3)

					{

						case 0: oset (dn, up, of); break;

						case 1: oset (of, dn, up); break;

						case 2: oset (up, of, dn); break;

					}

				}

				delay_ms (2);

			}

		}

	}

}

static void acl(void)

{

	#define redval 255

	#define greenval 150

	#define interval 1300

	#define flash 20

	#define pause 200

	#define def do { orb1_set(redval,0,0); orb2_set(0,greenval,0); } while (0)

	#define wht do { orb_set(255,255,255); } while (0)

	while (1)

	{

		wht; delay_ms (flash);

		def; delay_ms (pause-flash);

		wht; delay_ms (flash);

		def; delay_ms (pause-flash);

		def; delay_ms (interval-2*pause-2*flash);

	}

}

int main(void) {

//	dragonfly_init(ALL_ON);

	dragonfly_init(0);

	usb_init ();

	usb_puts ("Startup\r\n");

	//encoders_init ();

    //analog_init(ADC_START);

	//analog_init(0);

    //range_init();

	//DDRF=2;

	//motors_init ();

	//motor2_set (FORWARD, 64);

	//orb_init_binary ();

	orb_init_pwm ();

	if (false)

	{

		orbs_set (255, 0, 0, 0, 0, 0); delay_ms (500);

		orbs_set (0, 255, 0, 0, 0, 0); delay_ms (500);

		orbs_set (0, 0, 255, 0, 0, 0); delay_ms (500);

		orbs_set (0, 0, 0, 255, 0, 0); delay_ms (500);

		orbs_set (0, 0, 0, 0, 255, 0); delay_ms (500);

		orbs_set (0, 0, 0, 0, 0, 255); delay_ms (500);

	}

	if (false)

	{

		orb_set (1,1,1);

		while (1)

		{

			SYNC

			{

				for (uint8_t m=0; m<100; ++m)

				{

					_delay_us(10);

				}

			}

		}

	}

	if (false)

	{

		while (1)

		{

			for (uint8_t x=0; x<255; ++x)

			{

				orbs_set (x, 1, 2, 3, 4, 5);

				for (uint8_t n=0; n<80; ++n)

				{

					SYNC

					{ for (uint8_t m=0; m<1; ++m) _delay_us(50); }

				}

			}

			for (uint8_t x=255; x>0; --x)

			{

				orbs_set (x, 1, 1, 1, 1, 1);

				delay_ms (4);

			}

		}

	}

	if (false)

	{

		//orbs_set (2,4,6,8,10,12);

		//orbs_set (32, 64, 96, 128, 160, 192);

		orbs_set (128,128,128,128,128,128);

		while (1);

	}

	if (false)

	{

		if (!button2_read ())

		{

			orb_set_mode (orb_mode_pwm);

			orb_disable_timer ();

			while (1)

			{

				// Continuously call the sorting routine for timing test

				for (uint8_t i=0; i<200; ++i)

				{

					orbs_set (10,20,30,40,50,60);

					delay_ms (10);

				}

				for (uint8_t i=0; i<200; ++i)

				{

					orbs_set (60,50,40,30,20,10);

					delay_ms (10);

				}

			}

		}

		else

		{

			while (button2_read ());

			if (button1_read ())

			{

				color_circle ();

			}

			else

			{

				acl ();

			}

		}

	}

	// Do some lighting

	if (!button2_read ())

		color_circle ();

	else

		acl ();

}

########Update This Section########

#

#

# Relative path to the root directory (containing lib directory)

ifndef COLONYROOT

COLONYROOT = ../..

endif

# Target file name (without extension).

TARGET = template

# Uncomment this to use the wireless library

# USE_WIRELESS = 1

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

#AVRDUDE_PORT = com4

AVRDUDE_PORT = $(shell if [ -e /dev/ttyUSB0 ]; then echo /dev/ttyUSB0; else echo 'COM4:'; fi)

#

#

###################################

# 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

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 = 8000000

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

FORMAT = ihex

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

SRC = $(wildcard *.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 =

# 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

CDEFS += -DFFP

# for wireless library

ifdef USE_WIRELESS

	CDEFS += -DROBOT

endif

# Place -I, -L options here

CINCS = -I$(COLONYROOT)/lib/include/libdragonfly

CINCS += -L$(COLONYROOT)/lib/bin

ifdef USE_WIRELESS

	CINCS += -I$(COLONYROOT)/lib/include/libwireless

endif

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

# 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 += $(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)

ifdef USE_WIRELESS

	LDFLAGS += -lwireless

endif

LDFLAGS += -ldragonfly

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

# programmer connected to serial device

AVRDUDE_WRITE_FLASH = -b 57600 -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

	-taskkill /IM ttermpro.exe

	sleep 1

	$(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

// FIXME remove

typedef unsigned char uint8_t;

// ***** Predefined colors *****

/** @brief Turn the orb off **/

#define ORB_OFF   0x00

// ***** Initialization *****

/** @brief Enables the orbs in default mode **/

/** @brief Enables the orbs in binary mode **/

void orb_init_binary (void);

/** @brief Enables the orbs in PWM mode **/

void orb_init_pwm (void);

// ***** Mode setting *****

/** Specification of the orb mode **/

typedef uint8_t orb_mode_t;

/** @brief PWM mode **/

#define orb_mode_pwm 0

/** @brief Binary mode **/

#define orb_mode_binary 1

/** @brief Switches the orbs to the specified mode **/

void orb_set_mode (orb_mode_t mode);

/** @brief Disables the orb timer, but does not change the mode **/

void orb_disable_timer (void);

/** @brief Enables the orb timer, but does not change the mode **/

void orb_enable_timer (void);

// ***** Setting RGB colors *****

/** @brief set the specified orb to a specified color **/

void orb_n_set (uint8_t num, uint8_t red, uint8_t green, uint8_t blue);

void orb_set(uint8_t red, uint8_t green, uint8_t blue);

void orb1_set(uint8_t red_led, uint8_t green_led, uint8_t blue_led); 

void orb2_set(uint8_t red_led, uint8_t green_led, uint8_t blue_led);

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

// ***** Settings predefined colors *****

/** @brief set the specified orb to the specified color **/

void orb_n_set_color(uint8_t num, uint8_t col);

void orb1_set_color(uint8_t col);

void orb2_set_color(uint8_t col);

/** @brief set the orbs to specified colors **/

void orbs_set_color(uint8_t col1, uint8_t col2);

/** @brief Set both orbs to a specified color **/

void orb_set_color(uint8_t col);

// This file is included from the libdragonfly directory because it seems to be

// missing from the AVR libc distribution.

#include "atomic.h"

#include <stdbool.h>

/** @brief shortcut for ATOMIC_BLOCK(ATOMIC_RESTORESTATE) **/

#define SYNC ATOMIC_BLOCK(ATOMIC_RESTORESTATE)

/** @brief atomically grab a lock if it is free, return otherwise **/

#define REQUIRE_LOCK_OR_RETURN(LOCK) do { SYNC { if (LOCK) return; LOCK=1; } } while (0)

/** @brief atomically release a lock **/

#define RELEASE_LOCK(LOCK) do { LOCK=0; } while (0)

// FIXME remove

typedef unsigned char uint8_t;

// ***** Predefined colors *****

/** @brief Turn the orb off **/

#define ORB_OFF   0x00

// ***** Initialization *****

/** @brief Enables the orbs in default mode **/

/** @brief Enables the orbs in binary mode **/

void orb_init_binary (void);

/** @brief Enables the orbs in PWM mode **/

void orb_init_pwm (void);

// ***** Mode setting *****

/** Specification of the orb mode **/

typedef uint8_t orb_mode_t;

/** @brief PWM mode **/

#define orb_mode_pwm 0

/** @brief Binary mode **/

#define orb_mode_binary 1

/** @brief Switches the orbs to the specified mode **/

void orb_set_mode (orb_mode_t mode);

/** @brief Disables the orb timer, but does not change the mode **/

void orb_disable_timer (void);

/** @brief Enables the orb timer, but does not change the mode **/

void orb_enable_timer (void);

// ***** Setting RGB colors *****

/** @brief set the specified orb to a specified color **/

void orb_n_set (uint8_t num, uint8_t red, uint8_t green, uint8_t blue);

void orb_set(uint8_t red, uint8_t green, uint8_t blue);

void orb1_set(uint8_t red_led, uint8_t green_led, uint8_t blue_led); 

void orb2_set(uint8_t red_led, uint8_t green_led, uint8_t blue_led);

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

// ***** Settings predefined colors *****

/** @brief set the specified orb to the specified color **/

void orb_n_set_color(uint8_t num, uint8_t col);

void orb1_set_color(uint8_t col);

void orb2_set_color(uint8_t col);

/** @brief set the orbs to specified colors **/

void orbs_set_color(uint8_t col1, uint8_t col2);

/** @brief Set both orbs to a specified color **/

void orb_set_color(uint8_t col);

// This file is included from the libdragonfly directory because it seems to be

// missing from the AVR libc distribution.

#include "atomic.h"

#include <stdbool.h>

/** @brief shortcut for ATOMIC_BLOCK(ATOMIC_RESTORESTATE) **/

#define SYNC ATOMIC_BLOCK(ATOMIC_RESTORESTATE)

/** @brief atomically grab a lock if it is free, return otherwise **/

#define REQUIRE_LOCK_OR_RETURN(LOCK) do { SYNC { if (LOCK) return; LOCK=1; } } while (0)

/** @brief atomically release a lock **/

#define RELEASE_LOCK(LOCK) do { LOCK=0; } while (0)

/* This file is in the dragonfly library directory because it seems to be

   missing from the AVR libc distribution */

/* Copyright (c) 2007 Dean Camera

   All rights reserved.

   Redistribution and use in source and binary forms, with or without

   modification, are permitted provided that the following conditions are met:

   * Redistributions of source code must retain the above copyright

     notice, this list of conditions and the following disclaimer.

   * Redistributions in binary form must reproduce the above copyright

     notice, this list of conditions and the following disclaimer in

     the documentation and/or other materials provided with the

     distribution.

   * Neither the name of the copyright holders nor the names of

     contributors may be used to endorse or promote products derived

     from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE

  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

  POSSIBILITY OF SUCH DAMAGE.

*/

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

#ifndef _UTIL_ATOMIC_H_

#define _UTIL_ATOMIC_H_ 1

#include <avr/io.h>

#include <avr/interrupt.h>

#if !defined(__DOXYGEN__)

/* Internal helper functions. */

static __inline__ uint8_t __iSeiRetVal(void)

{

    sei();

    return 1;

}

static __inline__ uint8_t __iCliRetVal(void)

{

    cli();

    return 1;

}

static __inline__ void __iSeiParam(const uint8_t *__s)

{

    sei();

    __asm__ volatile ("" ::: "memory");

    (void)__s;

}

static __inline__ void __iCliParam(const uint8_t *__s)

{

    cli();

    __asm__ volatile ("" ::: "memory");

    (void)__s;

}

static __inline__ void __iRestore(const  uint8_t *__s)

{

    SREG = *__s;

    __asm__ volatile ("" ::: "memory");

}

#endif	/* !__DOXYGEN__ */

/** \file */

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

    \code

    #include <util/atomic.h>

    \endcode

    \note The macros in this header file require the ISO/IEC 9899:1999

    ("ISO C99") feature of for loop variables that are declared inside

    the for loop itself.  For that reason, this header file can only

    be used if the standard level of the compiler (option --std=) is

    set to either \c c99 or \c gnu99.

    The macros in this header file deal with code blocks that are

    guaranteed to be excuted Atomically or Non-Atmomically.  The term

    "Atomic" in this context refers to the unability of the respective

    code to be interrupted.

    These macros operate via automatic manipulation of the Global

    Interrupt Status (I) bit of the SREG register. Exit paths from

    both block types are all managed automatically without the need

    for special considerations, i. e. the interrupt status will be

    restored to the same value it has been when entering the

    respective block.

    A typical example that requires atomic access is a 16 (or more)

    bit variable that is shared between the main execution path and an

    ISR.  While declaring such a variable as volatile ensures that the

    compiler will not optimize accesses to it away, it does not

    guarantee atomic access to it.  Assuming the following example:

    \code

#include <inttypes.h>

#include <avr/interrupt.h>

#include <avr/io.h>

volatile uint16_t ctr;

ISR(TIMER1_OVF_vect)

{

  ctr--;

}

...

int

main(void)

{

   ...

   ctr = 0x200;

   start_timer();

   while (ctr != 0)

     // wait

       ;

   ...

}

    \endcode

    There is a chance where the main context will exit its wait loop

    when the variable \c ctr just reached the value 0xFF.  This happens

    because the compiler cannot natively access a 16-bit variable

    atomically in an 8-bit CPU.  So the variable is for example at

    0x100, the compiler then tests the low byte for 0, which succeeds.

    It then proceeds to test the high byte, but that moment the ISR

    triggers, and the main context is interrupted.  The ISR will

    decrement the variable from 0x100 to 0xFF, and the main context

    proceeds.  It now tests the high byte of the variable which is

    (now) also 0, so it concludes the variable has reached 0, and

    terminates the loop.

    Using the macros from this header file, the above code can be

    rewritten like:

    \code

#include <inttypes.h>

#include <avr/interrupt.h>

#include <avr/io.h>

#include <util/atomic.h>

volatile uint16_t ctr;

ISR(TIMER1_OVF_vect)

{

  ctr--;

}

...

int

main(void)

{

   ...

   ctr = 0x200;

   start_timer();

   sei();

   uint16_t ctr_copy;

   do

   {

     ATOMIC_BLOCK(ATOMIC_FORCEON)

     {

       ctr_copy = ctr;

     }

   }

   while (ctr_copy != 0);

   ...

}

    \endcode

    This will install the appropriate interrupt protection before

    accessing variable \c ctr, so it is guaranteed to be consistently

    tested.  If the global interrupt state were uncertain before

    entering the ATOMIC_BLOCK, it should be executed with the

    parameter ATOMIC_RESTORESTATE rather than ATOMIC_FORCEON.

*/

/** \def ATOMIC_BLOCK(type)

    \ingroup util_atomic

    Creates a block of code that is guaranteed to be executed

    atomically. Upon entering the block the Global Interrupt Status

    flag in SREG is disabled, and re-enabled upon exiting the block

    from any exit path.

    Two possible macro parameters are permitted, ATOMIC_RESTORESTATE

    and ATOMIC_FORCEON.

*/

#if defined(__DOXYGEN__)

#define ATOMIC_BLOCK(type)

#else

#define ATOMIC_BLOCK(type) for ( type, __ToDo = __iCliRetVal(); \

	                       __ToDo ; __ToDo = 0 )

#endif	/* __DOXYGEN__ */

/** \def NONATOMIC_BLOCK(type)

    \ingroup util_atomic

    Creates a block of code that is executed non-atomically. Upon

    entering the block the Global Interrupt Status flag in SREG is

    enabled, and disabled upon exiting the block from any exit

    path. This is useful when nested inside ATOMIC_BLOCK sections,

    allowing for non-atomic execution of small blocks of code while

    maintaining the atomic access of the other sections of the parent

    ATOMIC_BLOCK.

    Two possible macro parameters are permitted,

    NONATOMIC_RESTORESTATE and NONATOMIC_FORCEOFF.

*/

#if defined(__DOXYGEN__)

#define NONATOMIC_BLOCK(type)

#else

#define NONATOMIC_BLOCK(type) for ( type, __ToDo = __iSeiRetVal(); \

	                          __ToDo ;  __ToDo = 0 )

#endif	/* __DOXYGEN__ */

/** \def ATOMIC_RESTORESTATE

    \ingroup util_atomic

    This is a possible parameter for ATOMIC_BLOCK. When used, it will

    cause the ATOMIC_BLOCK to restore the previous state of the SREG

    register, saved before the Global Interrupt Status flag bit was

    disabled. The net effect of this is to make the ATOMIC_BLOCK's

    contents guaranteed atomic, without changing the state of the

    Global Interrupt Status flag when execution of the block

    completes.

*/

#if defined(__DOXYGEN__)

#define ATOMIC_RESTORESTATE

#else

#define ATOMIC_RESTORESTATE uint8_t sreg_save \

	__attribute__((__cleanup__(__iRestore))) = SREG

#endif	/* __DOXYGEN__ */

/** \def ATOMIC_FORCEON

    \ingroup util_atomic

    This is a possible parameter for ATOMIC_BLOCK. When used, it will

    cause the ATOMIC_BLOCK to force the state of the SREG register on

    exit, enabling the Global Interrupt Status flag bit. This saves on

    flash space as the previous value of the SREG register does not

    need to be saved at the start of the block.

    Care should be taken that ATOMIC_FORCEON is only used when it is

    known that interrupts are enabled before the block's execution or

    when the side effects of enabling global interrupts at the block's

    completion are known and understood.

*/

#if defined(__DOXYGEN__)

#define ATOMIC_FORCEON

#else

#define ATOMIC_FORCEON uint8_t sreg_save \

	__attribute__((__cleanup__(__iSeiParam))) = 0

#endif	/* __DOXYGEN__ */

/** \def NONATOMIC_RESTORESTATE

    \ingroup util_atomic

    This is a possible parameter for NONATOMIC_BLOCK. When used, it

    will cause the NONATOMIC_BLOCK to restore the previous state of

    the SREG register, saved before the Global Interrupt Status flag

    bit was enabled. The net effect of this is to make the

    NONATOMIC_BLOCK's contents guaranteed non-atomic, without changing

    the state of the Global Interrupt Status flag when execution of

    the block completes.

*/

#if defined(__DOXYGEN__)

#define NONATOMIC_RESTORESTATE

#else

#define NONATOMIC_RESTORESTATE uint8_t sreg_save \

	__attribute__((__cleanup__(__iRestore))) = SREG

#endif	/* __DOXYGEN__ */

/** \def NONATOMIC_FORCEOFF

    \ingroup util_atomic

    This is a possible parameter for NONATOMIC_BLOCK. When used, it

    will cause the NONATOMIC_BLOCK to force the state of the SREG

    register on exit, disabling the Global Interrupt Status flag

    bit. This saves on flash space as the previous value of the SREG

    register does not need to be saved at the start of the block.

    Care should be taken that NONATOMIC_FORCEOFF is only used when it

    is known that interrupts are disabled before the block's execution

    or when the side effects of disabling global interrupts at the

    block's completion are known and understood.

*/

#if defined(__DOXYGEN__)

#define NONATOMIC_FORCEOFF

#else

#define NONATOMIC_FORCEOFF uint8_t sreg_save \

	__attribute__((__cleanup__(__iCliParam))) = 0

#endif	/* __DOXYGEN__ */

#endif

 * @bug Unfinished

Controls orb1 and orb2. Can be extended for a software PWM that may be used for servos in the future (although maybe

using a different timer might be preferable).

3/31/2009 - Martin

    Rewritten from scratch. Fixes code duplication, long ISRs, bugs, unnecessary synchronized code, memory waste

*/

/**

 * Quick start: call orb_init_pwm or orb_init_binary, depending on which mode you want to use. Call orb*set or

 * orb*set_color to set the orbs.

 * 

 * The orbs have two modes of operation: PWM mode and binary mode. In PWM mode, a pwm signal is generated by a hardware

 * timer and the orbs can be set to a value of 0 through 255. In binary mode, the orbs can only be turned on or off and

 * a value of 0 means "off" and any other value means "on". The mode can be chosen on initialization and can be changed

 * at runtime using the orb_set_mode function.

 *

 * Operation (PWM mode): On timer overflow, all LEDs with a value>0 are turned on and the output compare value for the

 * first LED is loaded. On compare match, the corresponding LED is turned off and the next output compare value is

 * loaded. All masks are precomputed and sorted by time when setting the values.

 *

 * The data structure (pwm_t) containing the PWM times and masks is triple buffered. This is because the buffer the ISR

 * is reading from may only be modified on timer overflow before the next PWM sequence is started, because otherwise the

 * next OCR value might be sed to a value smaller than the current timer value, resulting in the remaining channels not

 * being turned off in that PWM period (flash to on). When using two buffers, the page flip can only occur on a timer

 * overflow for the same reason. So after writing a buffer and marking it for page flip, neither of the buffers could be

 * modified because the front buffer is read by the ISR and the back buffer could be switched at any time. So the

 * calling thread would have to be delayed by up to one full PWM period (8ms in the current implementation, but

 * 20ms-50ms would be a reasonable value to expect here). To avoid this, triple buffering is used.

 *

 * The code for applying the orbs is fairly optimized. See the apply_orbs function for some time measurements and

 * further nodes.

 *

 * The PWM frequency is 120Hz (8ms period time). The next lower frequency (determined by the prescaler) is 30 Hz which

 * is too slow (orbs flicker).

 *

 * The orbs code is thread safe, which means that the functions may be called from another interrupt handler. If there

 * are multiple concurrent calls to the orb*set* functions, one of them is ignored and the orbs are never left in an

 * inconsistent state. For example, if the orbs are set to green by the main thread and to red by an interrupt handler,

 * the resulting color will be either red or green, but never yellow.

 * Thread safety is achieved by grabbing a lock at the beginning of all functions that modify the orb code and releasing

 * the lock at the end. If the lock is already taken, the function just returns doing nothing.

 *

 * Some performance measurements:

 *   - Time for setting new orb values (PWM mode):       35us-72us (depending on the degree to which the array is

 *                                                                  already in the correct order)

 *   - Time for setting new orb values (binary mode):        5.5us

 *

 *   - Interrupt time (PWM mode only):                         8us (overflow)

 *                                                            10us (output compare)

 *                                                             6us (last output compare)

 *                                                            30us (output compare, all value equal)

 *

 *   - Maximum total interrupt time per period:               64us

 *   - Maximum CPU usage for interrupts (PWM mode only):     <0.8%

 *

 *   - Maximum contiguous synchronized block:                 30us (output compare interrupt, all values equal)

 *

 * There are some potential optimizations left. See the source code for more information.

 *

 * A note on robustness: if the output compare interrupt is disabled for too long, either due to a long ISR or a long

 * synchronized code block, the orbs will flicker to brighter values for being turned off too late. With software PWM,

 * there's nothing at all to be done about that. The problem can be alleviated by using a lower PWM frequency, but then

 * the orbs will start flickering all the time due to the low update frequency.

 * Some measurements: with 100us synchronized blocks, the flickering is accepptably low. Longer synchronized blocks

 * mean more flickering. At 1ms synchronized blocks, the flickering is quite bad, especially for low orb values. Note

 * that orb value 0 never flickers at all because the corresponding channels are not turned on at all.

 * Test code (not the _delay_us restrictions!)

 *   orb_set (1,1,1); while (1) { SYNC { for (uint8_t m=0; m<10; ++m) { _delay_us(10); } } }

 **/

/*

All different:

Overflow: 8us

OC: 5*10+1*6