View difference between Paste ID: F0ipbdNN and RV0tsMFz

 /*
 Copyright 2012 D Westaby
 
 ----------------------------------------------------------------------
    Generic Pattern for Attiny2313
 ----------------------------------------------------------------------
 Title:      Generic_Lighting.c
 Author:     Dustin Westaby
 Date Created:   September 8, 2012
 Date Modified:   March 21, 2013
 
 Compiled with AVR-GCC WinAVR
 
 Connection reference by Alex Weber:
 http://tinkerlog.com/2009/06/18/microcontroller-cheat-sheet/
 
 ----------------------------------------------------------------------
     Fuses:
 ----------------------------------------------------------------------
  BrownOut Disabled
  CKDIV8
  Int RC Osc 8Mhz + 64ms
 
 ----------------------------------------------------------------------
     Inputs:
 ----------------------------------------------------------------------
  pin  i/o  port    circuit trace       notes
 ----------------------------------------------------------------------
   1    0   PA2 =   RESET               Momentary Switch to ground
  10        GND =   Ground
  12    0   PB0 =   B0                  Momentary Switch to ground
  20        VCC =   +V Battery
 
 Note: Momentary switches need pullup 10k resisters
 
 ----------------------------------------------------------------------
     Ouputs:
 ----------------------------------------------------------------------
  pin  i/o  port    circuit trace       notes
 ----------------------------------------------------------------------
   2    1   PD0 =   LED1                *1
   3    1   PD1 =   LED2                *1
   4    1   PA1 =   LED3                *1
   5    1   PA0 =   LED4                *1
   6    1   PD2 =   LED5
   7    1   PD3 =   LED6
   8    1   PD4 =   LED7
   9    1   PD5 =   LED8
  11    1   PD6 =   LED9
  13    1   PB1 =   LED10
  14    1   PB2 =   LED11
- 17    1   PB5 =   LED12               *1
+ 15    1   PB3 =   LED12
- 18    1   PB6 =   LED13               *1
+ 16    1   PB4 =   LED13
- 19    1   PB7 =   LED14               *1
+ 17    1   PB5 =   LED14               *1
  18    1   PB6 =   LED15               *1
  19    1   PB7 =   LED16               *1
 
 Note *1 - LED connected will disable pin's alternate functions
           = external osc
           = serial
           = programming
           Use a resister to isolate these.
 
 */
 
 //--------------------------------------
 //          Global Variables           |
 //--------------------------------------
 // 8 MHz Internal Oscillator DIV8 (used for delay subroutines)
 // One CPU Cycle = 1us
 #define F_CPU 8000000UL/8
 
 #define LED1_PD0  (0)
 #define LED2_PD1  (1)
 #define LED3_PA1  (1)
 #define LED4_PA0  (0)
 #define LED5_PD2  (2)
-#define LED7_PD4  (4) //These 4 are new to the program
+
 
 #define LED7_PD4  (4)
 #define LED8_PD5  (5)
 #define LED9_PD6  (6)
 #define LED10_PB1 (1)
-#define LED12_PB5  (5)
+#define LED12_PB3 (3)
-#define LED13_PB6  (6)
+#define LED13_PB4 (4)
-#define LED14_PB7  (7)
+
 #define LED11_PB2  (2)
 #define LED14_PB5  (5)
 #define LED15_PB6  (6)
 #define LED16_PB7  (7)
 
 #define INPUT_PB0 (0)
 
 #define CONST_DIM_DELAY_ON  (200)
 #define CONST_DIM_DELAY_OFF (4000)
 
 /* This value is used to count us of delay and convert to ms
    Due to other cpu processing: "1ms of delay" < "1000us of delay" */
 //#define TIME_CONVERSION_VAL (50) //actual number should be 150 (am running faster)
 #define TIME_CONVERSION_VAL (150)
 
 #define OFF (0)
 #define ON  (1)
 
 #define LED_ON(led_position)  (ON<<led_position)
 #define LED_OFF(led_position) (OFF<<led_position)
 
 #define INPUT_SW   (0)
 #define OUTPUT_LED (1)
 
 int program_ms_counter;
 int program_counter_us; //used for tracking time elapsed
 
 //--------------------------------------
 //              Includes               |
 //--------------------------------------
 #include <avr/io.h>
 #include <util/delay.h>
 
 //--------------------------------------
 //          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) {
         program_ms_counter+=ms;
         while ( ms )
         {
                 _delay_ms(1);
                 ms--;
         }
 }
 void delay_us(uint16_t us) {
   program_counter_us+=us;
   while ( us )
   {
     _delay_us(1);
     us--;
   }
 
   while(program_counter_us>=TIME_CONVERSION_VAL)
   {
           program_ms_counter++;
           program_counter_us-=TIME_CONVERSION_VAL;
   }
 }
 
 //--------------------------------------
 //         Common Subroutines          |
 //--------------------------------------
 
 void reset_ms_us_counters(void) {
    program_ms_counter=0;
    program_counter_us=0;
 }
 
 void all_LEDs_ON(void) {
    PORTA = 0xFF;
    PORTB = 0xFF;
    PORTD = 0xFF;
 }
 
 void all_LEDs_OFF(void) {
    PORTA = ~(0x03);
    PORTB = ~(0xFF);
    PORTD = ~(0xFF);
 }
 
 //--------------------------------------
