Colony

/*

lights.c

Controls led_user (small green LED) and the ORB (big light)

author: CMU Robotics Club, Colony Project

*/

#include "lights.h"

#include "firefly+_lib.h"

// the below comment may not be correct

// Initializes timer2 to count every 0.5 us, overflowing every 16.32 ms (because we set the counter to start at 0x8000)

void orb_init()

{

#ifndef FFPP

        //enable the data direction register on the 3 orb LEDs

        DDRE |= _BV(REDLED) | _BV(GREENLED) | _BV(BLUELED);

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

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

// clear Output Compare Registers

        OCR3AH=0x00;

        OCR3AL=0x00;

        OCR3BH=0x00;

        OCR3BL=0x00;

        OCR3CH=0x00;

        OCR3CL=0x00;

#else

        tlc5940init();

#endif

}

// Sets the red, green and blue elements of the LED with 8-bit resolution

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

{

#ifdef FFPP

        orbs[28]=blue_led<<4;

        orbs[29]=green_led<<4;

        orbs[30]=red_led<<4;

        tlc_send();

#else

        OCR3AL = red_led;

        OCR3BL = green_led;

        OCR3CL = blue_led;

#endif

}

void orb_set_color(int col)

{

 int red, green, blue;

 red = ((col & 0xE0) >> 5) * 36;

 green = ((col & 0x1C) >> 2) * 36;

 blue = (col & 0x03) * 85;

 orb_set(red, green, blue);

}

// Disables the timer1 interrupt, disabling the Orb's color fading capabilities

// You can still turn the red, green, and blue leds on and off with set_orb_dio

void orb_disable()

{

#ifndef FFPP

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

#endif

}

// Enables the timer1 interrupt, enabling the Orb's color fading capabilities

void orb_enable()

{

#ifndef FFPP

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

#else

        tlc5940init();

#endif

}

/*

This function turns each Orb element on or off

Useful for using the Orb for debugging purposes without

the overhead of the software PWM routine used for color fading.

*/

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

{

#ifdef FFPP

        orb_set(red*255, green*255, blue*255);

#else

        if(red == 0)

                PORTE &= (0xFF - _BV(REDLED));

        else

                PORTE |= _BV(REDLED);

        if(green == 0)

                PORTE &= (0xFF - _BV(GREENLED));

        else

                PORTE |= _BV(GREENLED);

        if(blue == 0)

                PORTE &= (0xFF - _BV(BLUELED));

        else

                PORTE |= _BV(BLUELED);

#endif

}

/////////////////////////////////////////

///////////    user LED   ///////////////

/////////////////////////////////////////

void led_init( void )

{

#ifdef FFPP

        tlc5940init();

#else

        DDRG |= _BV(USERLED);

#endif

}

void led_user(int value)

{

#ifdef FFPP

        orbs[USERLED]=value*4095;

        tlc_send();

#else

        if(value == 0)

                PORTG &= (0xFF - _BV(USERLED));

        else

                PORTG |= _BV(USERLED);

#endif

}

#ifdef FFPP

//no send

void orb_set_num_ns(unsigned char num, unsigned int red_led,

                    unsigned int green_led, unsigned int blue_led)

{

        int high = (num>4);

        orbs[3*num+high]=blue_led<<4;

        orbs[3*num+1+high]=green_led<<4;

        orbs[3*num+2+high]=red_led<<4;

}

void orb_set_num(unsigned char num, unsigned int red_led,

                 unsigned int green_led, unsigned int blue_led)

{

        orb_set_num_ns(num,red_led,green_led,blue_led);

        tlc_send();

}

void orb_send(){

        tlc_send();

}

652879

void tlc_clock1(int data)

{

  PORTC &= ~0x02;

  PORTC |= (data << 1)&0x02;

  _delay_us(1);

  PORTC |= 0x04;

  _delay_us(1);

  PORTC &= ~0x04;

}

