Stair-Light Prox/Motion Sensor - Draft

/*
Copyright 2011 Dustin L. Westaby

----------------------------------------------------------------------
    Stairway Light Controller for Attiny2313
----------------------------------------------------------------------
Title:      stairway.c
Author:     Dustin Westaby
Date Created:   01/19/12
Last Modified:
Purpose:  Monitor proximity and motion sensors and animate stairway
          lighting.

Compiled with AVR-GCC WinAVR

Revisions List:
01/19/12 Initial draft

----------------------------------------------------------------------
    Fuses:
----------------------------------------------------------------------
 BrownOut Disabled
 CKDIV8
 Int RC Osc 8Mhz + 64ms

----------------------------------------------------------------------
    Inputs:
----------------------------------------------------------------------
 pin       port    function
----------------------------------------------------------------------
  1        RST     Unused
  2        PD0     Motion Sensor    (digital) (active low with pullup 10k)
 23        PC0     Prox Sensor Low  (digital) 5 feet range
 24        PC1     Prox Sensor High (digital)
  4        PD2     Override button  (digital) External Interrupt 0

----------------------------------------------------------------------
    Ouputs:
----------------------------------------------------------------------
 pin       port    function
----------------------------------------------------------------------
 14        PB0      Lighting Channel
 15        PB1      Lighting Channel
 16        PB2      Lighting Channel
 17        PB3      Lighting Channel
 18        PB4      Lighting Channel
 19        PB5      Lighting Channel
  9        PB6      Lighting Channel
 10        PB7      Lighting Channel


The Prox sensors are analog, uses a comparator to convert to digital
and a pot to select the cutoff range.

*/

//--------------------------------------
//          Global Variables           |
//--------------------------------------
// 8 MHz Internal Oscillator DIV8 (used for delay subroutines)
// One CPU Cycle = 1us
#define F_CPU 8000000UL/8

enum { up, down };
enum { on, off };
enum { low, high };

//--------------------------------------
//              Includes               |
//--------------------------------------
#include <avr/io.h>
#include <util/delay.h>
//#include <avr/sleep.h>
#include <inttypes.h>


//--------------------------------------
//          Global Constants           |
//--------------------------------------

int START_CH = PB0; //lowest channel bit
int NUM_OF_CH = 6;
int ALL_ON  = 0xFF;
int ALL_OFF = 0x00;

//--------------------------------------
//          Delay Subroutines          |
//--------------------------------------
//These functions are from the delay.h include, the calls to delay functions
//are re-written here to allow for longer waits.
void delay_ms(uint16_t ms) {
  while ( ms )
  {
    _delay_ms(1);
    ms--;
  }
}

void delay_us(uint16_t us) {
  while ( us )
  {
    _delay_us(1);
    us--;
  }
}


//--------------------------------------
//          Other Functions            |
//--------------------------------------

void standby_sequence(int count)
{
    int i;

    //determine if count is even or odd
    PORTB = ALL_OFF;
    if (count % 2 == 0)
    {
        //every other bit, even
        for (i=START_CH; i <= NUM_OF_CH; i+=2)
        {
            PORTB |= (1 << i);
        }
    }
    else
    {
        //every other bit, odd
        for (i=(START_CH+1); i <= NUM_OF_CH; i+=2)
        {
            PORTB |= (1 << i);
        }
    }


}

void animate_sequence(int direction, int onoff)
{
    int time = 100;
    int i;

    if(direction == up)
    {
        if (onoff == on )
        {
            //rotates through.
            PORTB = ALL_OFF;
            for (i=START_CH; i < NUM_OF_CH; i++)
            {
                PORTB |= (1 << i);
                delay_ms(time);
            }

        }
        else
        {
            //rotates through.
            PORTB = ALL_ON;
            for (i=START_CH; i < NUM_OF_CH; i++)
            {
                PORTB &= ~(1 << i);
                delay_ms(time);
            }

        }

    }
    else
    {
        if (onoff == on )
        {
            //reverse rotates through.
            PORTB = ALL_OFF;
            for (i=( START_CH + NUM_OF_CH - 1); i >= 0; i--)
            {
                PORTB |= (1 << i);
                delay_ms(time);
            }
        }
        else
        {
            //reverse rotates through.
            PORTB = ALL_ON;
            for (i=( START_CH + NUM_OF_CH - 1); i >= 0; i--)
            {
                PORTB &= ~(1 << i);
                delay_ms(time);
            }
        }
    }

}


