API tools faq
paste
Advertisement
vulture2600

Trike Lights

vulture2600
Feb 15th, 2016
128
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 19.54 KB | None | 0 0
raw download clone embed print report
  1. /*
  2. TRIKE LIGHTS for Peacock Groove Cargo Trike. www.facebook.com/peacockgroove/
  3. Code by Steve McCluskey and Karl Stoerzinger
  4. steve.a.mccluskey@gmail.com
  5. kstoerz@gmail.com
  6.  
  7. This sketch flashes 13 LEDs and has 3 digital inputs for mode and L/R turn signals.
  8.  
  9. Revision History:
  10. V1.0 : Prototype release. 02/14/16
  11. V1.1 : Changed led0next/led1next/etc to ledNext[7] array. 02/15/16
  12. V1.2 : Changed led0p/led1p/etc to ledP[7] array. Karl tweaked hazard() to only blink corners and make the sides and center reds stay on. Mode 3 is now
  13. skipped due to lack of dedicated brake lever switch. 02/16/15
  14.  
  15. Modes:
  16. ----------
  17. Switch off     : all lights off.
  18. Switch on      : steady on (default).
  19. Off/on quick 1 : normal amber, normal red.
  20. Off/on quick 2 : normal amber, brake red.
  21. Off/on quick 3 : hazards.
  22. Off/on quick 4 : back to steady on.
  23.  
  24. Turn signals are always active and work with current pattern.
  25.  
  26. Hardware:
  27. Using TIP102/TIP1206 NPN transistors to switch the ground of the 12v LED fixtures.
  28.  - 1k resistor from digitial pin to left leg of TIP102.
  29.  - middle leg of TIP102 to negative wire of LED (white, in this case!).
  30.  - right leg of TIP102 to ground of 12v power source.
  31.  - tie 12v ground to 5v ground!!!
  32.  - +12v to positive wires of all LED fixtures.
  33.  - 5v supplied to power microcontroller via appropriate LM7805 vreg circuit, etc.
  34.  - put a suitable fuse on the 12v wire(s) going out to lights!
  35.  
  36. ARRAY SIZES:
  37. https://arduino.land/FAQ/content/6/29/en/how-to-get-the-size-of-an-array.html  
  38. number of elements in array (kludged because there is no straightforward array length function!)
  39. unsigned int led0el = sizeof( ledAr[0] ) / sizeof( uint16_t );
  40. unsigned int led1el = sizeof( ledAr[1] ) / sizeof( uint16_t );
  41. unsigned int led2el = sizeof( ledAr[2] ) / sizeof( uint16_t );
  42. Not currently used.
  43.  
  44. Some sample patterns by Karl:
  45. {40,40,40,40,40,40,40,40,300,400,0};                                            4 short pulses, 1 long
  46. {100,50,100,50,100,50,50,100,50,100,50,100,0};                                  alternating duty cycle (needs work)
  47. {10,10,20,20,30,30,40,40,50,50,60,60,70,70,80,80,90,90,100,100,0};              ramp down fast to slow (needs work)
  48. {50,50,50,50,50,50,50,50,50,50,50,100,100,50,100,50,100,100,0};                 alternating fast and slow strobes (pretty good)
  49. {50,50,50,50,50,50,50,50,50,550,0}    and   {50,550,50,50,50,50,50,50,50,50,0}  kind of alternating pairs of strobes
  50. {25,100,50,100,75,100,100,100,75,100,50,100,25,100,0}                           constant off time, ramping on time
  51. {50,200,50,150,50,100,50,50,50,100,50,150,50,200,50,250,0}                      constant on time, ramping off time
  52. {370,340,0}                                                                     turn signal
  53. {20,40,20,40,20,200,20,40,20,40,20,200,20,40,20,40,20,500,0}                    three fast strobes and a pause (pretty good)
  54.  
  55. On/off logic:
  56. 0%2 = 0
  57. 1%2 = 1
  58. 2%2 = 0
  59. 3%2 = 1
  60.  
  61. element   0             1             2             3
  62. value     20            30            10            50
  63. meaning   on for 20ms   off for 30    on for 10     off for 50
  64.  
  65. LEDs on trike are arranged as follows:
  66.  
  67.   Y0     Y0
  68. Y1         Y1
  69.  
  70. Y2         Y2
  71.  
  72. Y3         Y3
  73.   R  RRR  R
  74.   0  123  4
  75.  
  76. Output pin layout as follows:
  77. 0  : Serial RX     (NC).
  78. 1  : Serial TX     (NC).
  79. 2  : Amber Left  0 (Front facing).
  80. 3 ~: Amber Left  1 (Side facing).
  81. 4  : Amber Left  2 (Side facing).
  82. 5 ~: Red         0 (Rear facing).
  83. 6 ~: Red         1 (Rear facing).
  84. 7  : Amber Left  3 (Side facing).
  85. 8  : Amber Right 0 (Front facing).
  86. 9 ~: Red         2 (Rear facing).
  87. 10~: Red         3 (Rear facing).
  88. 11~: Red         4 (Rear facing).
  89. 12 : Amber Right 1 (Side facing).
  90. 13 : Amber Right 2 (Side facing).
  91. A5 : Amber Right 3 (Side facing).
  92.  
  93. Inputs:
  94. A0 : NC.
  95. A1 : Ground.
  96. A2 : Mode.
  97. A3 : Left turn.
  98. A4 : Right turn.
  99. */
  100.  
  101. // Pin declarations:
  102. #define amberL0        2
  103. #define amberL1        3
  104. #define amberL2        4
  105. #define amberL3        7
  106.  
  107. #define amberR0        8
  108. #define amberR1        12
  109. #define amberR2        13
  110. #define amberR3        A5
  111.  
  112. #define red0           5
  113. #define red1           6
  114. #define red2           9
  115. #define red3           10
  116. #define red4           11
  117.  
  118. #define inputGnd       A1
  119. #define modeSwitch     A2
  120. #define lturn          A3
  121. #define rturn          A4
  122.  
  123. #define modeSwitchTime 500 // Change to make switching modes easier or harder.
  124.  
  125.  
  126. // Current flash patterns:
  127. uint16_t ledAr[7][11] = {{40, 40, 40, 40, 40, 40, 40, 40, 300, 400, 0},
  128.                          {42, 42, 42, 42, 42, 42, 42, 42, 300, 400, 0},
  129.                          {44, 44, 44, 44, 44, 44, 44, 44, 300, 400, 0},
  130.                          {46, 46, 46, 46, 46, 46, 46, 46, 300, 400, 0},
  131.                          {48, 48, 48, 48, 48, 48, 48, 48, 300, 400, 0},
  132.                          {50, 50, 50, 50, 50, 50, 50, 50, 300, 400, 0},
  133.                          {54, 54, 54, 54, 54, 54, 54, 54, 400, 500, 0}};
  134.  
  135. // Flash pattern array position pointers:
  136. uint8_t  ledP [7]     =  {0, 0, 0, 0, 0, 0, 0};
  137.  
  138. // Turn signal pattern and its position pointer:
  139. uint16_t turn  [3] = {370, 340, 0};
  140. uint8_t  turnP     =  0;
  141.  
  142. // Hazard pattern and its position pointer:
  143. uint16_t hazard[3] = {550, 400, 0};
  144. uint8_t  hazP      =  0;
  145.  
  146. //uint8_t chaseP = 0; // Chase position.
  147.  
  148. byte currentMode  = 1;
  149.  
  150. bool timerReset   = false;
  151. bool modeChanged  = true;
  152. bool modeSwitchOn = false;
  153. bool leftTurnOn   = false;
  154. bool rightTurnOn  = false;
  155.  
  156. unsigned long mls        =  0;                    // Value in which to store millis() for multiple rapid comparisons.
  157. unsigned long ledNext[7] = {0, 0, 0, 0, 0, 0, 0}; // Next millis() value at which LED state will change.
  158. unsigned long turnNext   =  0;                    // Next turn time.
  159. unsigned long hazNext    =  0;                    // Next hazard time.
  160. unsigned long modeTime   =  0;                    // How long mode switch has been off.
  161. //unsigned long chaseNext = 0;
  162.  
  163.  
  164. void setup() {
  165.   pinMode     (amberL0,    OUTPUT);
  166.   pinMode     (amberL1,    OUTPUT);
  167.   pinMode     (amberL2,    OUTPUT);
  168.   pinMode     (amberL3,    OUTPUT);
  169.   pinMode     (amberR0,    OUTPUT);
  170.   pinMode     (amberR1,    OUTPUT);
  171.   pinMode     (amberR2,    OUTPUT);
  172.   pinMode     (amberR3,    OUTPUT);
  173.   pinMode     (red0,       OUTPUT);
  174.   pinMode     (red1,       OUTPUT);
  175.   pinMode     (red2,       OUTPUT);
  176.   pinMode     (red3,       OUTPUT);
  177.   pinMode     (red4,       OUTPUT);
  178.   pinMode     (inputGnd,   OUTPUT);
  179.   digitalWrite(inputGnd,   LOW);          // Using as ground pin for now.
  180.   pinMode     (modeSwitch, INPUT_PULLUP);
  181.   pinMode     (lturn,      INPUT_PULLUP);
  182.   pinMode     (rturn,      INPUT_PULLUP);
  183. } //end setup().
  184.  
  185. void loop() {
  186.   mls = millis();                         // Store millis() in a variable for many rapid comparisons.
  187.  
  188.   // Read inputs:
  189.   if (digitalRead(modeSwitch) == LOW) {   // Input defaults to HIGH. Switch on pulls it low.
  190.     modeSwitchOn = true;
  191.   } // end if.
  192.   else {
  193.     modeSwitchOn = false;
  194.   }
  195.  
  196.   if (digitalRead(lturn)      == LOW) {
  197.     leftTurnOn   = true;
  198.   } // end if.
  199.   else {
  200.     leftTurnOn   = false;
  201.   } // end else.
  202.  
  203.   if (digitalRead(rturn)      == LOW) {
  204.     rightTurnOn  = true;
  205.   } // end if.
  206.  
  207.   else {
  208.     rightTurnOn  = false;
  209.   } // end else.
  210.  
  211.  
  212.   // Mode switch ON, no turn signals:
  213.   if (modeSwitchOn && !leftTurnOn && !rightTurnOn) {
  214.     timerReset = false;                                  // Set to false every time switch turns on.
  215.     if (mls - modeTime > modeSwitchTime) {               // Longer than timeout?
  216.       if (!modeChanged) {                                // Has mode been changed?
  217.         currentMode = 1;                                 // Reset back to 1.
  218.         modeChanged = true;                              // Mode has been changed.
  219.       } // end if.
  220.     } // end if.
  221.  
  222.     else {                                               // Shorter than timeout.
  223.       if (!modeChanged) {                                // Has mode been changed?
  224.         currentMode ++;                                  // Next mode.
  225.         if (currentMode > 4) {                           // Limit on number of modes.
  226.           currentMode = 1;                               // Reset back to 1.
  227.         } // end if.
  228.         modeChanged = true;                              // Mode has been changed.
  229.       } // end if.
  230.     } // end else.
  231.    
  232.     switch (currentMode) {                               // Displays pattern.
  233.       case 1:
  234.         steadyOn();
  235.       break; // end case 1.
  236.      
  237.       case 2:
  238.         normalAmber();
  239.         normalRed();
  240.       break; // end case 2.
  241.  
  242.       case 3:
  243.         currentMode = 4;                                 // Skip past brake light mode for now due to lack of dedicated hardware. -Karl
  244.         //normalAmber();
  245.         //brakeRed();
  246.       break; // end case 3.
  247.      
  248.       case 4:
  249.         hazards();
  250.       break; // end case 4.
  251.  
  252.       default:
  253.       break; // end case default.
  254.     } // end switch.    
  255.   } // end if switch ON.
  256.  
  257.   // Mode switch off, no turn signals:
  258.   else if (!modeSwitchOn && !leftTurnOn && !rightTurnOn) {
  259.     allOff();
  260.     modeChanged = false;
  261.     if (!timerReset) { // Only resets timer once per switch off.
  262.       modeTime = mls;
  263.       timerReset = true;
  264.     } // end if.
  265.   } // end else.
  266.  
  267.   // Mode switch off, left turn ON:
  268.   else if (leftTurnOn && !modeSwitchOn && !rightTurnOn) {
  269.     leftTurn();
  270.   } // end if.
  271.  
  272.   // Mode switch off, right turn ON:
  273.   else if (rightTurnOn && !modeSwitchOn && !leftTurnOn) {
  274.     rightTurn();
  275.   }
  276.  
  277.   // Mode switch ON, left turn ON:
  278.   else if (modeSwitchOn && leftTurnOn && !rightTurnOn) {
  279.     leftTurn();
  280.   } // end else if.
  281.  
  282.   // Mode switch ON, right turn ON:
  283.   else if (modeSwitchOn && rightTurnOn && !leftTurnOn) {
  284.     rightTurn();
  285.   } // end else if.
  286.  
  287.   delay(2);
  288. } // end loop().
  289.  
  290. void normalAmber() {
  291.   // Fronts L/R:
  292.   if (mls >= ledNext[0]) {                        // Time to do something?
  293.     if (ledAr[0][ledP[0]] == 0) {                 // Reached null value of array? Return to beginning.
  294.       ledP[0] = 0;
  295.     } // end if.
  296.     digitalWrite(amberL0, ((ledP[0] + 1) % 2));   // %2 is modulus of 2. +1 inverts the result so first element (0) creates 1 for on.
  297.     digitalWrite(amberR0, ((ledP[0] + 1) % 2));
  298.     ledNext[0] = mls + ledAr[0][ledP[0]];         // Next time to do something.
  299.     ledP[0] ++;                                   // Increment pointer.
  300.   } // end if.
  301.  
  302.   // Front side L/R:
  303.   if (mls >= ledNext[1]) {
  304.     if (ledAr[1][ledP[1]] == 0) {
  305.       ledP[1] = 0;
  306.     } // end if.
  307.     digitalWrite(amberL1, ((ledP[1] + 1) % 2));  
  308.     digitalWrite(amberR1, ((ledP[1] + 1) % 2));
  309.     ledNext[1] = mls + ledAr[1][ledP[1]];
  310.     ledP[1] ++;
  311.   } // end if.
  312.  
  313.   // Mid side L/R:
  314.   if (mls >= ledNext[2]) {
  315.     if (ledAr[2][ledP[2]] == 0) {
  316.       ledP[2] = 0;
  317.     } // end if.
  318.     digitalWrite(amberL2, ((ledP[2] + 1) % 2));
  319.     digitalWrite(amberR2, ((ledP[2] + 1) % 2));
  320.     ledNext[2] = mls + ledAr[2][ledP[2]];
  321.     ledP[2] ++;
  322.   } // end if.
  323.  
  324.   // Rear side L/R.
  325.   if (mls >= ledNext[3]) {
  326.     if (ledAr[3][ledP[3]] == 0) {
  327.       ledP[3] = 0;
  328.     } // end if.
  329.     digitalWrite(amberL3, ((ledP[3] + 1) % 2));
  330.     digitalWrite(amberR3, ((ledP[3] + 1) % 2));
  331.     ledNext[3] = mls + ledAr[3][ledP[3]];
  332.     ledP[3] ++;
  333.   } // end if.
  334. } //end normalAmber().
  335.  
  336. void normalRed() {
  337.   // Outer reds:  
  338.   if (mls >= ledNext[4]) {
  339.     if (ledAr[4][ledP[4]] == 0) {
  340.       ledP[4] = 0;
  341.     } // end if.
  342.     digitalWrite(red0, ((ledP[4] + 1) % 2));
  343.     digitalWrite(red4, ((ledP[4] + 1) % 2));
  344.     ledNext[4] = mls + ledAr[4][ledP[4]];
  345.     ledP[4] ++;
  346.   } // end if.
  347.  
  348.   // Center red:
  349.   if (mls >= ledNext[5]) {
  350.     if (ledAr[5][ledP[5]] == 0) {
  351.       ledP[5] = 0;
  352.     } // end if.
  353.     digitalWrite(red2, ((ledP[5] + 1) % 2));
  354.     ledNext[5] = mls + ledAr[5][ledP[5]];
  355.     ledP[5] ++;
  356.   } // end if.
  357.  
  358.   // Mid reds:
  359.   if (mls >= ledNext[6]) {
  360.     if (ledAr[6][ledP[6]] == 0) {
  361.       ledP[6] = 0;
  362.     } // end if.
  363.     digitalWrite(red3, ((ledP[6] + 1) % 2));
  364.     digitalWrite(red1, ((ledP[6] + 1) % 2));
  365.     ledNext[6] = mls + ledAr[6][ledP[6]];
  366.     ledP[6] ++;
  367.   } // end if.
  368. } // end normalRed().
  369.  
  370. void brakeRed() {
  371.   analogWrite(red0, 100);
  372.   analogWrite(red1, 150);
  373.   analogWrite(red2, 255);
  374.   analogWrite(red3, 150);
  375.   analogWrite(red4, 100);
  376. } //end brakeRed();
  377.  
  378. void leftTurn() {
  379.   if (modeSwitchOn) {
  380.     switch (currentMode) {
  381.       case 1:
  382.      
  383.       break; // end case 1.
  384.      
  385.       case 2 ... 3:                                  // Only do this if in normalAmber() and switch is on.
  386.         if (mls >= ledNext[0]) {
  387.           if (ledAr[0][ledP[0]] == 0) {
  388.             ledP[0] = 0;
  389.           } // end if.
  390.           digitalWrite(amberR0, ((ledP[0] + 1) % 2));
  391.           ledNext[0] = mls + ledAr[0][ledP[0]];
  392.           ledP[0] ++;
  393.         } // end if.
  394.      
  395.         if (mls >= ledNext[1]) {
  396.           if (ledAr[1][ledP[1]] == 0) {
  397.             ledP[1] = 0;
  398.           } // end if.
  399.           digitalWrite(amberR1, ((ledP[1] + 1) % 2));
  400.           ledNext[1] = mls + ledAr[1][ledP[1]];
  401.           ledP[1] ++;
  402.         } // end if.
  403.        
  404.         if (mls >= ledNext[2]) {
  405.           if (ledAr[2][ledP[2]] == 0) {
  406.             ledP[2] = 0;
  407.           } // end if.
  408.           digitalWrite(amberR2, ((ledP[2] + 1) % 2));  
  409.           ledNext[2] = mls + ledAr[2][ledP[2]];
  410.           ledP[2] ++;
  411.         } // end if.
  412.        
  413.         if (mls >= ledNext[3]) {
  414.           if (ledAr[3][ledP[3]] == 0) {
  415.             ledP[3] = 0;
  416.           } // end if.
  417.           digitalWrite(amberR3, ((ledP[3] + 1) % 2));
  418.           ledNext[3] = mls + ledAr[3][ledP[3]];
  419.           ledP[3] ++;
  420.         } // end if.
  421.       break; // end case 2 or 3.
  422.      
  423.       case 4:                                           // If in hazard mode, turn off other lights.
  424.         digitalWrite(amberR0, LOW);
  425.         digitalWrite(amberR1, LOW);
  426.         digitalWrite(amberR2, LOW);
  427.         digitalWrite(amberR3, LOW);
  428.         digitalWrite(red4,    LOW);
  429.         digitalWrite(red3,    LOW);
  430.         digitalWrite(red2,    LOW);
  431.       break; // end case 4.
  432.      
  433.       default:
  434.      
  435.       break; // end case default.
  436.     } // end switch  
  437.   } // end if modeSwitchOn.
  438.  
  439.   else {                                                 // Turn off other lights if mode switch off.
  440.     digitalWrite(amberR0, LOW);
  441.     digitalWrite(amberR1, LOW);
  442.     digitalWrite(amberR2, LOW);
  443.     digitalWrite(amberR3, LOW);
  444.     digitalWrite(red2,    LOW);
  445.     digitalWrite(red3,    LOW);
  446.     digitalWrite(red4,    LOW);
  447.   } // end else.
  448.  
  449.   // Calls turn signal array pattern:
  450.   if (mls >= turnNext) {                      
  451.     if (turn[turnP] == 0) {
  452.       turnP = 0;
  453.     } // end if.
  454.     digitalWrite(amberL0, ((turnP + 1) % 2));
  455.     digitalWrite(amberL1, ((turnP + 1) % 2));
  456.     digitalWrite(amberL2, ((turnP + 1) % 2));
  457.     digitalWrite(amberL3, ((turnP + 1) % 2));
  458.     digitalWrite(red0,    ((turnP + 1) % 2));
  459.     digitalWrite(red1,    ((turnP + 1) % 2));
  460.    
  461.     if (modeSwitchOn && currentMode != 4) {              // Ignore hazard mode.
  462.       analogWrite (red2,    128);
  463.       analogWrite (red3,    40);
  464.       analogWrite (red4,    10);
  465.     } // end if.
  466.     else {
  467.       digitalWrite(red2,    LOW);
  468.       digitalWrite(red3,    LOW);
  469.       digitalWrite(red4,    LOW);
  470.     } // end else.
  471.    
  472.     turnNext = mls + turn[turnP];
  473.     turnP ++;
  474.   } // end if.
  475. } // end leftTurn().
  476.  
  477. void rightTurn() {
  478.   if (modeSwitchOn) {
  479.     switch (currentMode) {
  480.       case 1:
  481.      
  482.       break; // end case 1.
  483.      
  484.       case 2 ... 3:
  485.         if (mls >= ledNext[0]) {
  486.           if (ledAr[0][ledP[0]] == 0) {
  487.             ledP[0] = 0;
  488.           } // end if.
  489.           digitalWrite(amberL0, ((ledP[0] + 1) % 2));  
  490.           ledNext[0] = mls + ledAr[0][ledP[0]];
  491.           ledP[0] ++;
  492.         } // end if.
  493.      
  494.         if (mls >= ledNext[1]) {
  495.           if (ledAr[1][ledP[1]] == 0) {
  496.             ledP[1] = 0;
  497.           } // end if.
  498.           digitalWrite(amberL1, ((ledP[1] + 1) % 2));
  499.           ledNext[1] = mls + ledAr[1][ledP[1]];  
  500.           ledP[1] ++;
  501.         } // end if.
  502.        
  503.         if (mls >= ledNext[2]) {
  504.           if (ledAr[2][ledP[2]] == 0) {
  505.             ledP[2] = 0;
  506.           } // end if.
  507.           digitalWrite(amberL2, ((ledP[2] + 1) % 2));  
  508.           ledNext[2] = mls + ledAr[2][ledP[2]];
  509.           ledP[2] ++;
  510.         } // end if.
  511.        
  512.         if (mls >= ledNext[3]) {
  513.           if (ledAr[3][ledP[3]] == 0) {
  514.             ledP[3] = 0;
  515.           } // end if.
  516.           digitalWrite(amberL3, ((ledP[3] + 1) % 2));  
  517.           ledNext[3] = mls + ledAr[3][ledP[3]];
  518.           ledP[3] ++;
  519.         } // end if.
  520.       break; // end case 2 or 3.
  521.        
  522.       case 4:
  523.         digitalWrite(amberL0, LOW);
  524.         digitalWrite(amberL1, LOW);
  525.         digitalWrite(amberL2, LOW);
  526.         digitalWrite(amberL3, LOW);
  527.         digitalWrite(red0,    LOW);
  528.         digitalWrite(red1,    LOW);
  529.         digitalWrite(red2,    LOW);
  530.       break; // end case 4.
  531.      
  532.       default:
  533.      
  534.       break; // end case default.
  535.     } // end switch.
  536.   } // end if modeSwitchOn.
  537.  
  538.   else {
  539.     digitalWrite(amberL0, LOW);
  540.     digitalWrite(amberL1, LOW);
  541.     digitalWrite(amberL2, LOW);
  542.     digitalWrite(amberL3, LOW);
  543.     digitalWrite(red2,    LOW);
  544.     digitalWrite(red1,    LOW);
  545.     digitalWrite(red0,    LOW);
  546.   } // end else.
  547.  
  548.   if (mls >= turnNext) {
  549.     if (turn[turnP] == 0) {
  550.       turnP = 0;
  551.     } // end if.
  552.     digitalWrite(amberR0, ((turnP + 1) % 2));
  553.     digitalWrite(amberR1, ((turnP + 1) % 2));
  554.     digitalWrite(amberR2, ((turnP + 1) % 2));
  555.     digitalWrite(amberR3, ((turnP + 1) % 2));
  556.     digitalWrite(red3,    ((turnP + 1) % 2));
  557.     digitalWrite(red4,    ((turnP + 1) % 2));
  558.    
  559.     if (modeSwitchOn && currentMode != 4) {
  560.       analogWrite (red2,    128);
  561.       analogWrite (red1,    40);
  562.       analogWrite (red0,    10);
  563.     } // end if.
  564.     else {
  565.       digitalWrite(red0,    LOW);
  566.       digitalWrite(red1,    LOW);
  567.       digitalWrite(red2,    LOW);
  568.     } // end else.
  569.     turnNext = mls + turn[turnP];
  570.     turnP ++;
  571.   } // end if.
  572. } // end rightTurn().
  573.  
  574. void steadyOn() {
  575.   digitalWrite(amberL0, HIGH);
  576.   digitalWrite(amberL1, HIGH);
  577.   digitalWrite(amberL2, HIGH);
  578.   digitalWrite(amberL3, HIGH);
  579.   digitalWrite(amberR0, HIGH);
  580.   digitalWrite(amberR1, HIGH);
  581.   digitalWrite(amberR2, HIGH);
  582.   digitalWrite(amberR3, HIGH);
  583.   analogWrite (red0,    40);
  584.   analogWrite (red1,    40);
  585.   analogWrite (red2,    40);
  586.   analogWrite (red3,    40);
  587.   analogWrite (red4,    40);
  588. } // end steadyOn().
  589.  
  590. void allOff() { // All lights off.
  591.   for (uint8_t x = 2; x < 14; x ++) {
  592.     digitalWrite(x, LOW);
  593.   } // end for.
  594.   digitalWrite(A5, LOW);
  595. } // end allOff().
  596.  
  597. void hazards(){
  598.   if (mls >= hazNext) {
  599.     if (hazard[hazP] == 0) {
  600.       hazP = 0;
  601.     } // end if.
  602.     uint8_t value = ((hazP + 1) % 2); // Only do calculation once instead of each digitalWrite.
  603.     digitalWrite(amberL0, value);     // Tweak hazards to only flash the corners of the vehicle. -Karl
  604.     digitalWrite(amberL1, value);
  605.     digitalWrite(amberL2, 1);
  606.     digitalWrite(amberL3, value);
  607.     digitalWrite(amberR0, value);
  608.     digitalWrite(amberR1, value);
  609.     digitalWrite(amberR2, 1);
  610.     digitalWrite(amberR3, value);
  611.     digitalWrite(red0,    value);
  612.     digitalWrite(red1,    1);
  613.     digitalWrite(red2,    1);
  614.     digitalWrite(red3,    1);
  615.     digitalWrite(red4,    value);
  616.     hazNext = mls + hazard[hazP];
  617.     hazP ++;
  618.   } // end if.
  619. } // end hazards().
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!