View difference between Paste ID: tU6stCT5 and wj0wxjX1

 /*
 Copyright 2011 Dustin L. Westaby
 
 ----------------------------------------------------------------------
     Stairway Light Controller for Attiny2313
 ----------------------------------------------------------------------
 Title:      stairway.c
 Author:     Dustin Westaby
 Date Created:   01/19/12
-Last Modified:
+Last Modified:
-Purpose:  Monitor proximity and motion sensors and animate stairway
+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
+ 23         PC0      Prox Sensor Low  (digital) 5 feet range
- 24		   PC1	   Prox Sensor High (digital)
+ 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
+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          |
+//          Delay Subroutine           |
 //--------------------------------------
-//These functions are from the delay.h include, the calls to delay functions
+//This function is 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) {
+void delay_ms(uint16_t ms)
 {
   while ( ms )
   {
     _delay_ms(1);
     ms--;
   }
 }
-void delay_us(uint16_t us) {
+
-  while ( us )
+
 //          Other Functions            |
-    _delay_us(1);
+
-    us--;
+
 void standby_sequence(int count)
 {
    // Description:
    // This function animates a back and forth motion
    // Approx 4 transitions per second
 
    // Example:
    // 0 1 2 3 4 5 6 7 8  Channels
    // 0 1 0 1 0 1 0 1 0  Odd Count
    // 1 0 1 0 1 0 1 0 1  Even Count
-	int i;
+
    int i;
-	//determine if count is even or odd
+
-	PORTB = ALL_OFF;
+   //determine if count is even or odd
-	if (count % 2 == 0)
+   PORTB = ALL_OFF;
-	{
+   if (count % 2 == 0)
-		//every other bit, even
+   {
-		for (i=START_CH; i <= NUM_OF_CH; i+=2)
+      //every other bit, even
-		{
+      for (i=START_CH; i <= NUM_OF_CH; i+=2)
-			PORTB |= (1 << i);
+      {
-		}
+         PORTB |= (1 << i);
-	}
+      }
-	else
+   }
-	{
+   else
-		//every other bit, odd
+   {
-		for (i=(START_CH+1); i <= NUM_OF_CH; i+=2)
+      //every other bit, odd
-		{
+      for (i=(START_CH+1); i <= NUM_OF_CH; i+=2)
-			PORTB |= (1 << i);
+      {
-		}
+         PORTB |= (1 << i);
-	}
+      }
    }
 
 
 }
 
 void animate_sequence(int direction, int onoff)
-	int time = 100;
+
-	int i;
+   int time = 100;
    int i;
-	if(direction == up)
+
-	{
+   if(direction == up)
-		if (onoff == on )
+   {
-		{
+      if (onoff == on )
-			//rotates through.
+      {
-			PORTB = ALL_OFF;
+         // Animates by rotating through.
-			for (i=START_CH; i < NUM_OF_CH; i++)
+         PORTB = ALL_OFF;
-			{
+         for (i=START_CH; i < NUM_OF_CH; i++)
-				PORTB |= (1 << i);
+         {
-				delay_ms(time);
+            PORTB |= (1 << i);
-			}
+            delay_ms(time);
          }
-		}
+
-		else
+      }
-		{
+      else
-			//rotates through.
+      {
-			PORTB = ALL_ON;
+         // Animates by rotating through.
-			for (i=START_CH; i < NUM_OF_CH; i++)
+         PORTB = ALL_ON;
-			{
+         for (i=START_CH; i < NUM_OF_CH; i++)
-				PORTB &= ~(1 << i);
+         {
-				delay_ms(time);
+            PORTB &= ~(1 << i);
-			}
+            delay_ms(time);
          }
-		}
+
       }
-	}
+
-	else
+   }
-	{
+   else
-		if (onoff == on )
+   {
-		{
+      if (onoff == on )
-			//reverse rotates through.
+      {
-			PORTB = ALL_OFF;
+         // Animates by reverse rotating through.
-			for (i=( START_CH + NUM_OF_CH - 1); i >= 0; i--)
+         PORTB = ALL_OFF;
-			{
+         for (i=( START_CH + NUM_OF_CH - 1); i >= 0; i--)
-				PORTB |= (1 << i);
+         {
-				delay_ms(time);
+            PORTB |= (1 << i);
-			}
+            delay_ms(time);
-		}
+         }
-		else
+      }
-		{
+      else
-			//reverse rotates through.
+      {
-			PORTB = ALL_ON;
+         // Animates by reverse rotating through.
-			for (i=( START_CH + NUM_OF_CH - 1); i >= 0; i--)
+         PORTB = ALL_ON;
-			{
+         for (i=( START_CH + NUM_OF_CH - 1); i >= 0; i--)
-				PORTB &= ~(1 << i);
+         {
-				delay_ms(time);
+            PORTB &= ~(1 << i);
-			}
+            delay_ms(time);
-		}
+         }
-	}
+      }
    }
 
 }
 
-int low_read()
+int read_prox(int pin)
 {
    // This function allows for some debouncing
-	if (bit_is_set(PIND, PD0))
+
-	{
+   if (bit_is_set(PIND, pin))
-		delay_ms(1);
+   {
-		if (bit_is_set(PIND, PD0))
+      delay_ms(1);
-		{
+      if (bit_is_set(PIND, pin))
-			delay_ms(5);
+      {
-			return 1;
+         return 1;
-		}
+      }
-	}
+   }
 
-	return 0;
+   return 0;
 }
 
-int high_read()
+
 {
 
-	if (bit_is_set(PIND, PD1))
+   //[tbd] read motion sensor
-	{
+
-		delay_ms(1);
+   return 0;
-		if (bit_is_set(PIND, PD1))
+
-		{
+
-			delay_ms(5);
+
-			return 1;
+
-		}
+
-	}
+   // Set direction registers
    // sensors data direction
-	return 0;
+   // lighting data direction
 
    DDRA =  0b11111111;
    DDRB =  0b11111111;
    DDRD =  0b00000000;
 
-	//[tbd] read motion sensor
+   // Enable Wake Interrupts
    //[TBD]
-	return 0;
+
    // Set power down mode
    //[tbd]
 
 }
 
-	// Set direction registers
+
-	// sensors data direction
+
-	// lighting data direction
+
 //--------------------------------------
-	DDRA =  0b11111111;
+
-	DDRB =  0b11111111;
+
-	DDRD =  0b00000000;
+   // Local Variables
    int low_store = 0, high_store = 0, sens_store;
    int trigger_direction;
-	// Enable Wake Interrupts
+   int counterA, counterB;
-	//[TBD]
+   int motion_store = 0;
-
+   int TIMEOUT_MAX = 117; // approx >30 seconds, (30*1000/255) ~= 117
-	// Set power down mode
+
-	//[tbd]
+   // Pin position of Prox Sensors
    int LOWPIN = PD0;
    int HIGHPIN = PD1;
 
    // Initialize registers
    init_cpu();
 
    // Turn off LEDs
    PORTB = 0x00;
 
-	int low_store = 0, high_store = 0;
+   // Loop forever
-	int trigger_direction;
+   // TBD: Replace with timeout to sleep and save power
-	int counterA, counterB;
+   while(1)
-	int motion_store = 0;
+   {
-	int TIMEOUT_MAX = 117; //~30 seconds
+      low_store = 0;
       high_store = 0;
-	init_cpu();
+      counterA = 0;
       counterB = 0;
-	//turn off LEDs
+      motion_store = 0;
-	PORTB = 0x00;
+      sens1_store = 0;
       sens2_store = 0;
-	while(1)
+
-	{
+      // Wait for trigger on any sensor
-		low_store = 0;
+      while((low_store != 1) &&
-		high_store = 0;
+            (high_store != 1) &&
-		counterA = 0;
+            (motion_store != 1))
-		counterB = 0;
+      {
-		motion_store = 0;
+
          // Read the sensor data and store local
-		//wait for either ADC to match (ADC0 > ADC2) | (ADC1 > ADC3)
+         low_store    = read_prox(LOWPIN);
-		while((low_store != 1) && (high_store != 1) && (motion_store != 1))
+         high_store   = read_prox(HIGHPIN);
-		{
+         motion_store = motion_read();
-
+
-			//read the sensor data and store local
+      }
-			low_store = low_read();
+
-			high_store = high_read();
+      // Determine which condition fired, so that the other may be watched later
-			motion_store = motion_read();
+      if (low_store == 1)
       {
-		}
+         // Low sensor fired
-
+         trigger_direction = low;
 
-		//Determine which condition fired, so that the other may be watched later
+         // Play animations for low to high
-		if (low_store == 1)
+         animate_sequence(up, on);
-		{
+
-			//low sensor fired
+      }
-			trigger_direction = low;
+      else if (high_store == 1)
       {
-			// play animations for low to high
+         // High sensor fired
-			animate_sequence(up, on);
+         trigger_direction = high;
 
-			//turn on leds in low to high sequence
+         // Play animations for high to low
          animate_sequence(down, on);
-			//wait for high sensor
+
-			while((high_read() != 1) && (counterB <= TIMEOUT_MAX))
+      }
-			{
+      else
-				counterA++;
+      {
-				delay_ms(1);
+         //[tbd] motion detected animation
-				if (counterA >= 255)
+      }
-				{
+
-					counterA = 0;
+      // Wait for other sensor or Timeout Counter
-					counterB++;
+      while((counterB <= TIMEOUT_MAX) && (sens1_store != 1))
-				}
+      {
-
+
-				if ((motion_read() == 1) || (low_read() == 1))
+         // Determine which is next sensor to watch
-				{
+         if (trigger_direction == low)
-					//motion detected, reset timer, turn lights on
+         {
-					counterB = 0;
+            sens1_store = read_prox(HIGHPIN);
-					PORTB = ALL_ON;
+            sens2_store = read_prox(LOWPIN);
-				}
+         }
-
+         else if  (trigger_direction == high)
-				if (counterB > (2*TIMEOUT_MAX/3))
+         {
-				{
+            sens1_store = read_prox(LOWPIN);
-					//play standby animation (timeout is 2/3s complete)
+            sens2_store = read_prox(HIGHPIN);
-					standby_sequence(counterB);
+         }
-				}
+         motion_store = motion_read();
 
-			}
+         // Determine if timeout counter should be reset
          if ((motion_store == 1) || (sens2_store == 1))
-			//turn off LEDs
+         {
-			animate_sequence(up, off);
+            // Motion detected, reset timer
             counter_high = 0;
-		}
+
-		else if (high_store == 1)
+            // Turn lights on
-		{
+            PORTB = ALL_ON;
-			//high sensor fired
+         }
-			trigger_direction = high;
+
          // Timeout Counters, 1 tick >= 1ms.
-			//play animations for high to low
+         counter_low++;
-			animate_sequence(down, on);
+         delay_ms(1);
          if (counter_low >= 255)
-			//wait for low sensor
+         {
-			//also timeout
+            counter_low = 0;
-			while((low_read() != 1) && (counterB <= TIMEOUT_MAX))
+            counter_high++;
-			{
+         }
-				counterA++;
+
-				delay_ms(1);
+         // Determine if timeout is 2/3rds complete
-				if (counterA >= 255)
+         if (counter_high > (2*TIMEOUT_MAX/3))
-				{
+         {
-					counterA = 0;
+            // Play standby animation
-					counterB++;
+            standby_sequence(counter_high);
-				}
+         }
-
+
-				if ((motion_read() == 1) || (high_read() == 1))
+      } // End wait for Timeout
-				{
+
-					//motion detected, reset timer, turn lights on
+      // Turn off LEDs in proper sequence
-					counterB = 0;
+      if (trigger_direction == low)
-					PORTB = ALL_ON;
+      {
-				}
+         animate_sequence(up, off);
-
+      }
-				if (counterB > (2*TIMEOUT_MAX/3))
+      else if  (trigger_direction == high)
-				{
+      {
-					//play standby animation (timeout is 2/3s complete)
+         animate_sequence(down, off);
-					standby_sequence(counterB);
+      }
-				}
+
       // Small delay before lights are allowed to trigger again
-
+      delay_ms(2000);
-			}
+
    } // End Inf Loop
-			//turn off LEDs
+
-			animate_sequence(down, off);
+
 
-		}
+