daily pastebin goal
74%
SHARE
TWEET

IRremote_ledcube3x

Al_Ninyo Jan 14th, 2015 579 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <IRremote.h>
  2. #include <LedCube.h>
  3.  
  4. #define SIZE 3
  5. #define COLS (SIZE*SIZE)
  6.    
  7. int RECV_PIN = 4;
  8. IRrecv irrecv(RECV_PIN);
  9. decode_results results;
  10.      
  11.     // Initalize our LED columns (positive)
  12.     byte LEDPin[] = {5,8,11,6,9,12,7,10,13};
  13.     // Initalize the LED layers (ground)
  14.     byte LayerPin[] = {A3,A4,A5};
  15.    
  16.     LedCube cube(3, LayerPin, LEDPin);
  17.    
  18.     int count = 0;
  19.     int pin = 0;
  20.     int layer = 0;
  21.     boolean PinState = 0;
  22.      
  23.     int LPin = 0;
  24.      
  25. void LayersOff() { // функция для выключения всех слоёв
  26.       for(int layer = 0; layer < 3; layer++){
  27.         digitalWrite(LayerPin[layer], LOW);
  28.       }
  29.     }
  30.      
  31. void LayersOn() { // функция для включения всех слоёв
  32.       for(int layer = 0; layer < 3; layer++){
  33.         digitalWrite(LayerPin[layer], HIGH);
  34.       }
  35.     }
  36.      
  37. void PinOnOff() {
  38.         PinState = !PinState;
  39.         digitalWrite(LEDPin[pin],PinState);
  40.     }
  41.      
  42. void LayerUP(int layer) { // включаем на 1 слой выше
  43.         for (LPin = 0; LPin < layer; LPin++){
  44.         digitalWrite(LayerPin[LPin],HIGH);
  45.         }
  46.     }
  47.      
  48. void setup() {
  49.     //  pinMode(ButPin, INPUT);    // Задаем как вход
  50.       Serial.begin(9600);
  51.     //  pinMode(IRpin, INPUT);
  52.       irrecv.enableIRIn(); // Start the receiver
  53.      
  54.       // Set up LED columns as output
  55.       for(int pin = 0; pin < 10 ; pin++ ){
  56.         pinMode(LEDPin[pin],OUTPUT);
  57.         digitalWrite(LEDPin[pin],LOW);
  58.       }
  59.       // Set up LED Layers as output
  60.       for(int layer = 0; layer < 3; layer++){
  61.         pinMode(LayerPin[layer], OUTPUT);
  62.       }
  63.       LayersOff();
  64.      
  65.     }
  66.      
  67. void loop() {
  68.       if (irrecv.decode(&results)) {
  69.         Serial.println(results.value);  
  70.         switch (results.value)  {
  71.           case 0xFF6897: // button 0
  72.             Serial.println("pin 0");
  73.             pin = 0;
  74.             PinOnOff();
  75.             break;
  76.           case 0xFF30CF: // button 1
  77.             Serial.println("pin 1");
  78.             pin = 1;
  79.             PinOnOff();
  80.             break;
  81.           case 0xFF18E7: // button 2
  82.             Serial.println("pin 2");
  83.             pin = 2;
  84.             PinOnOff();
  85.             break;
  86.           case 0xFF7A85: // button 3
  87.             Serial.println("pin 3");
  88.             pin = 3;
  89.             PinOnOff();
  90.             break;
  91.           case 0xFF10EF: // button 4
  92.             Serial.println("pin 4");
  93.             pin = 4;
  94.             PinOnOff();
  95.             break;
  96.           case 0xFF38C7: // button 5
  97.             Serial.println("pin 5");
  98.             pin = 5;
  99.             PinOnOff();
  100.             break;
  101.           case 0xFF5AA5: // button 6
  102.             Serial.println("pin 6");
  103.             pin = 6;
  104.             PinOnOff();
  105.             break;
  106.           case 0xFF42BD: // button 7
  107.             Serial.println("pin 7");
  108.             pin = 7;
  109.             PinOnOff();
  110.             break;
  111.           case 0xFF4AB5: // button 8
  112.             Serial.println("pin 8");
  113.             pin = 8;
  114.             PinOnOff();
  115.             break;
  116.           case 0xFF52AD: // button 9
  117.             Serial.println("All is UP!");
  118.               PinState = !PinState;
  119.               for(int pin = 0; pin < 10 ; pin++ ){
  120.                 digitalWrite(LEDPin[pin],PinState);
  121.               }
  122.             break;
  123.           case 0xFFE01F: //vol-
  124.             if (pin < 0) {
  125.               pin = 8;
  126.                 int count = 0;
  127.                 while (count < 3) {
  128.                   PinOnOff();
  129.                   delay(50);
  130.                   count++;
  131.                 }
  132.             } else {
  133.                 PinOnOff();
  134.                 pin = pin--;
  135.               }
  136.             PinOnOff();
  137.             Serial.print("pin - | ");
  138.             Serial.println(pin);
  139.             break;
  140.           case 0xFFA857: //vol+
  141.             Serial.print("pin + | ");
  142.             Serial.println(pin);
  143.             if (pin > 8) {
  144.               pin = 0;
  145.                 int count = 0;
  146.                 while (count < 3) {
  147.                   PinOnOff();
  148.                   delay(50);
  149.                   count++;
  150.                 }
  151.             } else {
  152.                 PinOnOff();
  153.                 pin = ++pin;
  154.               }
  155.             PinOnOff();
  156.             break;
  157.           case 0xFFA25D: //CH-
  158.             if (layer < 0) {
  159.               layer = 0;
  160.               LayersOff();
  161.               int count = 0;
  162.                 while (count < 3) {
  163.                   LayersOn();
  164.                   delay(50);
  165.                   LayersOff();
  166.                   delay(50);
  167.                   count++;
  168.                 }
  169.             } else {
  170.                 digitalWrite(LayerPin[layer],LOW);
  171.                 layer = layer--;
  172.             }
  173.             Serial.print("layer - | ");
  174.             Serial.println(layer);
  175.             break;
  176.           case 0xFFE21D: //CH+
  177.             if (layer > 2) {
  178.               layer = 3;
  179.               int count = 0;
  180.                 while (count < 3) {
  181.                   LayersOff();
  182.                   delay(50);
  183.                   LayersOn();
  184.                   delay(50);
  185.                   count++;
  186.                 }
  187.             } else {
  188.                 layer = layer++;
  189.             }
  190.             LayerUP(layer);
  191.             Serial.print("layer + | ");
  192.             Serial.println(layer);
  193.             break;
  194.           case 0xFF22DD: // PREV
  195.             LayersOff();
  196.               if (layer == 0) {
  197.                 layer = 2;
  198.               }
  199.                 else {
  200.                   layer = layer--;
  201.                 }
  202.                 digitalWrite(LayerPin[layer],HIGH);
  203.             Serial.print("prev layer | ");
  204.             Serial.println(layer);
  205.             break;
  206.           case 0xFF02FD: // NEXT
  207.             LayersOff();
  208.             if (layer >= 2) {
  209.               layer = 0;
  210.               }
  211.                 else {
  212.                   layer = layer++;
  213.                   }
  214.                 digitalWrite(LayerPin[layer],HIGH);
  215.             Serial.print("next layer | ");
  216.             Serial.println(layer);
  217.             break;
  218.           case 0xFF629D: //CH
  219.             Serial.println("Layers Off");
  220.             LayersOff();
  221.             layer = -1;
  222.             break;
  223.           case 0xFFC23D: //PAUSE
  224.             Serial.println("Layers On");
  225.             LayersOn();
  226.             break;
  227.           case 0xFF906F: // EQ
  228.             Serial.print("pin = ");
  229.             Serial.println(pin);
  230.             Serial.print("layer = ");
  231.             Serial.println(layer);
  232.             delay(100);
  233.     cube.enableBuffer(false);
  234.    
  235.     // light one level at a time, increasing speed each time
  236.     for(byte d=25; d>2; d-=2) {
  237.         for(byte r=0; r<cube.getLevels(); r++) {
  238.             cube.lightLevel(r,d);
  239.         }
  240.     }
  241.    
  242.     // single random light at a time
  243.     cube.randomLight(random(25,100),100);
  244.    
  245.     // random column drop
  246.     for(byte x=0; x<=15; x++) {
  247.         cube.lightDrop(random(0,cube.getCols()), random(50,150));
  248.     }
  249.    
  250.     // circle around cube at a random level
  251.     for(byte x=0; x<=5; x++) {
  252.         cube.lightPerimeter(random(0,cube.getLevels()), random(1,5), random(25,100));
  253.     }
  254.    
  255.     // random columns
  256.     cube.randomColumn(25);
  257.    
  258.     // turn off a single column randomly
  259.     cube.enableBuffer();
  260.     for(byte c=0; c<25; c++)
  261.     {
  262.         cube.fillBuffer();
  263.         cube.invertBuffer();
  264.         cube.randomColumn();
  265.         cube.drawBuffer(10);
  266.     }
  267.     cube.enableBuffer(false);
  268.    
  269.     // cols in and out
  270.     for(byte c=1, d=0; c<=36; c++)
  271.     {
  272.         if(c%2 == 0){
  273.             for(d=0; d<20; d++) {
  274.                 cube.lightColumn(2,1);
  275.                 cube.lightColumn(4,1);
  276.                 cube.lightColumn(6,1);
  277.                 cube.lightColumn(8,1);
  278.             }
  279.         } else if(c%4 == 1) {
  280.             for(d=0; d<30; d++) {
  281.                 cube.lightColumn(1,1);
  282.                 cube.lightColumn(3,1);
  283.                 cube.lightColumn(7,1);
  284.                 cube.lightColumn(9,1);
  285.             }
  286.         } else {
  287.             for(d=0; d<70; d++) {
  288.                 cube.lightColumn(5,1);
  289.             }
  290.         }
  291.     }
  292.    
  293.     // diamond and box
  294.     byte diamond[] = {0,4, 1,1, 1,3, 1,4, 1,5, 1,7, 2,4};
  295.     byte box[] = {0,0, 0,1, 0,2, 0,3, 0,5, 0,6, 0,7, 0,8, 1,1,  1,0, 1,2, 1,6, 1,8,  2,0, 2,1, 2,2, 2,3, 2,5, 2,6, 2,7, 2,8};
  296.     cube.lightSequence(box, sizeof(box), 200);
  297.     cube.lightSequence(diamond, sizeof(diamond), 400);
  298.    
  299.     // helicopter effect
  300.     cube.enableBuffer();
  301.     byte topSeq[8] = {0,3,6,7,8,5,2,1};
  302.     byte botSeq[8] = {8,5,2,1,0,3,6,7};
  303.     for(byte r = 0; r<7; r++){
  304.         for(byte s= 0; s<8; s++){
  305.             cube.clearBuffer();
  306.             cube.lightOn(0,botSeq[s]);
  307.             cube.lightOn(1,4);
  308.             cube.lightOn(2,topSeq[s]);
  309.             cube.drawBuffer(20);
  310.         }
  311.     }
  312.    
  313.     // turn off one light at a time
  314.     cube.fillBuffer();
  315.     cube.drawBuffer(25);
  316.     for(byte w=0, l, c; w<27; ){
  317.         l = random(0,cube.getLevels());
  318.         c = random(0,cube.getCols());
  319.         if(cube.getBufferAt(l,c)){
  320.             cube.lightOff(l,c);
  321.             cube.drawBuffer(15+w*2);
  322.             w++;
  323.         }
  324.     }
  325.             layer = 0;
  326.             pin = 0;
  327.             break;
  328.          }
  329.         irrecv.resume(); // Receive the next value
  330.       }  
  331.     }
RAW Paste Data
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
 
Top