Colony

/**

 * Copyright (c) 2007 Colony Project

 * 

 * Permission is hereby granted, free of charge, to any person

 * obtaining a copy of this software and associated documentation

 * files (the "Software"), to deal in the Software without

 * restriction, including without limitation the rights to use,

 * copy, modify, merge, publish, distribute, sublicense, and/or sell

 * copies of the Software, and to permit persons to whom the

 * Software is furnished to do so, subject to the following

 * conditions:

 * 

 * The above copyright notice and this permission notice shall be

 * included in all copies or substantial portions of the Software.

 * 

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES

 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT

 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,

 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR

 * OTHER DEALINGS IN THE SOFTWARE.

 **/

/**

 * @file ligths.c

 * @brief Orbs

 *

 * Implemenation for the orbs (tri-colored LEDs)

 *

 * @author Colony Project, CMU Robotics Club

 * @bug Unfinished

 **/

/*

lights.c

Controls orb1 and orb2. Can be extended for a software PWM that may be used

for servos in the future.

author: CMU Robotics Club, Colony Project

Change Log:

3/31/2009 - Martin

    Rewritten from scratch (mostly), fixes some code duplication, long ISRs,

        bugs, unnecessary synchronized code, memory waste

*/

/*

Operation:

On timer overflow:

  - switch on LEDs (where value>0, according to a pre-determined mask)

  - load the first output compare value

At compare match:

  - switch off LEDs (according to mask)

  - load the next output compare value

 */

#include "lights.h"

#include <avr/interrupt.h>

#include "dragonfly_lib.h"

// *********

// ** I/O **

// *********

#define NUM_ORBS 2   // Number or orbs

#define NUM_COLORS 3 // Number of colors per orb

// Orb port

#define ORBPORT PORTC

#define ORBDDR  DDRC

// Orb pins

#define ORB1_RED   0

#define ORB1_GREEN 1

#define ORB1_BLUE  2

#define ORB2_RED   4

#define ORB2_GREEN 5

#define ORB2_BLUE  6

// ***********

// ** Masks **

// ***********

// Some useful bit masks. All of them are are calculated from the I/O

// definitions above. The calculations should be done at compile time (even if

// they are not, they are only executed once at startup).

// Masks for the individual LEDs

#define orb1_red_mask    _BV (ORB1_RED  )

#define orb1_green_mask  _BV (ORB1_GREEN)

#define orb1_blue_mask   _BV (ORB1_BLUE )

#define orb2_red_mask    _BV (ORB2_RED  )

#define orb2_green_mask  _BV (ORB2_GREEN)

#define orb2_blue_mask   _BV (ORB2_BLUE )

// Mask for all LEDs

const uint8_t all_orbs_mask=

        orb1_red_mask | orb1_green_mask | orb1_blue_mask |

        orb2_red_mask | orb2_green_mask | orb2_blue_mask;

// Mask for the individual LEDs, organized as an array for programmatic access.

// The layout of this array is orb_mask[orb_num, color_num]

const uint8_t orb_mask[NUM_ORBS][NUM_COLORS]=

{

        { orb1_red_mask, orb1_green_mask, orb1_blue_mask },

        { orb2_red_mask, orb2_green_mask, orb2_blue_mask }

};

// ***********

// ** Types **

// ***********

struct pwm_channel

{

    uint8_t time;

    uint8_t mask;

};

// ***************

// ** Variables **

// ***************

struct pwm_channel channels[NUM_ORBS*NUM_COLORS];

// ********************

// ** Initialization **

// ********************

static void dset(uint8_t num)

{

        PORTF|=1<<num;

}

static void dclear(uint8_t num)

{

        PORTF&=~(1<<num);

}

/**

 * Initializes the PWM for Orb control. This must be called before 

 * the orbs are used for them to function.

 **/

void orb_init ()