void tlc_clock2(int data)

{

  PORTC &= ~0x01;

  PORTC |= (data)&0x01;

 // _delay_us(1);

  PORTC |= 0x04;

 // _delay_us(1);

  PORTC &= ~0x04;

}

void tlc_send(void)

{

  int i,j;

  for(j = 15; j >= 0; j--)

  {

    for(i = 11; i >= 0; i--)

    {

      PORTC &= ~0x03;

      PORTC |= ((orbs[j]>>i)&0x01);

      PORTC |= ((orbs[j+16]>>i)<<1)&0x02;

      // _delay_us(1);

      PORTC |= 0x04;

      // _delay_us(1);

      PORTC &= ~0x04;

    }

  }

  PORTC |= 0x08;

  PORTC &= ~(0x08);

}

/*

void tlc_send2(int value)

{

  int i;

  for(i = 11; i >= 0; i--)

  {

    tlc_clock2(0x01 & (value >> i));

  }

}*/

void tlc_latch(void)

{

  PORTC |= 0x08;

//  _delay_us(1);

  PORTC &= ~(0x08);

}

void tlc5940init(void)

{

  int i;

  // set PC0...5 to outputs

  DDRC |= 0x3F;

  DDRE |= 0x08;

  DDRA |= 0x80;

  // unblank buffer

  PORTC &= ~0x10;

  // set DC mode so we start in known state

  PORTC |= 0x20;

  delay_ms(2);

  // set DC to all 1's?  needed?

/*  for(i = 0; i < 96; ++i)

  {

    tlc_clock1(1);

  }

  tlc_latch();

  */

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

  {

    orbs[i]=4095;

  }

  tlc_send();

  delay_ms(2);

  // set GS mode

  PORTC &= ~0x20;

  // clock in 0s to do init case

/*  for(i = 0; i < 16; ++i)

  {

    tlc_send1(0);

  }

  tlc_latch();*/

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

  {

    orbs[i]=4095;

  }

  tlc_send();

  // extra clock needed after DC -> GS transition

  tlc_clock1(0);

  tlc_clock2(0); //probably not needed

  TCCR3A |=_BV(COM3A0);

  TCCR3B |= _BV(CS30)|_BV(WGM32); //prescaler

  OCR3A = 1;

  TCNT3 = 0;

 // ETIMSK |=_BV(OCIE3A);//interrupt

  TCCR2 = 0x05; //prescaler

  TIMSK |= _BV(OCIE2);//interrupt

  OCR2 = 16;

  TCNT2 = 0;

  sei();

}

//int blankcounter = 0;

char status = 0;

ISR(TIMER2_COMP_vect){

//        int i = 0;

        //status=!status;

        //if(status){

                PORTC |= 0x10;

//                for(i=0;i<1;i++);

                PORTC &= ~0x10;

//        }

        TCNT2=0;

        //chirp(250, 150);

}

void silly_clock(void)

{

 /* int i;

  DDRA |= 0x80;

  PORTC |= 0x10;

  _delay_us(1);

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

  {

    PORTA |= 0x80;

    _delay_us(1);

    PORTA &= ~(0x80);

        _delay_us(1);

  }

  */

//  delay_ms(1);

}

void tlc5940test()

{

  int j, k;

  tlc5940init();

        // fade up

        for(j = 0; j < 4096; ++j)

        {

          //tlc_send1(j);

          for(k = 0; k < 8; ++k)

          {

      orbs[2*k]=4096-j;

      orbs[2*k+1]=j;

      orbs[2*k+16]=0;

      orbs[2*k+17]=j;

          }

          tlc_send();

        }

        delay_ms(1000);

        // fade down

        for(j = 0; j < 4096; ++j)

        {

          //tlc_send(4095 - j);

          for(k = 0; k < 32; ++k)

          {

      orbs[k]=4096-j;

    }

          tlc_send();

        }

}

#endif