Subversion Repositories HomeAutomation

/**

 * CAN RGB LED. This application is used to control a RGB LED.

 * Still under heavy development

 *

 * @date    2007-02-10

 * @author  Martin Nordén

 *

 * TODO: Better CAN Integration, Failsafe mode, Tempsensors etc.

 * Also, check current/destination intensity better when in a program?

 *

 * A little comment here :)

 */

/*-----------------------------------------------------------------------------

 * Includes

 *---------------------------------------------------------------------------*/

/* system files */

#include <avr/interrupt.h>

#include <inttypes.h>

#include <stdio.h>

#include <avr/pgmspace.h> //To allow read/write from flash

#include <math.h>

#include <drivers/timer/timebase.h>

#include <config.h> // All configuration parameters

#include <bios.h>   // BIOS interface declarations, including CAN structure and ID defines.

#include <string.h> //for memcpy

/* lib files */

#include <bios.h>

//#include <funcdefs/funcdefs.h>

//#include <settings.h>

/*----------------------------------------------------------------------------

 * Defines

 * -------------------------------------------------------------------------*/

//Working on implementing all of these...

#define RGBLED_CMD_STATUS           0x00    /* Get status */

#define RGBLED_CMD_SETRGB           0x01    /* Set RGB Triplet */

#define RGBLED_CMD_CHANGERGB        0x02    /* Change RGB +/- */

#define RGBLED_CMD_SETPROGRAM       0x03    /* Set program */

#define RGBLED_CMD_SETFADESPEED     0x04    /* Set fadespeed */

#define RGBLED_CMD_SETDIMSPEED      0x05    /* Set dimspeed */

#define RGBLED_CMD_SETINTENS        0x10    /* Set intensity */

#define APP_TYPE    CAN_APPTYPES_RGBLED

#define APP_VERSION 0x0001

#define GROUP_ID    0x01L // FIXME

#define TRUE 1

#define FALSE !TRUE

/*----------------------------------------------------------------------------

 * Ehm, struct?

 * -------------------------------------------------------------------------*/

typedef struct

{

    uint8_t R;

    uint8_t G;

    uint8_t B;

    uint8_t Intens;

} Color;

/*-----------------------------------------------------------------------------

 * Programs! There will be a better way to add programs here.. some day.

 *---------------------------------------------------------------------------*/

//Special combinations that means something special

//The combinations are useless for lighting anyway

//So we might as well use them!

//0x00, 0x00, 0x00, 0x00 means end of program, keep looping it

//0x00, 0x00, 0x00, 0x01 means end of program, halt 

Color pgm1[] PROGMEM = {

{0xff,0x00,0x00,0x64},

{0xff,0xff,0x00,0x10},

{0x00,0xff,0x00,0xa0},

{0x00,0xff,0xff,0x7f},

{0x00,0x00,0xff,0x7f},

{0xff,0x00,0xff,0x40},

{0x00,0x00,0x00,0x00}

};

Color pgm2[] PROGMEM = {

{0xff,0x00,0x00,0x00},

{0xff,0xff,0x00,0x00},

{0xff,0xff,0xff,0x00},

{0xa0,0x00,0xa0,0x00},

{0x00,0x00,0xff,0x00},

{0x00,0x00,0x00,0x00}

};

Color pgm3[] PROGMEM = {

{0xff,0xff,0xff,0x00},

{0x00,0x00,0x00,0x01}

};

Color* programs[] PROGMEM = {

(Color*)pgm1,

(Color*)pgm2,

(Color*)pgm3

};

/*-----------------------------------------------------------------------------

 * Global variables

 *---------------------------------------------------------------------------*/

uint32_t timeStamp; //TimeStamp to keep track of time

uint32_t dimStamp;  //Timestamp to keep track of dimmer changes

Color currColor;    //Current color

Color destColor;    //Destination color

uint16_t fadeSpeed; //Fadingspeed. 16bit for reaaaally slow fading. Sets the speed of colorchange.

uint8_t dimSpeed;       //Dimmer speed. Sets the speed of intensitychange.

uint8_t currProgram;    //This variable keeps track of what program is currently running. 

uint8_t programMode;    //This keeps track of what mode we are currently using. 0: the program obeyes the current brightness, 1: the program is allowed to set it's own brightness

Can_Message_t txMsg;    //Transmit message storage

volatile Can_Message_t rxMsg; // Message storage

volatile uint8_t rxMsgFull;   // Synchronization flag

uint8_t lastr;

uint8_t lastg;

uint8_t lastb;

/*----------------------------------------------------------------------------

 * Functions

 * -------------------------------------------------------------------------*/

void updateLED(void);

void reformatRGB(uint8_t R, uint8_t G, uint8_t B, uint8_t setBright);

void changeColor(int8_t amount, uint8_t* color);

void fade(uint8_t* current, uint8_t* destination);