{

        // Timer mode:

        //   OCRnx update "immediate" is required. This leaves "Normal" mode and the

        //   "CTC" modes. "Normal" doesn't allow setting a reload value, and the

        //   prescaler is too limited. So CTC is used. CTC can match to OCRnA and

        //   ICRn. For the motor, OCRnA is already in use for the compare match

        //   output unit. So ICRn is used.

        //   This leaves: WGMn3:0=1100.

        //   This mode does not provide an overflow interrupt, so Output Compare

        //   has to be used instead.

        // Enable the output ports and turn off the LEDs

        ORBDDR  |=  all_orbs_mask;

        ORBPORT &= ~all_orbs_mask;

        // Set all orbs to "off"

        orb_set (0, 0, 0);

    // Set up the timer

    // Prescaler 8 is 66 ms or 15 Hz (8 MHz/prescaler 8/2^16)

        TCCR3A=0;

    TCCR3B=_BV(CS31); // Prescaler 8

    //TCCR3B=_BV(CS31) | _BV(CS30); // Prescaler 64

    TCCR3C=0;

    ETIMSK |= _BV(TOIE3) | _BV(OCIE3C); // Enable Overflow Interrupt and Output compare 3 interrupt

    // Clear Timer on Compare match:

    // Either from OCR3A (WGM3 3:0=4) or from ICR3 (WGM3 3:0=12

        // DOING: Select a good reload so

        //   - there are 256 values (not so important)

        //   - the refresh rate is around 20..25 Hz

        // Then, check if it can be co-used w/ the compare match output unit.

    ICR3=10000; // Refresh rate (period): 10ms

        OCR3C=0;

        //TCCR3A |= _BV(WGM31);

    TCCR3B |= _BV(WGM33) | _BV(WGM32);

        // TOP is 6, counter counts 0 1 2 3 4 5 6 (7 intervals) => 8 possibilities

        // OCR=0 => 1/8, OCR=7 => 8/8

    //OCR3C=1; // Compare after (?) 1

    // Debug

    DDRF=6;

        // In PWM mode, the OCR is double buffered (updated at TOP or BOTTOM)

//        //init timer3

//        TCCR3A = 0; 

//        TCCR3B = _BV(CS31); //prescale = 8

//        TCCR3C = 0;

//        ETIMSK |= _BV(OCIE3C); //turn on oc3c interrupt

//        OCR3C = TCNT3+ORB_RESET;

}

//

// ****************

// ** Timer ISRs **

// ****************

volatile uint8_t x;

volatile uint8_t i;

void orb_tick (uint8_t t)

{

        x++;

}

SIGNAL (SIG_OVERFLOW3)

{

}

// Timer values: 0 1 2 3 4 5 6 7 8 9

SIGNAL (SIG_OUTPUT_COMPARE3C)

{

        if (i==0)

        {

                dset (1);

                dset (2);

                i=1;

                OCR3C=1000;

        }

        else if (i==1)

        {

                dclear (1);

                OCR3C=2000;

                i=2;

        }

        else if (i==2)

        {

                dclear (2);

                OCR3C=0;

                i=0;

        }

}

// ************************

// ** Setting RGB colors **

// ************************

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

{

        // FIXME implement PWM code (this is only binary on/off)

        // FIXME Synchronization

        // Oh, and of course the outputs are inverted.

        if (!red)   ORBPORT|=orb_mask[num][0]; else ORBPORT&=~orb_mask[num][0];

        if (!green) ORBPORT|=orb_mask[num][1]; else ORBPORT&=~orb_mask[num][1];

        if (!blue)  ORBPORT|=orb_mask[num][2]; else ORBPORT&=~orb_mask[num][2];

}

/**

 * Set orb1 to the color specified. orb_init must be called before this function

 * may be used.

 *

 * @param red the red component of the color

 * @param green the green component of the color

 * @param blue the blue component of the color

 *

 * @see orb_init

 **/

void orb1_set (uint8_t red, uint8_t green, uint8_t blue)

{

        orb_n_set (0, red, green, blue);

}

/**

 * Set orb2 to the color specified. orb_init must be called before this function

 * may be used.

 *

 * @param red_led the red component of the color

 * @param green_led the green component of the color

 * @param blue_led the blue component of the color

 *

 * @see orb_init

 **/

void orb2_set (uint8_t red, uint8_t green, uint8_t blue)

{

        orb_n_set (1, red, green, blue);

}

