View difference between Paste ID: DeVL7Ddu and fs0gKCsq

 /*
-Copyright 2011 Dustin L. Westaby
+
 Cortana Arduino Code for the ATTiny45 by Dustin Westaby
-----------------------------------------------------------------------
+
-    Prop Circuit for Attiny45
+Version History:
-----------------------------------------------------------------------
+ 2/13/11 Initial Draft and test circuit
-Title:      cortana.c
+ 2/14/11 Updated Comments, re-arranged structure
-Author:     Dustin Westaby
+ 9/17/11 Timer Off Code Added
-Date Created:   2/13/11
+ 9/27/12 converted to arduino, expanded animations (Ryuuzaki Julio)
-Last Modified:  9/17/11
+11/29/12 cleaned up and rewrote logic
-Purpose:  Animated output to LEDs
+
 Ouputs:
-Compiled with AVR-GCC WinAVR
+
   2     PB3 =   LED
-Revisions List:
+
-2/13/11 Initial Draft and test circuit
+
-2/14/11 Updated Comments, re-arranged structure
+
-9/17/11 Timer Off Code Added
+
 */
-----------------------------------------------------------------------
+
-    Fuses:
+
-----------------------------------------------------------------------
+
- BrownOut Disabled
+//arduino specific digital pin numbers
- CKDIV8
+int myPins[6] = {2,3,4,1,0};
- Int RC Osc 8Mhz + 64ms
+
 //performs subtraction then ensures positive result
-----------------------------------------------------------------------
+#define ABS_SUB(a, b) ((a) < (b)? ((b) - (a)): ((a) - (b)))
-    Inputs:
+
-----------------------------------------------------------------------
+/* -------------------- */
- Power up
+/* Helper Functions     */
 /* -------------------- */
