API tools faq
paste
Advertisement
dlwestab

Car Lights 1.1

dlwestab
Sep 21st, 2012
27
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 13.45 KB | None | 0 0
raw download clone embed print report
  1. /*
  2. Copyright 2012 D Westaby
  3.  
  4. ----------------------------------------------------------------------
  5.    Car Lights for Attiny2313
  6. ----------------------------------------------------------------------
  7. Title:      Car_Lighting.D
  8. Author:     Dustin Westaby
  9. Date Created:   September 8, 2012
  10. Date Modified:   September 21, 2012
  11.  
  12. Compiled with AVR-GCC WinAVR
  13.  
  14. ----------------------------------------------------------------------
  15.     Fuses:
  16. ----------------------------------------------------------------------
  17.  BrownOut Disabled
  18.  CKDIV8
  19.  Int RC Osc 8Mhz + 64ms
  20.  
  21. ----------------------------------------------------------------------
  22.     Inputs:
  23. ----------------------------------------------------------------------
  24.  None
  25.  
  26. ----------------------------------------------------------------------
  27.     Ouputs:
  28. ----------------------------------------------------------------------
  29.  pin  i/o  port    circuit trace       connection
  30. ----------------------------------------------------------------------
  31.   4    1   PA1 =   R_LED1
  32.   5    1   PA0 =   L_LED2
  33.   2    1   PD0 =   R_LED3
  34.   3    1   PD1 =   R_LED4
  35.   6    1   PD2 =   R_LED5
  36.   7    1   PD3 =   R_LED6
  37.  14    1   PB2 =   L_LED7
  38.  17    1   PB5 =   L_LED8
  39.  18    1   PB6 =   L_LED9
  40.  19    1   PB7 =   L_LED10
  41.  
  42. */
  43.  
  44. //--------------------------------------
  45. //          Global Variables           |
  46. //--------------------------------------
  47. // 8 MHz Internal Oscillator DIV8 (used for delay subroutines)
  48. // One CPU Cycle = 1us
  49. #define F_CPU 8000000UL/8
  50.  
  51. #define R_LED1_PA1  (1<<1)
  52. #define L_LED2_PA0  (1<<0)
  53. #define R_LED3_PD0  (1<<0)
  54. #define R_LED4_PD1  (1<<1)
  55. #define R_LED5_PD2  (1<<2)
  56. #define R_LED6_PD3  (1<<3)
  57. #define L_LED7_PB2  (1<<2)
  58. #define L_LED8_PB5  (1<<5)
  59. #define L_LED9_PB6  (1<<6)
  60. #define L_LED10_PB7 (1<<7)
  61.  
  62. //This value is used to count us of delay and convert to ms
  63. //Due to other cpu processing: "1ms of delay" < "1000us of delay"
  64. #define TIME_CONVERSION_VAL (50)
  65.  
  66. int program_ms_counter;
  67. int program_counter_us; //used for tracking time elapsed
  68.  
  69. //--------------------------------------
  70. //              Includes               |
  71. //--------------------------------------
  72. #include <avr/io.h>
  73. #include <util/delay.h>
  74.  
  75. //--------------------------------------
  76. //          Delay Subroutines          |
  77. //--------------------------------------
  78. //These functions are from the delay.h include, the calls to delay functions
  79. //are re-written here to allow for longer waits.
  80. void delay_ms(uint16_t ms) {
  81.         program_ms_counter+=ms;
  82.         while ( ms )
  83.         {
  84.                 _delay_ms(1);
  85.                 ms--;
  86.         }
  87. }
  88. void delay_us(uint16_t us) {
  89.   program_counter_us+=us;
  90.   while ( us )
  91.   {
  92.     _delay_us(1);
  93.     us--;
  94.   }
  95.  
  96.   while(program_counter_us>=TIME_CONVERSION_VAL)
  97.   {
  98.           program_ms_counter++;
  99.           program_counter_us-=TIME_CONVERSION_VAL;
  100.   }
  101. }
  102.  
  103. //--------------------------------------
  104. //          Misc Subroutines          |
  105. //--------------------------------------
  106.  
  107. void reset_ms_us_counters(void) {
  108.         program_ms_counter=0;
  109.         program_counter_us=0;
  110. }
  111.  
  112. void all_LEDs_ON(void) {
  113.         PORTA = 0xFF;
  114.         PORTB = 0xFF;
  115.         PORTD = 0xFF;
  116. }
  117.  
  118. void all_LEDs_OFF(void) {
  119.         PORTA &= ~(R_LED1_PA1 + L_LED2_PA0);
  120.         PORTB &= ~(L_LED10_PB7 + L_LED9_PB6 + L_LED8_PB5 + L_LED7_PB2);
  121.         PORTD &= ~(R_LED6_PD3 + R_LED5_PD2 + R_LED4_PD1 + R_LED3_PD0);
  122. }
  123.  
  124. void program1_off(void) {
  125.         PORTA &= ~(R_LED1_PA1 + L_LED2_PA0);
  126.         PORTB &= ~(L_LED10_PB7 + L_LED9_PB6 + L_LED8_PB5 + L_LED7_PB2);
  127.         PORTD &= ~(R_LED6_PD3 + R_LED5_PD2 + R_LED4_PD1 + R_LED3_PD0);
  128. }
  129.  
  130. void program2_off(void) {
  131.         PORTA &= ~(R_LED1_PA1 + L_LED2_PA0);
  132.         PORTB &= ~(L_LED10_PB7 + L_LED8_PB5);
  133.         PORTD &= ~(R_LED6_PD3 + R_LED5_PD2 + R_LED4_PD1 + R_LED3_PD0);
  134. }
  135.  
  136. void program3_off(void) {
  137.         PORTA &= ~(R_LED1_PA1 + L_LED2_PA0);
  138. }
  139.  
  140. void program4_off (void) {
  141.         PORTA &= ~(R_LED1_PA1 + L_LED2_PA0);
  142.         PORTB &= ~(L_LED10_PB7 + L_LED9_PB6 + L_LED8_PB5 + L_LED7_PB2);
  143.         PORTD &= ~(R_LED6_PD3 + R_LED5_PD2 + R_LED4_PD1 + R_LED3_PD0);
  144. }
  145.  
  146. void program5_off (void) {
  147.         PORTA &= ~(R_LED1_PA1 + L_LED2_PA0);
  148.         PORTB &= ~(L_LED10_PB7 + L_LED9_PB6 + L_LED8_PB5 + L_LED7_PB2);
  149.         PORTD &= ~(R_LED6_PD3 +  R_LED4_PD1);
  150. }
  151.  
  152. void program6_off (void) {
  153.         PORTA &= ~(R_LED1_PA1 + L_LED2_PA0);
  154. }
  155.  
  156.  
  157. //--------------------------------------
  158. //               Main                  |
  159. //--------------------------------------
  160. int main (void)
  161. {
  162.  
  163.   /* ---------------------------------------------------------------- */
  164.   /*                            Initialization                        */
  165.   /* ---------------------------------------------------------------- */
  166.  
  167.   int dim_delay_on = 200; //us
  168.   int dim_delay_off = 4000; //us
  169.  
  170.   //Initialize all ports as outputs
  171.   DDRA =  0b00000011; //A0, A1
  172.   DDRB =  0b11111111;
  173.   DDRD =  0b11111111;
  174.  
  175.   all_LEDs_OFF();
  176.  
  177. /* ---------------------------------------------------------------- */
  178. /*                              Main Loop                           */
  179. /* ---------------------------------------------------------------- */
  180.  
  181.   while(1)
  182.   {
  183.  
  184.         //program 1
  185.         reset_ms_us_counters();
  186.         while(program_ms_counter < 6000)
  187.         {
  188.                 all_LEDs_ON();
  189.                 delay_us(dim_delay_on);
  190.                 all_LEDs_OFF();
  191.                 delay_us(dim_delay_off);
  192.         }
  193.  
  194. //program 2
  195.         reset_ms_us_counters();
  196.         while(program_ms_counter < 500)
  197.         {
  198.                 all_LEDs_ON();
  199.                 delay_us(dim_delay_on);
  200.                 program3_off();
  201.                 delay_us(dim_delay_off);
  202.         }
  203.         while(program_ms_counter < 1000)
  204.         {
  205.                 all_LEDs_ON();
  206.                 delay_us(dim_delay_on);
  207.                 all_LEDs_OFF();
  208.                 delay_us(dim_delay_off);
  209.         }
  210.         while(program_ms_counter < 1500)
  211.         {
  212.                 all_LEDs_ON();
  213.                 delay_us(dim_delay_on);
  214.                 program3_off();
  215.                 delay_us(dim_delay_off);
  216.         }
  217.         while(program_ms_counter < 2000)
  218.         {
  219.                 all_LEDs_ON();
  220.                 delay_us(dim_delay_on);
  221.                 all_LEDs_OFF();
  222.                 delay_us(dim_delay_off);
  223.         }
  224.         while(program_ms_counter < 2500)
  225.         {
  226.                 all_LEDs_ON();
  227.                 delay_us(dim_delay_on);
  228.                 program3_off();
  229.                 delay_us(dim_delay_off);
  230.         }
  231.         while(program_ms_counter < 3000)
  232.         {
  233.                 all_LEDs_ON();
  234.                 delay_us(dim_delay_on);
  235.                 all_LEDs_OFF();
  236.                 delay_us(dim_delay_off);
  237.         }
  238.         while(program_ms_counter < 3500)
  239.         {
  240.                 all_LEDs_ON();
  241.                 delay_us(dim_delay_on);
  242.                 program3_off();
  243.                 delay_us(dim_delay_off);
  244.         }
  245.         while(program_ms_counter < 4000)
  246.         {
  247.                 all_LEDs_ON();
  248.                 delay_us(dim_delay_on);
  249.                 all_LEDs_OFF();
  250.                 delay_us(dim_delay_off);
  251.         }
  252.         while(program_ms_counter < 4500)
  253.         {
  254.                 all_LEDs_ON();
  255.                 delay_us(dim_delay_on);
  256.                 program3_off();
  257.                 delay_us(dim_delay_off);
  258.         }
  259.         while(program_ms_counter < 5000)
  260.         {
  261.                 all_LEDs_ON();
  262.                 delay_us(dim_delay_on);
  263.                 all_LEDs_OFF();
  264.                 delay_us(dim_delay_off);
  265.         }
  266.         while(program_ms_counter < 5500)
  267.         {
  268.                 all_LEDs_ON();
  269.                 delay_us(dim_delay_on);
  270.                 program3_off();
  271.                 delay_us(dim_delay_off);
  272.         }
  273.         while(program_ms_counter < 6000)
  274.         {
  275.                 all_LEDs_ON();
  276.                 delay_us(dim_delay_on);
  277.                 all_LEDs_OFF();
  278.                 delay_us(dim_delay_off);
  279.         }
  280.         while(program_ms_counter < 6500)
  281.         {
  282.                 all_LEDs_ON();
  283.                 delay_us(dim_delay_on);
  284.                 program3_off();
  285.                 delay_us(dim_delay_off);
  286.         }
  287.         while(program_ms_counter < 7000)
  288.         {
  289.                 all_LEDs_ON();
  290.                 delay_us(dim_delay_on);
  291.                 all_LEDs_OFF();
  292.                 delay_us(dim_delay_off);
  293.         }
  294.  
  295.         //program 3
  296.         reset_ms_us_counters();
  297.         while(program_ms_counter < 3000)
  298.         {
  299.                 all_LEDs_ON();
  300.                 delay_us(dim_delay_on);
  301.                 program2_off();
  302.                 delay_us(dim_delay_off);
  303.         }
  304.         while(program_ms_counter < 4000)
  305.         {
  306.                 all_LEDs_ON();
  307.                 delay_us(dim_delay_on);
  308.                 all_LEDs_OFF();
  309.                 delay_us(dim_delay_off);
  310.         }
  311.         while(program_ms_counter < 6500)
  312.         {
  313.                 all_LEDs_ON();
  314.                 delay_us(dim_delay_on);
  315.                 program2_off();
  316.                 delay_us(dim_delay_off);
  317.         }
  318.         while(program_ms_counter < 7000)
  319.         {
  320.                 all_LEDs_ON();
  321.                 delay_us(dim_delay_on);
  322.                 all_LEDs_OFF();
  323.                 delay_us(dim_delay_off);
  324.         }
  325.  
  326. //program 4
  327.         reset_ms_us_counters();
  328.         while(program_ms_counter < 6000)
  329.         {
  330.                 all_LEDs_ON();
  331.                 delay_us(dim_delay_on);
  332.                 all_LEDs_OFF();
  333.                 delay_us(dim_delay_off);
  334.         }
  335.  
  336.  //program 5
  337.         reset_ms_us_counters();
  338.         while(program_ms_counter < 500)
  339.         {
  340.                 all_LEDs_ON();
  341.                 delay_us(dim_delay_on);
  342.                 program4_off();
  343.                 delay_us(dim_delay_off);
  344.         }
  345.         while(program_ms_counter < 1000)
  346.         {
  347.                 all_LEDs_ON();
  348.                 delay_us(dim_delay_on);
  349.                 all_LEDs_OFF();
  350.                 delay_us(dim_delay_off);
  351.         }
  352.         while(program_ms_counter < 1500)
  353.         {
  354.                 all_LEDs_ON();
  355.                 delay_us(dim_delay_on);
  356.                 program4_off();
  357.                 delay_us(dim_delay_off);
  358.         }
  359.         while(program_ms_counter < 2000)
  360.         {
  361.                 all_LEDs_ON();
  362.                 delay_us(dim_delay_on);
  363.                 all_LEDs_OFF();
  364.                 delay_us(dim_delay_off);
  365.         }
  366.         while(program_ms_counter < 2500)
  367.         {
  368.                 all_LEDs_ON();
  369.                 delay_us(dim_delay_on);
  370.                 program4_off();
  371.                 delay_us(dim_delay_off);
  372.         }
  373.         while(program_ms_counter < 3000)
  374.         {
  375.                 all_LEDs_ON();
  376.                 delay_us(dim_delay_on);
  377.                 all_LEDs_OFF();
  378.                 delay_us(dim_delay_off);
  379.         }
  380.         while(program_ms_counter < 3500)
  381.         {
  382.                 all_LEDs_ON();
  383.                 delay_us(dim_delay_on);
  384.                 program4_off();
  385.                 delay_us(dim_delay_off);
  386.         }
  387.         while(program_ms_counter < 4000)
  388.         {
  389.                 all_LEDs_ON();
  390.                 delay_us(dim_delay_on);
  391.                 all_LEDs_OFF();
  392.                 delay_us(dim_delay_off);
  393.         }
  394.         while(program_ms_counter < 4500)
  395.         {
  396.                 all_LEDs_ON();
  397.                 delay_us(dim_delay_on);
  398.                 program4_off();
  399.                 delay_us(dim_delay_off);
  400.         }
  401.         while(program_ms_counter < 5000)
  402.         {
  403.                 all_LEDs_ON();
  404.                 delay_us(dim_delay_on);
  405.                 all_LEDs_OFF();
  406.                 delay_us(dim_delay_off);
  407.         }
  408.         while(program_ms_counter < 5500)
  409.         {
  410.                 all_LEDs_ON();
  411.                 delay_us(dim_delay_on);
  412.                 program4_off();
  413.                 delay_us(dim_delay_off);
  414.         }
  415.         while(program_ms_counter < 6000)
  416.         {
  417.                 all_LEDs_ON();
  418.                 delay_us(dim_delay_on);
  419.                 all_LEDs_OFF();
  420.                 delay_us(dim_delay_off);
  421.         }
  422.         while(program_ms_counter < 6500)
  423.         {
  424.                 all_LEDs_ON();
  425.                 delay_us(dim_delay_on);
  426.                 program4_off();
  427.                 delay_us(dim_delay_off);
  428.         }
  429.         while(program_ms_counter < 7000)
  430.         {
  431.                 all_LEDs_ON();
  432.                 delay_us(dim_delay_on);
  433.                 all_LEDs_OFF();
  434.                 delay_us(dim_delay_off);
  435.         }
  436.  
  437. //program 6
  438.         reset_ms_us_counters();
  439.         while(program_ms_counter < 3000)
  440.         {
  441.                 all_LEDs_ON();
  442.                 delay_us(dim_delay_on);
  443.                 program2_off();
  444.                 delay_us(dim_delay_off);
  445.         }
  446.         while(program_ms_counter < 4000)
  447.         {
  448.                 all_LEDs_ON();
  449.                 delay_us(dim_delay_on);
  450.                 all_LEDs_OFF();
  451.                 delay_us(dim_delay_off);
  452.         }
  453.         while(program_ms_counter < 6500)
  454.         {
  455.                 all_LEDs_ON();
  456.                 delay_us(dim_delay_on);
  457.                 program2_off();
  458.                 delay_us(dim_delay_off);
  459.         }
  460.         while(program_ms_counter < 7000)
  461.         {
  462.                 all_LEDs_ON();
  463.                 delay_us(dim_delay_on);
  464.                 all_LEDs_OFF();
  465.                 delay_us(dim_delay_off);
  466.         }
  467. }
  468.  
  469.   while(1);                 // Ending infinite loop (just in case)
  470.  
  471. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!