/* Takes care of incoming messages and parses them if this node is adressed */

void can_receive(Can_Message_t *msg)

{ // CAN callback function

    if (!rxMsgFull) {

        memcpy((void*)&rxMsg, msg, sizeof(rxMsg));

        rxMsgFull = 1;

    }

}

/*-----------------------------------------------------------------------------

 * Main Program

 *---------------------------------------------------------------------------*/

int main(void) {

//Setting up OC1A, 16 bit counter used as 8 bit.

    TCCR1A |= (1<<COM1A1) | (1<<WGM11); /* Set OC1A at TOP, mode 14 */

    TCCR1B |= (1<<WGM13) | (1<<WGM12) | (1<<CS11)| (1<<CS10); /* Timer uses main system clock with ? prescale */

    ICR1 = 256; //8 bit precision to match the other two counters.

    OCR1A = 0;  //0% as standard

    DDRB |= (1<<PB1); /* Enable pin as output */

//Setting up OC0A

    TCCR0A |= (1<<COM0A1)|(1<<WGM01)|(1<<WGM00); /* Set OC0A at TOP, Mode 7 */

    TCCR0B |= (1<<CS01)|  (1<<CS00); /* Prescaler updating now */

    OCR0A = 0;  //0% standard

    DDRD |= (1<<PD6);

//Setting up OC0B

    TCCR0A |= (1<<COM0B1);

    OCR0B = 0;

    DDRD |= (1<<PD5);

//Initialize variables

    fadeSpeed = 40;

    dimSpeed = 10;

    timeStamp = 0;

    dimStamp = 0;

    reformatRGB(0x00,0x00,0x00,1);

    destColor.Intens = 0xa0;

    currColor = destColor;

//Just temporary for now, they keep track of some kind of demo-program.

    currProgram = 1;

    programMode = 0;

    uint16_t temp_adress = pgm_read_word(&programs[currProgram-1]); //Get adress for program 0

    sei();

    BIOS_CanCallback = &can_receive;

//Send a message that we are alive!

    txMsg.Id = (CAN_NMT_APP_START << CAN_SHIFT_NMT_TYPE) | (NODE_ID << CAN_SHIFT_NMT_SID);

    txMsg.DataLength = 4;

    txMsg.RemoteFlag = 0;

    txMsg.ExtendedFlag = 1;

    txMsg.Data.words[0] = APP_TYPE;

    txMsg.Data.words[1] = APP_VERSION;

    BIOS_CanSend(&txMsg);

//Lets get timebase up and running

    Timebase_Init();

    /* main loop */

    while (1) {

        /* Time to fade color? */

        if ((Timebase_CurrentTime() - timeStamp) >= fadeSpeed) {

            fade(&currColor.R, &destColor.R);          

            fade(&currColor.G, &destColor.G);

            fade(&currColor.B, &destColor.B);

            timeStamp = Timebase_CurrentTime();

            updateLED();

        }

        /* Time to fade intensity? */

        if (Timebase_CurrentTime() - dimStamp >= dimSpeed) {

            fade(&currColor.Intens, &destColor.Intens);

            dimStamp = Timebase_CurrentTime();

            updateLED();

        }

        /* Program management */

        if (currProgram != 0) { //Check if a program is currently running

            if ((currColor.R == destColor.R)&(currColor.G == destColor.G)&(currColor.B == destColor.B)&(currColor.Intens == destColor.Intens)){//Is the current sequence finished?

                //Now we have to check if the program is finished and if we should loop

                if ((pgm_read_byte(temp_adress)==0)&(pgm_read_byte(temp_adress+1)==0)&(pgm_read_byte(temp_adress+2)==0)){

                    //The program has ended! Shall we loop it?

                    if (pgm_read_byte(temp_adress+3)==0){

                        //Yes, let's loop it

                        temp_adress = pgm_read_word(&programs[currProgram-1]);

                    } else {

                        //No, halt!

                        currProgram = 0;

                    }

                } else {

                    //The program has not ended, let's get the next RGB-triplet!

                    destColor.R = pgm_read_byte(temp_adress);

                    destColor.G = pgm_read_byte(temp_adress + 1);

                    destColor.B = pgm_read_byte(temp_adress + 2);

                    if (programMode == 1){

                        destColor.Intens = pgm_read_byte(temp_adress + 3);

                    }

                    temp_adress = temp_adress + 4;             

                }

            }

        }

        /* Check if any messages has been recieved */

        if (rxMsgFull) {

            uint16_t acttype;

            uint8_t rgbledid;          

            if ( ((rxMsg.Id & CAN_MASK_CLASS)>>CAN_SHIFT_CLASS) == CAN_ACT){

                // Actuator package

                acttype =(uint16_t)((rxMsg.Id & CAN_MASK_ACT_TYPE) >> CAN_SHIFT_ACT_TYPE);

                rgbledid = (uint8_t)((rxMsg.Id & CAN_MASK_ACT_ID) >> CAN_SHIFT_ACT_ID);

                if ((acttype == ACT_TYPE_RGBLED) && (rgbledid == THISRGBLEDID)) {                                                          

                    // This is a message for this rgbled

                    if( rxMsg.Data.bytes[0] == RGBLED_CMD_SETPROGRAM ){

                        /* Set a program! Untested! */

                        currProgram = rxMsg.Data.bytes[1];

                        temp_adress = pgm_read_word(&programs[currProgram-1]);             

                    } else if ( rxMsg.Data.bytes[0] == RGBLED_CMD_SETINTENS ){

                        /* Set intensity! Works!*/

                        if (rxMsg.Data.bytes[1] == TRUE){

                            currColor.Intens = rxMsg.Data.bytes[2];                

                        }

                        destColor.Intens = rxMsg.Data.bytes[2];

                        if (rxMsg.Data.bytes[3] != 0){

                            dimSpeed = rxMsg.Data.bytes[3];

                        }

                    } else if( rxMsg.Data.bytes[0] == RGBLED_CMD_SETRGB) {

                        /* Set RGB-triplet! */

                        reformatRGB(rxMsg.Data.bytes[2],rxMsg.Data.bytes[3],rxMsg.Data.bytes[4],0);

                        if (rxMsg.Data.bytes[5] != 0){

                            destColor.Intens = rxMsg.Data.bytes[5];

                        }

                        if (rxMsg.Data.bytes[1] == TRUE){

                            currColor = destColor;

                        }

                        if (rxMsg.Data.bytes[7] != 0){

                            fadeSpeed = rxMsg.Data.bytes[6] * 255 + rxMsg.Data.bytes[7];

                        }

                        currProgram = 0;               

                    }

                }

            }

            rxMsgFull = 0; //  

        }

        /* Done checking incoming packages */

    }

    return 0;

}

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

 *     updateLED updates the PWM counter values and thus changes the color of the RGBLED.       *

 *     It doesn't reculculate anything, except the values to write to the PWM registers.        *

 *     TODO: Get rid of the tempcontainer!                                                      *

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