-----------------------------------------------------------------------
+
-    Ouputs:
+// the setup routine runs once when you press reset:
-----------------------------------------------------------------------
+void setup()
 {
-----------------------------------------------------------------------
+   int i;
 
    // initialize the digital pin as an output.
    for (i=0;i<=4;i++)
    {
       pinMode(myPins[i], OUTPUT);
    }
-----------------------------------------------------------------------
+
-    Notes:
+
-----------------------------------------------------------------------
+
- -Program is free to modify, but please keep my name on the author list.
+void delay_ms(uint16_t ms)
 {
    while ( ms )
    {
-//--------------------------------------
+      _delay_ms(1);
-//          Global Variables           |
+      ms--;
-//--------------------------------------
+   }
-// 8 MHz Internal Oscillator DIV8 (used for delay subroutines)
+
-// One CPU Cycle = 1us
+
-#define F_CPU 8000000UL/8
+void delay_us(uint16_t us)
 {
-// Enumerate up down for use in the fade loops
+   while ( us )
-enum { up, down };
+   {
       _delay_us(1);
-//Option to disable the time out turn off
+      us--;
-//0 = OFF, 1 = ON
+   }
-#define TIMER_ENABLE 1
+
 
-//--------------------------------------
+/* -------------------- */
-//              Includes               |
+/* Animation Functions  */
-//--------------------------------------
+/* -------------------- */
-#include <avr/io.h>
+
 void blinkBlink(int delayTime, int MaxFlickr)
-#include <avr/sleep.h>
+
-#include <inttypes.h>
+   int i, RandomFlickrAmmount;
 
    //randomize number of blinks and delay to help blinking look more alive
-//--------------------------------------
+   RandomFlickrAmmount = random(1,MaxFlickr);
-//          Delay Subroutines          |
+
-//--------------------------------------
+   for (i = 0; i <= RandomFlickrAmmount; i++)
-//These functions are from the delay.h include, the calls to delay functions
+   {
-//are re-written here to allow for longer waits.
+      //Turn ON all LEDs 01234
-void delay_ms(uint16_t ms) {
+      PORTB = 0b00011111;
-  while ( ms )
+      delay(delayTime - RandomFlickrAmmount);
-  {
+
-    _delay_ms(1);
+      //Turn OFF all LEDs 01234
-    ms--;
+      PORTB = 0b00000000;
-  }
+      delay(delayTime - RandomFlickrAmmount);
    }
 
-void delay_us(uint16_t us) {
+} //end blink function
-  while ( us )
+
-  {
+void spinSpin(int count_delay)
-    _delay_us(1);
+
-    us--;
+   int i;
-  }
+   int repeat           = random(1,3)*5;    //random number of spins times 5 LEDs
    int circle_direction = random(0,1);      //random selection of clockwise or counterclockwise animations
    int pin_to_on  = random(0,4);            //random starting LED position for animation (on)
-//--------------------------------------
+   int pin_to_off = random(0,4);            //random starting LED position for animation (off)
-//          Sleep Subroutine           |
+
-//--------------------------------------
+   //loop ends after random number of spins
-void shutdown_and_sleep(void) {
+   for (i = 0; i <= repeat; i++)
    {
-	//setup low power sleep mode
+      if (circle_direction == 1)
-	set_sleep_mode(SLEEP_MODE_PWR_DOWN);
+      {
          //each animation section turns off one LED and turns on one LED
-	//send to sleep
+         digitalWrite(myPins[pin_to_on++], HIGH);
-	sleep_mode();
+         digitalWrite(myPins[pin_to_off++], LOW);
       }
-	//NOT HIT
+      else
-	while(1);
+      {
          //each animation section turns off one LED and turns on one LED
          digitalWrite(myPins[pin_to_on--], HIGH);
          digitalWrite(myPins[pin_to_off--], LOW);
       }
-//--------------------------------------
+
-//               Main                  |
+      //delay before next spin animation
-//--------------------------------------
+      delay(count_delay);
-int main (void)
+
       //the following overrun check works because circle_direction can only be 0 or 1.
       //When circle_direction is 0, the pin_to_on pin_to_off are decremented, down to 0.  The overrun check compares to 0, then sets to 4.
-  /* ---------------------------------------------------------------- */
+      //When circle_direction is 1, the pin_to_on pin_to_off are incremented, up to 4.  The overrun check compares to 4, then sets 0.
-  /*                            Initialization                        */
+      if (pin_to_on == circle_direction*4)
-  /* ---------------------------------------------------------------- */
+      {
-  //Variables used for animations
+         pin_to_on = ABS_SUB(circle_direction*4,4);
-  int i, count_delay, direction;
+      }
-  int time_on, time_off, max_value,  min_value, rate_of_change;
+      if (pin_to_off == circle_direction*4)
-  int time_to_off, cycle_count, fade_inc_count;
+      {
          pin_to_off = ABS_SUB(circle_direction*4,4);
-  //Initialize Port B is an output
+
-  DDRB =  0b00011111;
+         //one rotation complete
          //speed up the spinning, down to 16
-  /* ---------------------------------------------------------------- */
+         if (count_delay > 16)
-  /*                Spin Circle Four Times (approx 1s)                */
+         {
-  /* ---------------------------------------------------------------- */
+            count_delay = count_delay - 2;
-  i=0;
+         }
-  count_delay=50;             //Delay between circle movement is 50ms
+      }
-  for (i = 0; i < 4; i++)
+
-  {
+   } //end loop
-    PORTB = 0b00000001;       //Turn ON only LED 0 for defined delay (50ms)
+
-    delay_ms(count_delay);
+} //end spin function
-    PORTB = 0b00000010;       //Turn ON only LED 1 for defined delay (50ms)
+
-    delay_ms(count_delay);
+/* -------------------- */
-    PORTB = 0b00000100;       //Turn ON only LED 2 for defined delay (50ms)
+/* Main Function        */
-    delay_ms(count_delay);
+/* -------------------- */
-    PORTB = 0b00001000;       //Turn ON only LED 3 for defined delay (50ms)
+
-    delay_ms(count_delay);
+void loop()
-    PORTB = 0b00010000;       //Turn ON only LED 4 for defined delay (50ms)
+
-    delay_ms(count_delay);
+   int i = 0;
-  }
+   int count_delay, e, repeat;
    int time_on, time_off, max_value, min_value, rate_of_change;
-  /* ---------------------------------------------------------------- */
+   boolean fade_direction;
-  /*                     All ON Long (0.8 seconds)                    */
+   int Chances_of_Flickr;
-  /* ---------------------------------------------------------------- */
+   int Chances_of_Spin;
-  PORTB = 0b00011111;         //Turn ON all LEDs 01234 for 800ms
+   int X_Loops;
-  delay_ms(800);
+   int randomInt;
 
-  /* ---------------------------------------------------------------- */
+   /* Set output pins */
-  /*                         Blink Blink                              */
+   DDRB = 0b00011111;
-  /* ---------------------------------------------------------------- */
+
-  PORTB = 0b00000000;         //Turn OFF all LEDS 01234 for 100ms
+   /* ---------------------------------------------------------------- */
-  delay_ms(100);
+   /* All OFF Short */
-  PORTB = 0b00011111;         //Turn ON  all LEDs 01234 for 10ms
+   /* ---------------------------------------------------------------- */
-  delay_ms(10);
+
-  PORTB = 0b00000000;         //Turn OFF all LEDs 01234 for 100ms
+   count_delay = 20; //Delay starting point
-  delay_ms(100);
+   for (i = 0; i <= 4; i++)
-  PORTB = 0b00011111;         //Turn ON  all LEDs 01234 for 100ms
+   {
-  delay_ms(100);
+      digitalWrite(myPins[i], LOW);  //turn off each of the 4 LEDs in sequence
       delay(count_delay*2 + i*20);   //delay increases after each iteration
-  /* ---------------------------------------------------------------- */
+   }
-  /*              Fade In and Out Continuous (Software PWM)           */
+
-  /* ---------------------------------------------------------------- */
+   /* ---------------------------------------------------------------- */
-  max_value=500;              //Max of 500us for LEDs ON
+   /* Spin Circle (single runner) */
-  min_value=5;                //Max of   5us for LEDs OFF
+   /* ---------------------------------------------------------------- */
-  time_on=min_value;          //Set Starting Time ON  to 5us
+
-  time_off=max_value;         //Set Starting Time OFF to 500us
+   repeat = 8;       //Number of spins
-  rate_of_change=2;           //This is the speed that the fade goes between min and max
+   count_delay = 60; //Delay between circle movement in ms
-  direction=down;             //Direction is defined for the direction of the fade (in or out)
+
-
+   for(e = 0; e <= repeat; e++)
-  time_to_off=5*(54);         //About 5 minutes (54 fades per minute)
+   {
-  cycle_count=0;              //Use to count the number of times fades to dark
+      for (i = 0; i <= 4; i++)
-  fade_inc_count=0;           //Used to count iterations of the fade loop
+      {
          digitalWrite(myPins[i], HIGH);
-  /* Note: The direction is backwards on purpose, causes the light animation to
+         delay(count_delay);
-           look like it hiccuped for the first fade cycle before reaching a steady fade. */
+         digitalWrite(myPins[i], LOW);
       }
-  while(1)
+
-  {
+      if (count_delay >= 6)
-  	//The ratio of ON time and OFF time determines the brightness of the LEDs (DUTY CYLE)
+      {
-  	//By continuously varying the ON time versus the OFF times we get a fade effect.
+         count_delay = count_delay - 6;
-    PORTB = 0b00011111;       //Turn ON  all LEDs 01234
+      }
-    delay_us(time_on);
+   }
-    PORTB = 0b00000000;       //Turn OFF all LEDs 01234
+
-    delay_us(time_off);
+   /* ---------------------------------------------------------------- */
    /* Spin Circle (chased runner) */
-	//This is the TimeOut code. Breaks loop.turning off the LEDs.
+   /* ---------------------------------------------------------------- */
-	if (TIMER_ENABLE)
+
-	{
+   spinSpin(16);  //spin with constant speed of 16ms
-		fade_inc_count++;
+
-		if (fade_inc_count>(max_value/2))
+   /* ---------------------------------------------------------------- */
-		{
+   /* All ON Long */
-			fade_inc_count=0;
+   /* ---------------------------------------------------------------- */
-			cycle_count++;
+
    count_delay = 20; //Delay starting point
-			if (cycle_count > time_to_off)
+
-			{
+   for (i = 0; i <= 4; i++)
-				shutdown_and_sleep();
+   {
-				//does not return
+      digitalWrite(myPins[i], HIGH);  //turn on each of the 4 LEDs in sequence
-				break;
+      delay(count_delay*2 + i*20);    //delay increases after each iteration
-			}
+   }
-		}
+   delay(200);
-	}
+
    /* ---------------------------------------------------------------- */
-    if (direction==up)
+   /* Blink Blink */
-    {
+   /* ---------------------------------------------------------------- */
-    	//In the UP direction the Time ON increases while the Time OFF decreases.
+
-    	//The result is that the LEDs get brighter
+   blinkBlink(50,5);
-      time_on+=rate_of_change;
+   delay_ms(100);
-      time_off-=rate_of_change;
+   blinkBlink(50,2);
    delay(200);
-      //When the end of the fade is reached, switch directions
+
-      if (time_on>max_value)
+   /* ---------------------------------------------------------------- */
-        direction=down;
+   /* Fade In and Out Continuous (Software PWM) */
-    }
+   /* ---------------------------------------------------------------- */
-    else
+
-    {
+   max_value = 400;           //Max for LEDs ON in us
-    	//In the DOWN direction the Time ON decreases while the Time OFF increases.
+   min_value = 3;             //Max for LEDs OFF in us
-    	//The result is that the LEDs get dimmer
+   time_on  = min_value;      //Set Starting Time ON to min
-      time_on-=rate_of_change;
+   time_off = max_value;      //Set Starting Time OFF to max
-      time_off+=rate_of_change;
+   rate_of_change = 1;        //This is the speed that the fade goes between min and max
    fade_direction = false;    //Direction is defined for the direction of the fade (in or out)
-      //When the end of the fade is reached, switch directions
+   Chances_of_Flickr = 2;     //The breathing animation has 2 in X_Loops chances of flickering.
-      if (time_on<=min_value)
+   Chances_of_Spin   = 1;     //The breathing animation has 1 in X_Loops chances of Spining.
-        direction=up;
+   X_Loops = 3000;
-    }
+
-  }
+   while(true) // Repeat Forever
    {
-  //this code should not be hit, the following is just in case
+
-  set_sleep_mode(SLEEP_MODE_PWR_DOWN);
+      //Turn ON all LEDs 01234
-  sleep_mode();
+      PORTB = 0b00011111;
-  while(1);  // Ending infinite loop
+      delay_us(time_on);
 
-}
+      //Turn OFF all LEDs 01234
       PORTB = 0b00000000;
       delay_us(time_off);
 
       if (fade_direction==true)
       {
          //In the UP direction the Time ON increases while the Time OFF decreases.
          //The result is that the LEDs get brighter
          time_on  += rate_of_change;
          time_off -= rate_of_change;
 
          //When the end of the fade is reached, switch directions
          if (time_on>max_value)
          {
             fade_direction = false;
          }
       }
       else
       {
          //In the DOWN direction the Time ON decreases while the Time OFF increases.
          //The result is that the LEDs get dimmer
          time_on  -= rate_of_change;
          time_off += rate_of_change;
 
          //When the end of the fade is reached, switch directions
          if (time_on <= min_value)
          {
             fade_direction=true;
          }
       }
 
       //Throughout the sequence, random chance of blinking or spinning instead of normal fading
       randomInt= random(1, X_Loops);
       if (randomInt <= Chances_of_Flickr)
       {
          blinkBlink(15, 4);
       }
 
       if (randomInt >= X_Loops-Chances_of_Spin)
       {
          spinSpin(30);  //spin with increasing speed, from 20 to 16ms
       }
 
    } //end inf loop
 
 } // end main loop