API tools faq
paste
Advertisement
skizziks_53

photobooth_pirate_v1

skizziks_53
Jan 30th, 2018
147
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 16.27 KB | None | 0 0
raw download clone embed print report
  1. /*
  2.    Photobooth pirate LED controller
  3.    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  4.    This sketch uses the Adafruit Neopixel library.
  5.  
  6.    The test was run on a Arduino Nano clone, using pin 3 as the WS2812 control LED.
  7.  
  8.    Note: I only used a short chain of eight WS2812 LEDs for this code, so that is all that it will operate.
  9.    You need to edit it for longer chains of LEDs.
  10.  
  11.    ----------------------------
  12.    PATTERNS NEEDED:
  13.    The 1st letter I assume starts and stops the LEDS. When I run the command in the software for "stop LED", it just sends one message: #0=101 [e]
  14.   The 2nd letter represents the speed. s=slow, m=medium, q=fast
  15.   The number [8] represents a color choice: 1=white, 2=red, 3=green, 4=blue, 5=purple, 6=yellow, 7=cyan, 8=orange
  16.   The final letter represents the pattern. z=spinning wheel, x=right fill, c=left fill, v=right ball, b=left ball
  17.  
  18.   The remaining problem is that the lights do not shut off when a single 'e' is entered.
  19.  
  20. */
  21.  
  22. #include <Adafruit_NeoPixel.h>
  23. #ifdef __AVR__
  24. #include <avr/power.h>
  25. #endif
  26.  
  27. #define PIN            3
  28. #define NUMPIXELS      8
  29.  
  30. Adafruit_NeoPixel pixels = Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);
  31.  
  32. char messageLetters[4];
  33. int messageCounter = 0;
  34. int serialMessage_timeOut = 500; // This is the milliseconds that a control message must complete in.
  35. // I just guessed at this value, 9600 baud is *about* 960 characters per second...
  36. unsigned long serialMessage_beginTime = 0;
  37. unsigned long serialMessage_currentTime = 0;
  38. bool messageIncoming = false;
  39. bool displayAlreadyCalled = false;
  40. bool charOutOfRange = false; // This is a value to indicate if a character was not within range (if it was not one of the accepted values)
  41.  
  42. int LEDs_off_on = 0; // zero means "all off" and one means show some pattern
  43. int LEDs_speed = 0; // 0 = slow, 1 = medium and 2 = fast
  44. int LEDs_color = 0;
  45. int LEDs_color_red = 0; // 1=white, 2=red, 3=green, 4=blue, 5=purple, 6=yellow, 7=cyan, 8=orange
  46. int LEDs_color_green = 0;
  47. int LEDs_color_blue = 0;
  48. int LEDs_pattern = 0; // the pattern to use:  z=spinning wheel, x=right fill, c=left fill, v=right ball, b=left ball
  49. // the numerical version is 0=spinning wheel, 1=right fill, 2=left fill, 3=right ball, 4=left ball
  50.  
  51. int led_pattern_control_1 = 0; // This is a variable used to generate the different patterns.
  52. // The different patterns use it different ways.
  53.  
  54. int LED_change_speed = 0; // This is the speed that the LED display changes at. One of the three values below gets copied into here.
  55. int LED_change_speed_slow = 3000;
  56. int LED_change_speed_medium = 700;
  57. int LED_change_speed_fast = 400;
  58. unsigned long LED_change_beginTime = 0;
  59. unsigned long LED_change_currentTime = 0;
  60.  
  61. // function prototypes
  62. void beginMessageTimer();
  63. void resetMessage();
  64. void displayLedMode();
  65. void turnAllLedsOff();
  66. void performMessage();
  67. void check_input_letter(char);
  68.  
  69.  
  70. bool returnMessage = true; // test variable
  71. void echoMessage(); // This is a function to return the sent message
  72.  
  73. void echoMessage() {
  74.   Serial.print(messageLetters[0]);
  75.   Serial.print(messageLetters[1]);
  76.   Serial.print(messageLetters[2]);
  77.   Serial.println(messageLetters[3]);
  78. }
  79.  
  80. void setup() {
  81.   Serial.begin(9600);
  82.  
  83.   for (int x = 0; x < 4; x++) {
  84.     messageLetters[x] = 0; // init the message array to nothing
  85.   }
  86.  
  87.   pixels.begin(); // This initializes the NeoPixel library.
  88.  
  89.   turnAllLedsOff();
  90. }
  91.  
  92.  
  93. void loop() {
  94.  
  95.   // This section gets characters off the serial connection, if any are there to get.
  96.   if (Serial.available()) {
  97.     while (Serial.available() > 0) {
  98.       if (messageCounter < 4) {
  99.         messageLetters[messageCounter] = Serial.read();
  100.         check_input_letter(messageLetters[messageCounter]);
  101.         if (charOutOfRange == false) {
  102.           messageCounter++;
  103.           if (messageIncoming == false) {
  104.             messageIncoming = true;
  105.             beginMessageTimer();
  106.           }
  107.           if (messageCounter > 3) {
  108.             Serial.println("performMessage(1) being called");
  109.             performMessage();
  110.             displayAlreadyCalled = true;
  111.             messageIncoming = false;
  112.             resetMessage();
  113.           }
  114.         }
  115.       }
  116.       else {
  117.         // reset the message if more than four characters are sent
  118.         resetMessage();
  119.       }
  120.     }
  121.   }
  122.  
  123.   /*
  124.     if (messageCounter > 3) {
  125.       Serial.println("performMessage(1) being called");
  126.       performMessage();
  127.       displayAlreadyCalled = true;
  128.       messageIncoming = false;
  129.       resetMessage();
  130.     }
  131.   */
  132.  
  133.   if (messageIncoming == true) { // This section resets a partial message, if it takes too long to complete.
  134.     if (displayAlreadyCalled == false) {
  135.       serialMessage_currentTime = millis();
  136.       if (serialMessage_currentTime > serialMessage_beginTime) {
  137.         if (serialMessage_currentTime > (serialMessage_beginTime + serialMessage_timeOut)) {
  138.           //Serial.println("does this ever work?");
  139.           if (messageCounter == 1) {
  140.             if (messageLetters[0] == 'e') {
  141.               Serial.println("single-e being called");
  142.               //performMessage();
  143.               messageIncoming = false;
  144.               displayAlreadyCalled = true;
  145.               LEDs_off_on == 0;
  146.               turnAllLedsOff();
  147.               resetMessage();
  148.             }
  149.  
  150.           }
  151.  
  152.         }
  153.       }
  154.       else {
  155.         serialMessage_beginTime = millis(); // millis() rollover condition
  156.       }
  157.     }
  158.   }
  159.  
  160.  
  161.  
  162.   // This section changes the LEDs, if they are set to light up at all.
  163.   if (LEDs_off_on == 1) {
  164.     LED_change_currentTime = millis();
  165.     if (LED_change_currentTime > LED_change_beginTime) {
  166.       if (LED_change_currentTime > (LED_change_beginTime + LED_change_speed)) {
  167.         //Serial.println("led caller #1");
  168.         displayLedMode();
  169.         //FastLED.show();
  170.         LED_change_beginTime = millis(); // reset the previous change time to now.
  171.       }
  172.     }
  173.     else {
  174.       LED_change_beginTime = millis(); // millis() rollover condition
  175.     }
  176.   }
  177.  
  178.  
  179. } // end of main loop
  180.  
  181. void beginMessageTimer() {
  182.   serialMessage_beginTime = millis();
  183. }
  184.  
  185. void resetMessage() {
  186.   if (returnMessage == true) {
  187.     echoMessage();
  188.   }
  189.   //for (int x = 0; x < 4; x++) {
  190.   //  messageLetters[x] = 0;
  191.   //}
  192.   messageCounter = 0;
  193.   messageIncoming = false;
  194.   displayAlreadyCalled = false;
  195. }
  196.  
  197.  
  198. void displayLedMode() {
  199.   // Note: I just wrote five different LED patterns here. I didn't try to duplicate the exact photobooth patterns.
  200.  
  201.   Serial.print("displayLedMode() pattern = ");
  202.   Serial.println(LEDs_pattern);
  203.   //Serial.print("speed = ");
  204.   //Serial.println(LED_change_speed);
  205.  
  206.   switch (LEDs_pattern) {
  207.     case 0:
  208.       // This pattern blinks every other light off and on, in two sets.
  209.       if (led_pattern_control_1 == 0) {
  210.         for (int x = 0; x < NUMPIXELS; x = x + 2) {
  211.           pixels.setPixelColor(x, pixels.Color(LEDs_color_red, LEDs_color_green, LEDs_color_blue));
  212.           //Serial.println("pattern call = 0");
  213.         }
  214.         for (int y = 1; y < NUMPIXELS; y = y + 2) {
  215.           pixels.setPixelColor(y, pixels.Color(0, 0, 0));
  216.         }
  217.         led_pattern_control_1 = 1;
  218.         pixels.show();
  219.         //Serial.println("pattern call = 0");
  220.       }
  221.  
  222.       else {
  223.         for (int x = 0; x < NUMPIXELS; x = x + 2) {
  224.           pixels.setPixelColor(x, pixels.Color(0, 0, 0));
  225.         }
  226.         for (int y = 1; y < NUMPIXELS; y = y + 2) {
  227.           pixels.setPixelColor(y, pixels.Color(LEDs_color_red, LEDs_color_green, LEDs_color_blue));
  228.         }
  229.         led_pattern_control_1 = 0;
  230.         pixels.show();
  231.       }
  232.  
  233.       break;
  234.     case 1:
  235.       // This pattern chases one LED in one direction.
  236.       for (int x = 0; x < NUMPIXELS; x++) {
  237.         pixels.setPixelColor(x, pixels.Color(0, 0, 0));
  238.         if (x == led_pattern_control_1) {
  239.           pixels.setPixelColor(x, pixels.Color(LEDs_color_red, LEDs_color_green, LEDs_color_blue));
  240.         }
  241.       }
  242.       led_pattern_control_1++;
  243.       if (led_pattern_control_1 == NUMPIXELS) {
  244.         led_pattern_control_1 = 0;
  245.       }
  246.       pixels.show();
  247.       break;
  248.     case 2:
  249.       // This pattern chases one LED in the opposite direction of pattern #1.
  250.       for (int x = 0; x < NUMPIXELS; x++) {
  251.         pixels.setPixelColor(x, pixels.Color(0, 0, 0));
  252.         if (x == led_pattern_control_1) {
  253.           pixels.setPixelColor(x, pixels.Color(LEDs_color_red, LEDs_color_green, LEDs_color_blue));
  254.         }
  255.       }
  256.       led_pattern_control_1--; // <--------- to reverse the direction, only 1 line is changed compared to pattern #1
  257.       if (led_pattern_control_1 == -1) {
  258.         led_pattern_control_1 = (NUMPIXELS - 1);
  259.       }
  260.       //FastLED.show();
  261.       pixels.show();
  262.       break;
  263.     case 3:
  264.       // This pattern fills the LEDs in one direction.
  265.       for (int x = 0; x < NUMPIXELS; x++) {
  266.         if (x <= led_pattern_control_1) {
  267.           pixels.setPixelColor(x, pixels.Color(LEDs_color_red, LEDs_color_green, LEDs_color_blue));
  268.         }
  269.         else {
  270.           pixels.setPixelColor(x, pixels.Color(0, 0, 0));
  271.         }
  272.       }
  273.       led_pattern_control_1++;
  274.       if (led_pattern_control_1 == NUMPIXELS) {
  275.         led_pattern_control_1 = 0;
  276.       }
  277.       pixels.show();
  278.       break;
  279.     case 4:
  280.       // This pattern fills the LEDs in the opposite direction of pattern #3.
  281.       for (int x = 0; x < NUMPIXELS; x++) {
  282.         if (x >= led_pattern_control_1) {
  283.           pixels.setPixelColor(x, pixels.Color(LEDs_color_red, LEDs_color_green, LEDs_color_blue));
  284.         }
  285.         else {
  286.           pixels.setPixelColor(x, pixels.Color(0, 0, 0));
  287.         }
  288.       }
  289.       led_pattern_control_1--;
  290.       if (led_pattern_control_1 == -1) {
  291.         led_pattern_control_1 = (NUMPIXELS - 1);
  292.       }
  293.       pixels.show();
  294.       break;
  295.     default:
  296.       Serial.println("no led pattern!");
  297.       break;
  298.   }
  299. }
  300.  
  301. void turnAllLedsOff() {
  302.   for (int x = 0; x < NUMPIXELS; x++) {
  303.     pixels.setPixelColor(x, pixels.Color(0, 0, 0));
  304.   }
  305.   pixels.show();
  306. }
  307.  
  308.  
  309.  
  310. void performMessage() {
  311.  
  312.   //Serial.println("performMessage() being called");
  313.  
  314.   if (messageCounter == 1) {
  315.     if (messageLetters[0] == 'e') {
  316.       // this turns all the LEDs off
  317.       Serial.println("performMessage() turning LEDs off");
  318.       LEDs_off_on = 0;
  319.       turnAllLedsOff();
  320.  
  321.     }
  322.     else {
  323.       // any message that does not begin with 'e' gets tossed out
  324.       resetMessage();
  325.     }
  326.   }
  327.   else if (messageCounter == 4) {
  328.     LEDs_off_on = 1;
  329.     // The 2nd letter represents the speed. s=slow, m=medium, q=fast
  330.     if (messageLetters[1] == 's') {
  331.       LED_change_speed = LED_change_speed_slow;
  332.     }
  333.     else if (messageLetters[1] == 'm') {
  334.       LED_change_speed = LED_change_speed_medium;
  335.     }
  336.     else if (messageLetters[1] == 'q') {
  337.       LED_change_speed = LED_change_speed_fast;
  338.     }
  339.     else {
  340.       // If the [speed] character is not correct, set the charOutOfRange indicator.
  341.       charOutOfRange = true;
  342.     }
  343.  
  344.  
  345.     //Serial.print("set speed = ");
  346.     //Serial.println(LED_change_speed);
  347.  
  348.  
  349.     //Serial.print("color char = ");
  350.     //Serial.println(messageLetters[2]);
  351.  
  352.     //Serial.print("range check #1 = ");
  353.     //Serial.println(charOutOfRange);
  354.  
  355.     if (charOutOfRange == false) {
  356.       // The number [8] represents a color choice: 1=white, 2=red, 3=green, 4=blue, 5=purple, 6=yellow, 7=cyan, 8=orange
  357.       Serial.println("inside condition?");
  358.       //LEDs_color = messageLetters[2] - 48; // This gets the single-digit-character's numerical value.
  359.  
  360.       //Serial.println("conditionals?...");
  361.       Serial.print("LEDs_color = ");
  362.       Serial.println(messageLetters[2]);
  363.  
  364.  
  365.  
  366.       if (messageLetters[2] == '1') {
  367.         // color = white
  368.         LEDs_color_red = 255;
  369.         LEDs_color_green = 255;
  370.         LEDs_color_blue = 255;
  371.       }
  372.       else if (messageLetters[2] == '2') {
  373.         // color = red
  374.         LEDs_color_red = 255;
  375.         LEDs_color_green = 0;
  376.         LEDs_color_blue = 0;
  377.       }
  378.       else if (messageLetters[2] == '3') {
  379.         // color = green
  380.         LEDs_color_red = 0;
  381.         LEDs_color_green = 255;
  382.         LEDs_color_blue = 0;
  383.       }
  384.       else if (messageLetters[2] == '4') {
  385.         // color = blue
  386.         LEDs_color_red = 0;
  387.         LEDs_color_green = 0;
  388.         LEDs_color_blue = 255;
  389.       }
  390.       else if (messageLetters[2] == '5') {
  391.         // color = purple
  392.         LEDs_color_red = 128;
  393.         LEDs_color_green = 0;
  394.         LEDs_color_blue = 128;
  395.       }
  396.       else if (messageLetters[2] == '6') {
  397.         // color = yellow
  398.         LEDs_color_red = 255;
  399.         LEDs_color_green = 255;
  400.         LEDs_color_blue = 0;
  401.       }
  402.       else if (messageLetters[2] == '7') {
  403.         // color = cyan
  404.         LEDs_color_red = 0;
  405.         LEDs_color_green = 255;
  406.         LEDs_color_blue = 255;
  407.       }
  408.       else if (messageLetters[2] == '8') {
  409.         // color = orange
  410.         LEDs_color_red = 255;
  411.         LEDs_color_green = 165;
  412.         LEDs_color_blue = 0;
  413.       }
  414.       else {
  415.         // If the [color] character is not correct, set the charOutOfRange indicator.
  416.         charOutOfRange = true;
  417.         Serial.print("performMessage() color char = ");
  418.         Serial.println(messageLetters[2]);
  419.       }
  420.  
  421.       /*
  422.             Serial.print("red = ");
  423.             Serial.println(LEDs_color_red);
  424.             Serial.print("green = ");
  425.             Serial.println(LEDs_color_green);
  426.             Serial.print("blue = ");
  427.             Serial.println(LEDs_color_blue);
  428.       */
  429.  
  430.       if (charOutOfRange == false) {
  431.         //int LEDs_pattern = 0; // the pattern to use:  z=spinning wheel, x=right fill, c=left fill, v=right ball, b=left ball
  432.         // the numerical version is 0=spinning wheel, 1=right fill, 2=left fill, 3=right ball, 4=left ball
  433.  
  434.         if (messageLetters[3] == 'z') {
  435.           LEDs_pattern = 0;
  436.         }
  437.         else if (messageLetters[3] == 'x') {
  438.           LEDs_pattern = 1;
  439.         }
  440.         else if (messageLetters[3] == 'c') {
  441.           LEDs_pattern = 2;
  442.         }
  443.         else if (messageLetters[3] == 'v') {
  444.           LEDs_pattern = 3;
  445.         }
  446.         else if (messageLetters[3] == 'b') {
  447.           LEDs_pattern = 4;
  448.         }
  449.         else {
  450.           // If the [speed] character is not correct, set the charOutOfRange indicator.
  451.           charOutOfRange = true;
  452.         }
  453.         Serial.print("performMessage() pattern = ");
  454.         Serial.println(LEDs_pattern);
  455.         led_pattern_control_1 = 0; // reset the pattern control sub-value
  456.       }
  457.     }
  458.     /*
  459.       Serial.print("red = ");
  460.       Serial.println(LEDs_color_red);
  461.       Serial.print("green = ");
  462.       Serial.println(LEDs_color_green);
  463.       Serial.print("blue = ");
  464.       Serial.println(LEDs_color_blue);
  465.     */
  466.     if (charOutOfRange == true) {
  467.       resetMessage();
  468.     }
  469.   } // if messageCounter == 3
  470.   else {
  471.     // any message that does not have 1 or 4 characters gets tossed out
  472.     resetMessage();
  473.   }
  474.  
  475.   // LEDs_off_on = 1;
  476.   //Serial.print("LEDs_off_on = ");
  477.   //Serial.println(LEDs_off_on);
  478.  
  479. }
  480.  
  481. void check_input_letter(char tLetter) {
  482.   charOutOfRange = true;
  483.   if (messageLetters[0] == 'e') {
  484.     charOutOfRange = false;
  485.   }
  486.   // -------------------------------
  487.   if (messageLetters[0] == 's') {
  488.     charOutOfRange = false;
  489.   }
  490.   if (messageLetters[0] == 'm') {
  491.     charOutOfRange = false;
  492.   }
  493.   if (messageLetters[0] == 'q') {
  494.     charOutOfRange = false;
  495.   }
  496.   // ------------------------------
  497.   if (messageLetters[0] == '1') {
  498.     charOutOfRange = false;
  499.   }
  500.   if (messageLetters[0] == '2') {
  501.     charOutOfRange = false;
  502.   }
  503.   if (messageLetters[0] == '3') {
  504.     charOutOfRange = false;
  505.   }
  506.   if (messageLetters[0] == '4') {
  507.     charOutOfRange = false;
  508.   }
  509.   if (messageLetters[0] == '5') {
  510.     charOutOfRange = false;
  511.   }
  512.   if (messageLetters[0] == '6') {
  513.     charOutOfRange = false;
  514.   }
  515.   if (messageLetters[0] == '7') {
  516.     charOutOfRange = false;
  517.   }
  518.   if (messageLetters[0] == '8') {
  519.     charOutOfRange = false;
  520.   }
  521.   // ---------------------------
  522.   if (messageLetters[0] == 'z') {
  523.     charOutOfRange = false;
  524.   }
  525.   if (messageLetters[0] == 'x') {
  526.     charOutOfRange = false;
  527.   }
  528.   if (messageLetters[0] == 'c') {
  529.     charOutOfRange = false;
  530.   }
  531.   if (messageLetters[0] == 'v') {
  532.     charOutOfRange = false;
  533.   }
  534.   if (messageLetters[0] == 'b') {
  535.     charOutOfRange = false;
  536.   }
  537. }
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!