void updateLED(){

    uint8_t tempcontainer;

    tempcontainer = currColor.R * currColor.Intens / 0xff;  //I really want to skip this, don't know how yet though.

    OCR1A = tempcontainer;

    OCR0A = currColor.G * currColor.Intens / 0xff;

    OCR0B = currColor.B * currColor.Intens / 0xff;

    //Just for debug

    Can_Message_t txMsg;

    txMsg.Id = 0x55;

    txMsg.RemoteFlag = 0;

    txMsg.ExtendedFlag = 1;

    txMsg.DataLength = 4;

    txMsg.Data.bytes[0] = currColor.R * currColor.Intens / 0xff;

    txMsg.Data.bytes[1] = currColor.G * currColor.Intens / 0xff;

    txMsg.Data.bytes[2] = currColor.B * currColor.Intens / 0xff;

    txMsg.Data.bytes[3] = currColor.Intens;

    //BIOS_CanSend(&txMsg); //Strictly for debug..

}

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

 *     reformatRGB sets a new target RGB triplet to fade to. It reformats it so that            *

 *     the highest color always gets 0xff. Brightness is recalculated.                          *

 *     if setBright is set to 0, the brightness will not be updated.                            *

 *     TODO: Smarter 16-bit arithmetics would be nice.                                          *

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

void reformatRGB(uint8_t R, uint8_t G, uint8_t B, uint8_t setBright){

    uint8_t maxvalue;

    uint16_t tempcontainer;

    if ((R>=G)&(R>=B)){

        maxvalue = R;

    } else if ((G>=R)&(G>=B)){

        maxvalue = G;

    } else {

        maxvalue = B;

    }

    tempcontainer = R * 255;

    destColor.R = tempcontainer/maxvalue;

    tempcontainer = G * 255;

    destColor.G = tempcontainer/maxvalue;

    tempcontainer = B * 255;

    destColor.B = tempcontainer/maxvalue;

    if (setBright){

        destColor.Intens = maxvalue;

    }

}

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

 *     fade takes two pointers, current and destination and fades current                       *

 *     one tick closer to destination.                                                          *

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

void fade(uint8_t* current, uint8_t* destination){

    if (*current > *destination){

        *current = *current - 1;

    } else if (*current < *destination){

        *current = *current + 1;

    }

}

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

 *     changeColor changes a color accord to amount. -127>127.                                  *

 *     color is either dest och curr R,G,B.                                                     *

 *     Maybe TODO: If red is already 255 and we want to increase it, decrease the other ones.   *

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

void changeColor(int8_t amount, uint8_t* color){

    if ( ((amount > 0)&(*color < 255)) || ((amount < 0)&(*color > 0)) ) //Se till att vi inte slår över *color

    *color = *color + amount;

}