/**

 * Set both orbs to the color specified. orb_init must be called before this

 * function may be used.

 *

 * @param red_led the red component of the color

 * @param green_led the green component of the color

 * @param blue_led the blue component of the color

 *

 * @see orb_init, orb1_set, orb2_set

 **/

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

{

        orb1_set (red, green, blue);

        orb2_set (red, green, blue);

}

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

//#define ORB_RESET 1025

//#define ORBMASK 0x77

//

///***** Port and Pin Definitions ****/

//

//

//// an orb node

//struct ORB_NODE {

//   uint8_t num;

//   uint16_t angle;

//};

//

//the change in an orb

//struct ORB_CHANGE {

//   uint16_t port_val;

//   uint16_t split_time_period;

//};

//

//// the status of an orb

//struct ORB_STATUS_STRUCT {

//   struct ORB_NODE orbs[ORB_COUNT];

//   uint16_t orb_angles[ORB_COUNT];

//   struct ORB_CHANGE changes[ORB_COUNT+1];

//   uint8_t change_count;

//   uint8_t new_angles;

//   uint8_t current_orb;

//

//} ORB_STATUS;

//

//void orb_sort(void);

//void orb_setup_pulse(void);

//

//SIGNAL (SIG_OUTPUT_COMPARE3C){

//

//                //pull the correct ones down

//      ORBPORT &= (~ORBMASK)|(ORB_STATUS.changes[ORB_STATUS.current_orb].port_val);

//

//      ++ORB_STATUS.current_orb; //now look at next orb transition

//

//      if (ORB_STATUS.current_orb < ORB_STATUS.change_count) { //if it isnt the end...

//          

//                        //setup timer for next pull down

//         OCR3C = TCNT3+ORB_STATUS.changes[ORB_STATUS.current_orb].split_time_period;

//                 

//     }

//      else { //we are done with these pulses

//                orb_setup_pulse();

//      }

//

//}

//

//

////sets a channel to a value

//void orb_set_angle(uint16_t orb, uint16_t angle) {

//        uint8_t mysreg;

//        

//        orb=orb&0x07; //only have 8

//        angle=angle&0xff; //only accept 0-255

//        angle=255-angle; //inverse intensity

//        angle=angle<<2; //scale up so that we dont run it too often

//        angle+=3; //0 values dont really work

//   if (ORB_STATUS.orb_angles[orb] != angle) { //if the angle has changed

//          mysreg=SREG; 

//          cli(); //disable interrupts

//      ORB_STATUS.orb_angles[orb] = angle; //update angle

//      ORB_STATUS.new_angles = 1;

//          SREG=mysreg; //put interrupt status back

//   }

//}

//

//

//void orb_sort(void) {

//   uint16_t done = 0, i;

//   

//   while (! done) {

//      done = 1;

//

//      for (i = 0; i < ORB_COUNT - 1; ++i) {  //loop through all

//          

//                        //if they are out of order, swap them

//         if (ORB_STATUS.orbs[i].angle > ORB_STATUS.orbs[i+1].angle) {

//            ORB_STATUS.orbs[i].angle ^= ORB_STATUS.orbs[i+1].angle;

//            ORB_STATUS.orbs[i+1].angle ^= ORB_STATUS.orbs[i].angle;

//            ORB_STATUS.orbs[i].angle ^= ORB_STATUS.orbs[i+1].angle;

//

//            ORB_STATUS.orbs[i].num ^= ORB_STATUS.orbs[i+1].num;

//            ORB_STATUS.orbs[i+1].num ^= ORB_STATUS.orbs[i].num;

//            ORB_STATUS.orbs[i].num ^= ORB_STATUS.orbs[i+1].num;

//

//            done = 0;

//         }

//      }

//   }

//}

//

////calculate the split times

//void orb_setup_pulse(void) {

//   uint16_t i;

//   uint16_t my_port;

//   uint16_t sum = 0;

//   uint16_t split_time;

//

//   my_port = 0xff; //all on

//

//   if (ORB_STATUS.new_angles) {

//

//      ORB_STATUS.change_count = 0;

//          for (i = 0; i < ORB_COUNT; ++i) { //get the new values