int low_read()
{

    if (bit_is_set(PIND, PD0))
    {
        delay_ms(1);
        if (bit_is_set(PIND, PD0))
        {
            delay_ms(5);
            return 1;
        }
    }

    return 0;
}

int high_read()
{

    if (bit_is_set(PIND, PD1))
    {
        delay_ms(1);
        if (bit_is_set(PIND, PD1))
        {
            delay_ms(5);
            return 1;
        }
    }

    return 0;
}

int motion_read()
{

    //[tbd] read motion sensor

    return 0;
}


void init_cpu()
{
    // Set direction registers
    // sensors data direction
    // lighting data direction

    DDRA =  0b11111111;
    DDRB =  0b11111111;
    DDRD =  0b00000000;


    // Enable Wake Interrupts
    //[TBD]

    // Set power down mode
    //[tbd]

}


//--------------------------------------
//               Main                  |
//--------------------------------------
int main (void)
{
    int low_store = 0, high_store = 0;
    int trigger_direction;
    int counterA, counterB;
    int motion_store = 0;
    int TIMEOUT_MAX = 117; //~30 seconds

    init_cpu();

    //turn off LEDs
    PORTB = 0x00;

    while(1)
    {
        low_store = 0;
        high_store = 0;
        counterA = 0;
        counterB = 0;
        motion_store = 0;

        //wait for either ADC to match (ADC0 > ADC2) | (ADC1 > ADC3)
        while((low_store != 1) && (high_store != 1) && (motion_store != 1))
        {

            //read the sensor data and store local
            low_store = low_read();
            high_store = high_read();
            motion_store = motion_read();

        }


        //Determine which condition fired, so that the other may be watched later
        if (low_store == 1)
        {
            //low sensor fired
            trigger_direction = low;

            // play animations for low to high
            animate_sequence(up, on);

            //turn on leds in low to high sequence

            //wait for high sensor
            while((high_read() != 1) && (counterB <= TIMEOUT_MAX))
            {
                counterA++;
                delay_ms(1);
                if (counterA >= 255)
                {
                    counterA = 0;
                    counterB++;
                }

                if ((motion_read() == 1) || (low_read() == 1))
                {
                    //motion detected, reset timer, turn lights on
                    counterB = 0;
                    PORTB = ALL_ON;
                }

                if (counterB > (2*TIMEOUT_MAX/3))
                {
                    //play standby animation (timeout is 2/3s complete)
                    standby_sequence(counterB);
                }

            }

            //turn off LEDs
            animate_sequence(up, off);

        }
        else if (high_store == 1)
        {
            //high sensor fired
            trigger_direction = high;

            //play animations for high to low
            animate_sequence(down, on);

            //wait for low sensor
            //also timeout
            while((low_read() != 1) && (counterB <= TIMEOUT_MAX))
            {
                counterA++;
                delay_ms(1);
                if (counterA >= 255)
                {
                    counterA = 0;
                    counterB++;
                }

                if ((motion_read() == 1) || (high_read() == 1))
                {
                    //motion detected, reset timer, turn lights on
                    counterB = 0;
                    PORTB = ALL_ON;
                }

                if (counterB > (2*TIMEOUT_MAX/3))
                {
                    //play standby animation (timeout is 2/3s complete)
                    standby_sequence(counterB);
                }


            }

            //turn off LEDs
            animate_sequence(down, off);

        }
        else
        {
            //[tbd] motion detected animation
        }

        //small delay before lights are allowed to trigger again
        delay_ms(2000);




    }


  while(1);                 // Ending infinite loop (just in case)

}