-  // the button is pressed when bit is clear
+
 //--------------------------------------
 int button_is_pressed()
 {
   // the button is pressed when bit is clear (ground)
   if (bit_is_clear(PINB, PB0))
   {
     delay_ms(25);
     if (bit_is_clear(PINB, PB0)) return 1;
   }
 
   return 0;
 }
 
-void program_left_turn_mode(void) {
+
-   /* Opposite '~', actually turns the following LEDs OFF */
+
-   PORTA &= ~(LED_ON(LED3_PA1) | LED_ON(LED4_PA0));
+
 
-   PORTA &= 0xFF & (LED_OFF(LED3_PA1) | LED_OFF(LED4_PA0));
+
 
-   PORTB &= ~(LED_ON(LED14_PB7) | LED_ON(LED12_PB5));
+
-   PORTD &= ~(LED_ON(LED6_PD3) | LED_ON(LED5_PD2) | LED_ON(LED2_PD1) | LED_ON(LED1_PD0));
+
       all_LEDs_ON();
       delay_us(CONST_DIM_DELAY_ON);
-void program_brake_mode(void) {
+
-   /* Opposite '~', actually turns the following LEDs OFF */
+
-   PORTA &= ~(LED_ON(LED3_PA1) | LED_ON(LED4_PA0));
+
 
 }
-void program_right_turn_mode (void) {
+void program_outer_leds (int circle) {
-   /* Opposite '~', actually turns the following LEDs OFF */
+
-   PORTA &= ~(LED_ON(LED3_PA1) | LED_ON(LED4_PA0));
+   /* The outer circle of LEDs are made up of the following eight:
-   PORTB &= ~(LED_ON(LED14_PB7) | LED_ON(LED13_PB6) | LED_ON(LED12_PB5) | LED_ON(LED11_PB2));
+      LED9_PD6    1  00000001
-   PORTD &= ~(LED_ON(LED6_PD3) | LED_ON(LED2_PD1));
+      LED10_PB1   2  00000010
       LED11_PB2   3  00000100
       LED12_PB3   4  00001000
       LED13_PB4   5  00010000
       LED14_PB5   6  00100000
       LED15_PB6   7  01000000
       LED16_PB7   8  10000000
     */
 
    //start with circle off
    PORTB |= LED_OFF(LED10_PB1) | LED_OFF(LED11_PB2) | LED_OFF(LED12_PB3) |
             LED_OFF(LED13_PB4) | LED_OFF(LED14_PB5) | LED_OFF(LED15_PB6) |
             LED_OFF(LED16_PB7);
    PORTD |= LED_OFF(LED9_PD6);
 
-void program_break_loop (int timer_val) {
+   //turn on the leds requested in the byte passed in
    for ( int i=0; circle != 0, i < 8; i++ )
    {
       if ( circle && (1<<i) )
       {
          switch (i)
-      program_brake_mode();
+         {
             case 1
                PORTD |= LED_ON(LED9_PD6);
                break;
             case 2
                PORTB |= LED_ON(LED10_PB1);
-void program_left_turn_loop (int timer_val) {
+               break;
             case 3
                PORTB |= LED_ON(LED11_PB2);
                break;
             case 4
                PORTB |= LED_ON(LED12_PB3);
-      program_left_turn_mode();
+               break;
             case 5
                PORTB |= LED_ON(LED13_PB4);
                break;
             case 6
                PORTB |= LED_ON(LED14_PB5);
-void program_right_turn_loop (int timer_val) {
+               break;
             case 7
                PORTB |= LED_ON(LED15_PB6);
                break;
             case 8
                PORTB |= LED_ON(LED16_PB7);
-      program_right_turn_mode();
+               break;
             default
                //should never hit
                circle = 0;
                break;
          } //end switch
       } // end if
    } // end loop
 }
 
 void program_inner_leds (int circle) {
 
    /* The inner circle of LEDs are made up of the following eight:
-  /* ---------------------------------------------------------------- */
+      LED1_PD0   1  00000001
-  /*                            Initialization                        */
+      LED2_PD1   2  00000010
-  /* ---------------------------------------------------------------- */
+      LED3_PA1   3  00000100
       LED4_PA0   4  00001000
-  //Initialize all ports
+      LED5_PD2   5  00010000
-//  DDRA =  0b00000011; //A0, A1
+      LED6_PD3   6  00100000
-//  DDRB =  0b11111111;
+      LED7_PD4   7  01000000
-//  DDRD =  0b11111111;
+      LED8_PD5   8  10000000
-  DDRA =  (OUTPUT_LED<<LED4_PA0) | (OUTPUT_LED<<LED3_PA1);
+    */
-  DDRB =  (INPUT_SW<<INPUT_PB0) | (OUTPUT_LED<<LED10_PB1) | (OUTPUT_LED<<LED11_PB2) | (OUTPUT_LED<<LED12_PB5) | (OUTPUT_LED<<LED13_PB6) | (OUTPUT_LED<<LED14_PB7);
+
-  DDRD =  (OUTPUT_LED<<LED1_PD0) | (OUTPUT_LED<<LED2_PD1) | (OUTPUT_LED<<LED5_PD2) | (OUTPUT_LED<<LED6_PD3) | (OUTPUT_LED<<LED7_PD4) | (OUTPUT_LED<<LED8_PD5) | (OUTPUT_LED<<LED9_PD6);
+   //start with circle off
    PORTD |= LED_OFF(LED1_PD0) | LED_OFF(LED2_PD1) | LED_OFF(LED5_PD2) |
-  all_LEDs_OFF();
+            LED_OFF(LED6_PD3) | LED_OFF(LED7_PD4) | LED_OFF(LED8_PD5);
    PORTA |= LED_OFF(LED3_PA1) | LED_OFF(LED4_PA0);
-/* ---------------------------------------------------------------- */
+
-/*                              Main Loop                           */
+   //turn on the leds requested in the byte passed in
-/* ---------------------------------------------------------------- */
+   for ( int i=0; circle != 0, i < 8; i++ )
    {
-  while(1)
+      if ( circle && (1<<i) )
       {
          switch (i)
-//1)    Dim
+         {
-      //1 - All dim nothing happens (resting natural state)
+            case 1
                PORTD |= LED_ON(LED1_PD0);
-      program_all_dim_loop(6000);
+               break;
             case 2
-//2)    Left Turn
+               PORTD |= LED_ON(LED2_PD1);
-      //2 - left turn, all dim, 2 will blink at ½ sec for 10 sec.
+               break;
             case 3
-      while(program_ms_counter < 10000)
+               PORTA |= LED_ON(LED3_PA1);
                break;
-         program_left_turn_loop(program_ms_counter+500);
+            case 4
-         program_all_dim_loop  (program_ms_counter+500);
+               PORTA |= LED_ON(LED4_PA0);
                break;
-      //then dim for 1 sec
+            case 5
-      program_all_dim_loop(11000);
+               PORTD |= LED_ON(LED5_PD2);
                break;
-//3)    Dim (4 sec)
+            case 6
-      //4 - All dim nothing happens (resting natural state)
+               PORTD |= LED_ON(LED6_PD3);
                break;
-      program_all_dim_loop(4000);
+            case 7
                PORTD |= LED_ON(LED7_PD4);
-//4)    Brakes
+               break;
-      //3 – brakes get bright (8 LED’s) for 4 sec then dim for 1sec for 12 seconds
+            case 8
                PORTD |= LED_ON(LED8_PD5);
-      while(program_ms_counter < 12000)
+               break;
             default
-         program_break_loop  (program_ms_counter+4000);
+               //should never hit
-         program_all_dim_loop(program_ms_counter+1000);
+               circle = 0;
                break;
          } //end switch
-//5)    Dim (4 Sec)
+      } // end if
-      //4 - All dim nothing happens (resting natural state)
+   } // end loop
 }
-      program_all_dim_loop(4000);
+
 void program_turn_on_sequence_inner(int speed) {
-//6)    Right Turn
+   int circle_placeholder=0;
-      //5 – right turn, all dim, 2 will blink at ½ sec for 10 sec.
+
    //turn on each led in circle, in sequence
-      while(program_ms_counter < 10000)
+   for(int i=0; i<16, circle_placeholder<=0b11111111; i++)
    {
-         program_right_turn_loop(program_ms_counter+500);
+      circle_placeholder |= 1<<i;
-         program_all_dim_loop   (program_ms_counter+500);
+      program_inner_leds(circle_placeholder);
       delay_us(speed);
-      //then dim for 1 sec.
+
-      program_all_dim_loop(11000);
+
 
-//7)    Dim (4 sec)
+void program_turn_on_sequence_outer(int speed) {
-      //4 - All dim nothing happens (resting natural state)
+   int circle_placeholder=0;
 
-      program_all_dim_loop(4000);
+   //turn on each led in circle, in sequence
    for(int i=0; i<16, circle_placeholder<=0b11111111; i++)
-//8)    Brakes
+
-      //6 – brakes get bright (8 LED’s) for 4 sec then dim for 1sec for 12 seconds
+      circle_placeholder |= 1<<i;
       program_outer_leds(circle_placeholder);
-      while(program_ms_counter < 12000)
+      delay_us(speed);
    }
-         program_break_loop  (program_ms_counter+4000);
+
-         program_all_dim_loop(program_ms_counter+1000);
+
 
 
-//9)    Loop
+
 //               Main                  |
 //--------------------------------------
 int main (void)
 {
 
    /* ---------------------------------------------------------------- */
    /*                            Initialization                        */
    /* ---------------------------------------------------------------- */
 
    //Initialize all ports
    DDRA =  (OUTPUT_LED<<LED4_PA0)  | (OUTPUT_LED<<LED3_PA1);
    DDRB =  (INPUT_SW<<INPUT_PB0)   | (OUTPUT_LED<<LED10_PB1) | (OUTPUT_LED<<LED11_PB2) |
           (OUTPUT_LED<<LED14_PB5) | (OUTPUT_LED<<LED15_PB6) | (OUTPUT_LED<<LED16_PB7);
    DDRD =  (OUTPUT_LED<<LED1_PD0)  | (OUTPUT_LED<<LED2_PD1)  | (OUTPUT_LED<<LED5_PD2) |
           (OUTPUT_LED<<LED6_PD3)  | (OUTPUT_LED<<LED7_PD4)  | (OUTPUT_LED<<LED8_PD5) |
           (OUTPUT_LED<<LED9_PD6);
 
    //clean state
    all_LEDs_OFF();
    reset_ms_us_counters();
 
    //Turn on each led in sequence to ignite, 20ms between animations
    program_turn_on_sequence_inner(20000);
    program_turn_on_sequence_outer(20000);
 
    //dim down after powerup, 6ms
    program_all_dim_loop(46000);
 
    /* ---------------------------------------------------------------- */
    /*                              Main Loop                           */
    /* ---------------------------------------------------------------- */
 
    while(1)
    {
       reset_ms_us_counters();
 
       // do this loop while waiting for button press
       while(!button_is_pressed())
       {
         //minimize delays in here, delays could miss a button press
 
         //Dim (0.4 seconds)
         program_all_dim_loop(400);
 
       }
 
      //button was pressed
      //do stuff
 
    }
 
   while(1);                 // Ending infinite loop (just in case)
 
 }