//         ORB_STATUS.orbs[i].angle = ORB_STATUS.orb_angles[ORB_STATUS.orbs[i].num];

//      }

//

//      orb_sort(); //sort them

//      ORB_STATUS.new_angles = 0;

//

//      for (i = 0; i < ORB_COUNT; ++i) { //calculate split times

//         split_time = ORB_STATUS.orbs[i].angle - sum;

//         my_port &= ~_BV(ORB_STATUS.orbs[i].num);

//                 

//         for (; i < ORB_COUNT - 1 && ORB_STATUS.orbs[i].angle == ORB_STATUS.orbs[i+1].angle; ++i) {

//            my_port &= ~_BV(ORB_STATUS.orbs[i+1].num); //look for doups

//         }

//                 

//         ORB_STATUS.changes[ORB_STATUS.change_count].port_val = my_port; //which pins are low

//         ORB_STATUS.changes[ORB_STATUS.change_count].split_time_period = split_time;

//         

//                 ++ORB_STATUS.change_count;

//                 

//         sum += split_time;

//      }

//

//      ORB_STATUS.changes[ORB_STATUS.change_count].port_val = my_port;

//      ORB_STATUS.changes[ORB_STATUS.change_count].split_time_period = ORB_RESET - sum; //get a constant period

//

//      ++ORB_STATUS.change_count;

//

//   }

//

//

//

//   ORB_STATUS.current_orb = 0;

//

//    ORBPORT |= ORBMASK; //start with all high

//        OCR3C = TCNT3 + ORB_STATUS.changes[0].split_time_period; //wait for first split

//

//}

//

///**

// * @defgroup orbs Orbs

// * @brief Functions for controlling the color of the orbs.

// * 

// * Functions for controlling the color and lighting of the orbs.

// *

// * @{

// **/

//

/**

 * Set both orbs to the specified color. This function

 * is intended to be used with the predefined

 * colors. orb_init must be called before this

 * function may be used.

 *

 * @param col the color to set the orbs to

 *

 * @see orb_init

 **/

void orb_set_color(uint8_t col)

{

// uint16_t red, green, blue;

//

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

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

// blue = (col & 0x03) * 85;

//

// orb_set(red, green, blue);

}

/**

 * Set orb1 to the specified color. This function

 * is intended to be used with the predefined

 * colors. orb_init must be called before this

 * function may be used.

 *

 * @param col the color to set the orbs to

 *

 * @see orb_init

 **/

void orb1_set_color(uint8_t  col)

{

// uint16_t red, green, blue;

//

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

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

// blue = (col & 0x03) * 85;

//

// orb1_set(red, green, blue);

}

/**

 * Set orb2 to the specified color. This function

 * is intended to be used with the predefined

 * colors. orb_init must be called before this

 * function may be used.

 *

 * @param col the color to set the orbs to

 *

 * @see orb_init

 **/

void orb2_set_color(uint8_t  col)

{

// uint16_t red, green, blue;

//

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

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

// blue = (col & 0x03) * 85;

//

// orb2_set(red, green, blue);

}

//DOES THIS WORK?

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

/* If we use the PWM for anything else besides the ORB, this implementation needs to be done better */

/**

 * Disables the orb color fading capabilities

 * by disabling the timer1 interrupt.

 *

 * @see orb_init

 **/

void orb_disable()

{

//        TCCR3B &= 0;          //Turn off everything

//        ORB_PORT |= _BV(ORB1_RED);

//        ORB_PORT |= _BV(ORB1_GREEN);

//        ORB_PORT |= _BV(ORB1_BLUE);

//        ORB_PORT |= _BV(ORB2_RED);

//        ORB_PORT |= _BV(ORB2_GREEN);

//        ORB_PORT |= _BV(ORB2_BLUE);

}

//DOES THIS WORK?

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

/**

 * Enables the orb's color fading capabilities.

 *

 * @see orb_init

 **/

void orb_enable()

{

////        TCCR0 |= _BV(COM01) | _BV(COM00)  | _BV(WGM00) | _BV(CS01);        //Toggle OC Pin on match, FAST PWM Mode, clock/8

//        TCCR3B =_BV(CS31);

}

/** @} **/ //end group