API tools faq
paste
Advertisement
Guest User

Arduino 10x10 RGB LED Matrix

a guest
Sep 23rd, 2016
271
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 12.28 KB | None | 0 0
raw download clone embed print report
  1. class FLED {
  2.   private:
  3.     bool b;
  4.  
  5.   public:
  6.     FLED();
  7.     void show();
  8. };
  9.  
  10. FLED::FLED() : b(false) {
  11.  
  12. }
  13.  
  14. void FLED::show() {
  15.  
  16. }
  17.  
  18.  
  19. class LED {
  20.   private:
  21.     uint8_t LEDname;
  22.     uint8_t R;
  23.     uint8_t G;
  24.     uint8_t B;
  25.  
  26.   public:
  27.     LED();
  28.     uint8_t getR();
  29.     uint8_t getG();
  30.     uint8_t getB();
  31.     void setR(uint8_t _R);
  32.     void setG(uint8_t _G);
  33.     void setB(uint8_t _B);
  34. };
  35.  
  36. LED::LED() : R(0), G(0), B(0) {
  37.  
  38. }
  39.  
  40. uint8_t LED::getR() {
  41.   return R;
  42. }
  43. uint8_t LED::getG() {
  44.   return G;
  45. }
  46. uint8_t LED::getB() {
  47.   return B;
  48. }
  49.  
  50. void LED::setR(uint8_t _R) {
  51.   R = _R;
  52. }
  53. void LED::setG(uint8_t _G) {
  54.   G = _G;
  55. }
  56. void LED::setB(uint8_t _B) {
  57.   B = _B;
  58. }
  59.  
  60. LED leds[100];
  61. FLED FastLED;
  62.  
  63.  
  64. void setup() {
  65.   //set pins to output so you can control the shift register
  66.   pinMode(2, OUTPUT);
  67.   pinMode(4, OUTPUT);
  68.   pinMode(3, OUTPUT);
  69.   pinMode(5, OUTPUT);
  70.   //Serial.begin(250000);
  71.   //noInterrupts();
  72.  
  73. }
  74.  
  75. unsigned long lngLast = 0;
  76.  
  77.  
  78. uint8_t BitMapR1[10] = {
  79.   B00000000,
  80.   B00000000,
  81.   B00000000,
  82.   B00000000,
  83.   B00000000,
  84.   B00000000,
  85.   B00000000,
  86.   B00000000,
  87.   B00000000,
  88.   B00000000
  89. };
  90. uint8_t BitMapR2[10] = {
  91.   B00000000,
  92.   B00000000,
  93.   B00000000,
  94.   B00000000,
  95.   B00000000,
  96.   B00000000,
  97.   B00000000,
  98.   B00000000,
  99.   B00000000,
  100.   B00000000
  101. };
  102. uint8_t BitMapR3[10] = {
  103.   B00000000,
  104.   B00000000,
  105.   B00000000,
  106.   B00000000,
  107.   B00000000,
  108.   B00000000,
  109.   B00000000,
  110.   B00000000,
  111.   B00000000,
  112.   B00000000
  113. };
  114.  
  115. uint8_t BitMapR4[10] = {
  116.   B00000000,
  117.   B00000000,
  118.   B00000000,
  119.   B00000000,
  120.   B00000000,
  121.   B00000000,
  122.   B00000000,
  123.   B00000000,
  124.   B00000000,
  125.   B00000000
  126. };
  127.  
  128. LED CRGB(byte _R, byte _G, byte _B) {
  129.   LED _LED = LED();
  130.   _LED.setR(constrain(_R / 16, 0, 15));
  131.   _LED.setG(constrain(_G / 16, 0, 15));
  132.   _LED.setB(constrain(_B / 16, 0, 15));
  133.   return _LED;
  134. }
  135.  
  136. void loop() {
  137.  
  138.  
  139.   //Serial.print(micros()); Serial.println(" Start");
  140.  
  141.   leds[0] = CRGB(36, 0, 0);
  142.   leds[1] = CRGB(103, 0, 0);
  143.   leds[2] = CRGB(170, 0, 0);
  144.   leds[3] = CRGB(255, 0, 0);
  145.   leds[4] = CRGB(255, 0, 0);
  146.   leds[5] = CRGB(170, 0, 0);
  147.   leds[6] = CRGB(103, 0, 0);
  148.   leds[7] = CRGB(36, 0, 0);
  149.   leds[8] = CRGB(0, 0, 0);
  150.   leds[9] = CRGB(0, 0, 0);
  151.   leds[10] = CRGB(36, 0, 0);
  152.   leds[11] = CRGB(103, 0, 0);
  153.   leds[12] = CRGB(170, 0, 0);
  154.   leds[13] = CRGB(255, 0, 0);
  155.   leds[14] = CRGB(255, 0, 0);
  156.   leds[15] = CRGB(170, 0, 0);
  157.   leds[16] = CRGB(103, 0, 0);
  158.   leds[17] = CRGB(36, 0, 0);
  159.   leds[18] = CRGB(0, 0, 0);
  160.   leds[19] = CRGB(0, 0, 0);
  161.   leds[20] = CRGB(36, 0, 0);
  162.   leds[21] = CRGB(103, 0, 0);
  163.   leds[22] = CRGB(170, 0, 0);
  164.   leds[23] = CRGB(255, 0, 0);
  165.   leds[24] = CRGB(255, 0, 0);
  166.   leds[25] = CRGB(170, 0, 0);
  167.   leds[26] = CRGB(103, 0, 0);
  168.   leds[27] = CRGB(36, 0, 0);
  169.   leds[28] = CRGB(0, 0, 0);
  170.   leds[29] = CRGB(0, 0, 0);
  171.   leds[30] = CRGB(36, 0, 0);
  172.   leds[31] = CRGB(103, 0, 0);
  173.   leds[32] = CRGB(170, 0, 0);
  174.   leds[33] = CRGB(255, 0, 0);
  175.   leds[34] = CRGB(255, 0, 0);
  176.   leds[35] = CRGB(170, 0, 0);
  177.   leds[36] = CRGB(103, 0, 0);
  178.   leds[37] = CRGB(36, 0, 0);
  179.   leds[38] = CRGB(0, 0, 0);
  180.   leds[39] = CRGB(0, 0, 0);
  181.   leds[40] = CRGB(36, 0, 0);
  182.   leds[41] = CRGB(103, 0, 0);
  183.   leds[42] = CRGB(170, 0, 0);
  184.   leds[43] = CRGB(255, 0, 0);
  185.   leds[44] = CRGB(255, 0, 0);
  186.   leds[45] = CRGB(170, 0, 0);
  187.   leds[46] = CRGB(103, 0, 0);
  188.   leds[47] = CRGB(36, 0, 0);
  189.   leds[48] = CRGB(0, 0, 0);
  190.   leds[49] = CRGB(0, 0, 0);
  191.   leds[50] = CRGB(36, 0, 0);
  192.   leds[51] = CRGB(103, 0, 0);
  193.   leds[52] = CRGB(170, 0, 0);
  194.   leds[53] = CRGB(255, 0, 0);
  195.   leds[54] = CRGB(255, 0, 0);
  196.   leds[55] = CRGB(170, 0, 0);
  197.   leds[56] = CRGB(103, 0, 0);
  198.   leds[57] = CRGB(36, 0, 0);
  199.   leds[58] = CRGB(0, 0, 0);
  200.   leds[59] = CRGB(0, 0, 0);
  201.   leds[60] = CRGB(36, 0, 0);
  202.   leds[61] = CRGB(103, 0, 0);
  203.   leds[62] = CRGB(170, 0, 0);
  204.   leds[63] = CRGB(255, 0, 0);
  205.   leds[64] = CRGB(255, 0, 0);
  206.   leds[65] = CRGB(170, 0, 0);
  207.   leds[66] = CRGB(103, 0, 0);
  208.   leds[67] = CRGB(36, 0, 0);
  209.   leds[68] = CRGB(0, 0, 0);
  210.   leds[69] = CRGB(0, 0, 0);
  211.   leds[70] = CRGB(36, 0, 0);
  212.   leds[71] = CRGB(103, 0, 0);
  213.   leds[72] = CRGB(170, 0, 0);
  214.   leds[73] = CRGB(255, 0, 0);
  215.   leds[74] = CRGB(255, 0, 0);
  216.   leds[75] = CRGB(170, 0, 0);
  217.   leds[76] = CRGB(103, 0, 0);
  218.   leds[77] = CRGB(36, 0, 0);
  219.   leds[78] = CRGB(0, 0, 0);
  220.   leds[79] = CRGB(0, 0, 0);
  221.   leds[80] = CRGB(36, 0, 0);
  222.   leds[81] = CRGB(103, 0, 0);
  223.   leds[82] = CRGB(170, 0, 0);
  224.   leds[83] = CRGB(255, 0, 0);
  225.   leds[84] = CRGB(255, 0, 0);
  226.   leds[85] = CRGB(170, 0, 0);
  227.   leds[86] = CRGB(103, 0, 0);
  228.   leds[87] = CRGB(36, 0, 0);
  229.   leds[88] = CRGB(0, 0, 0);
  230.   leds[89] = CRGB(0, 0, 0);
  231.   leds[90] = CRGB(36, 0, 0);
  232.   leds[91] = CRGB(103, 0, 0);
  233.   leds[92] = CRGB(170, 0, 0);
  234.   leds[93] = CRGB(255, 0, 0);
  235.   leds[94] = CRGB(255, 0, 0);
  236.   leds[95] = CRGB(170, 0, 0);
  237.   leds[96] = CRGB(103, 0, 0);
  238.   leds[97] = CRGB(36, 0, 0);
  239.   leds[98] = CRGB(0, 0, 0);
  240.   leds[99] = CRGB(0, 0, 0);
  241.  
  242.  
  243.  
  244.  
  245.   //Serial.print(micros()); Serial.println(" Objekte");
  246.  
  247.   //setBitMaps();
  248.   //myloop();
  249.  
  250.   BAM();
  251.  
  252.  
  253.  
  254.  
  255.  
  256.   //Serial.print(micros()); Serial.println(" BAM");
  257.  
  258. }
  259.  
  260. void BAM() {
  261.   for (byte cycle = 1; cycle <= 15; cycle++) {
  262.     //Serial.print(micros()); Serial.println(" bSetBitMaps");
  263.     setBitMaps(cycle, 1);
  264.     //Serial.print(micros()); Serial.println(" aSetBitMaps");
  265.     lngLast = micros();
  266.     myloop();
  267.     delayMicroseconds(50);
  268.     turnoff();
  269.     //Serial.print(micros()); Serial.println(" aMyloop");
  270.   }
  271. }
  272.  
  273. void turnoff() {
  274.   PORTD &= ~_BV(PORTD2);
  275.  
  276.   ShiftOut(B00000000);
  277.   ShiftOut(B00000000);
  278.   ShiftOut(B00000000);
  279.   ShiftOut(B00000000);
  280.   ShiftOut(B00000000);
  281.  
  282.   PORTD |= _BV(PORTD2);//LatchPin
  283. }
  284.  
  285. void setBitMaps(byte cycle, byte pos) {
  286.   //Register 1
  287.   for (byte intLayerSel = 0; intLayerSel < 100; intLayerSel += 10) { //Schleife laeuft 10x
  288.  
  289.     byte _byte = 0;
  290.     for (byte i = intLayerSel; i < intLayerSel + 8; i++) {
  291.       if (cycle == 1 && (leds[i].getR() & (1 << pos - 1)) != 0) {
  292.         _byte = _byte << 1;
  293.         _byte = _byte + B00000001;
  294.       }
  295.       else if ((cycle == 2 || cycle == 3) && (leds[i].getR() & (1 << pos)) != 0) {
  296.         _byte = _byte << 1;
  297.         _byte = _byte + B00000001;
  298.       }
  299.       else if (cycle >= 4 && cycle <= 7 && (leds[i].getR() & (1 << pos + 1 )) != 0)  {
  300.         _byte = _byte << 1;
  301.         _byte = _byte + B00000001;
  302.       }
  303.       else if (cycle >= 8 && cycle <= 15 && (leds[i].getR() & (1 << pos + 2)) != 0) {
  304.         _byte = _byte << 1;
  305.         _byte = _byte + B00000001;
  306.       }
  307.       else {
  308.         _byte = _byte << 1;
  309.         _byte = _byte + B00000000;
  310.       }
  311.     }
  312.     BitMapR1[intLayerSel / 10] = _byte;
  313.   }
  314.   for (byte intLayerSel = 0; intLayerSel < 100; intLayerSel += 10) { //Schleife laeuft 10x
  315.  
  316.     byte _byte = 0;
  317.     for (byte i = intLayerSel + 8; i < intLayerSel + 10; i++) {
  318.       if (cycle == 1 && (leds[i].getR() & (1 << pos - 1)) != 0) {
  319.         _byte = _byte << 1;
  320.         _byte = _byte + B00000001;
  321.       }
  322.       else if ((cycle == 2 || cycle == 3) && (leds[i].getR() & (1 << pos)) != 0) {
  323.         _byte = _byte << 1;
  324.         _byte = _byte + B00000001;
  325.       }
  326.       else if (cycle >= 4 && cycle <= 7 && (leds[i].getR() & (1 << pos + 1 )) != 0)  {
  327.         _byte = _byte << 1;
  328.         _byte = _byte + B00000001;
  329.       }
  330.       else if (cycle >= 8 && cycle <= 15 && (leds[i].getR() & (1 << pos + 2)) != 0) {
  331.         _byte = _byte << 1;
  332.         _byte = _byte + B00000001;
  333.       }
  334.       else {
  335.         _byte = _byte << 1;
  336.         _byte = _byte + B00000000;
  337.       }
  338.     }
  339.     for (byte i = intLayerSel; i < intLayerSel + 6; i++) {
  340.       if (cycle == 1 && (leds[i].getG() & (1 << pos - 1)) != 0) {
  341.         _byte = _byte << 1;
  342.         _byte = _byte + B00000001;
  343.       }
  344.       else if ((cycle == 2 || cycle == 3) && (leds[i].getG() & (1 << pos)) != 0) {
  345.         _byte = _byte << 1;
  346.         _byte = _byte + B00000001;
  347.       }
  348.       else if (cycle >= 4 && cycle <= 7 && (leds[i].getG() & (1 << pos + 1 )) != 0)  {
  349.         _byte = _byte << 1;
  350.         _byte = _byte + B00000001;
  351.       }
  352.       else if (cycle >= 8 && cycle <= 15 && (leds[i].getG() & (1 << pos + 2)) != 0) {
  353.         _byte = _byte << 1;
  354.         _byte = _byte + B00000001;
  355.       }
  356.       else {
  357.         _byte = _byte << 1;
  358.         _byte = _byte + B00000000;
  359.       }
  360.     }
  361.     BitMapR2[intLayerSel / 10] = _byte;
  362.   }
  363. }
  364.  
  365.  
  366.  
  367. void myloop() {
  368.  
  369.   byte bLayerA;
  370.   byte bLayerB;
  371.  
  372.  
  373.  
  374.   for (byte bLayerTop = 1; bLayerTop <= 10; bLayerTop++) {
  375.     //Serial.print(micros()); Serial.println(" startML");
  376.     bLayerA = B00000000;
  377.     bLayerB = B00000000;
  378.     switch (bLayerTop) {
  379.       case 1:
  380.         bLayerA = B10000000;
  381.         break;
  382.       case 2:
  383.         bLayerA = B01000000;
  384.         break;
  385.       case 3:
  386.         bLayerA = B00100000;
  387.         break;
  388.       case 4:
  389.         bLayerA = B00010000;
  390.         break;
  391.       case 5:
  392.         bLayerA = B00001000;
  393.         break;
  394.       case 6:
  395.         bLayerA = B00000100;
  396.         break;
  397.       case 7:
  398.         bLayerA = B00000010;
  399.         break;
  400.       case 8:
  401.         bLayerA = B00000001;
  402.         break;
  403.       case 9:
  404.         bLayerB = B00000010;
  405.         break;
  406.       case 10:
  407.         bLayerB = B00000001;
  408.         break;
  409.  
  410.     }
  411.     /*
  412.       if (bLayerTop == 1) {
  413.       bLayerA = B10000000;
  414.       } else if (bLayerTop == 2) {
  415.       bLayerA = B01000000;
  416.       } else if (bLayerTop == 3) {
  417.       bLayerA = B00100000;
  418.       } else if (bLayerTop == 4) {
  419.       bLayerA = B00010000;
  420.       } else if (bLayerTop == 5) {
  421.       bLayerA = B00001000;
  422.       } else if (bLayerTop == 6) {
  423.       bLayerA = B00000100;
  424.       } else if (bLayerTop == 7) {
  425.       bLayerA = B00000010;
  426.       } else if (bLayerTop == 8) {
  427.       bLayerA = B00000001;
  428.       } else if (bLayerTop == 9) {
  429.       bLayerB = B00000010;
  430.       } else if (bLayerTop == 10) {
  431.       bLayerB = B00000001;
  432.       }
  433.     */
  434.  
  435.  
  436.     //Serial.print(micros()); Serial.println(" bWait");
  437.     while (micros() - lngLast < 50) {
  438.       //Serial.println("call");
  439.     }
  440.     //Serial.print(micros()); Serial.println(" aWait");
  441.     turnoff();
  442.  
  443.     PORTD &= ~_BV(PORTD2); //Latch LOW
  444.     //OutPut Enable = False
  445.     PORTD |= _BV(PORTD5);
  446.  
  447.     byte bLayer = bLayerTop - 1;
  448.     ShiftOut(bLayerA);                     //Register 5
  449.     ShiftOut(bLayerB + BitMapR4[bLayer]);  //Register 4
  450.     ShiftOut(BitMapR3[bLayer]);            //Register 3
  451.     ShiftOut(BitMapR2[bLayer]);            //Register 2
  452.     ShiftOut(BitMapR1[bLayer]);            //Register 1
  453.  
  454.     //take the latch pin high so the LEDs will light up:
  455.  
  456.     PORTD |= _BV(PORTD2);//Latch High
  457.     //OutPut Enable = True
  458.     PORTD &= ~_BV(PORTD5);
  459.     // pause before next value:
  460.  
  461.     //delay(1);
  462.     //delayMicroseconds(100);
  463.     // Serial.print(micros()); Serial.println(" end");
  464.     lngLast = micros();
  465.  
  466.   }
  467.  
  468. }
  469.  
  470. void ShiftOut(byte myDataOut) {
  471.   // This shifts 8 bits out MSB first,
  472.   //on the rising edge of the clock,
  473.   //clock idles low
  474.  
  475.   //internal function setup
  476.   byte i = 0;
  477.  
  478.   //clear everything out just in case to
  479.   //prepare shift register for bit shifting
  480.   PORTD &= ~_BV(PORTD3);//Data aus
  481.   PORTD &= ~_BV(PORTD4);//Clock aus
  482.  
  483.   //for each bit in the byte myDataOutï
  484.   //NOTICE THAT WE ARE COUNTING DOWN in our for loop
  485.   //This means that %00000001 or "1" will go through such
  486.   //that it will be pin Q0 that lights.
  487.   for (i = 0; i <= 7; i++)  {
  488.     PORTD &= ~_BV(PORTD4);//Clock aus
  489.  
  490.     //if the value passed to myDataOut and a bitmask result
  491.     // true then... so if we are at i=6 and our value is
  492.     // %11010100 it would the code compares it to %01000000
  493.     // and proceeds to set pinState to 1.
  494.  
  495.  
  496.     /*
  497.         //00001010 - 00000010 = true
  498.         switch (myDataOut & (1 << i)) {
  499.           case 0:
  500.             Serial.println("0");
  501.             PORTD &= ~_BV(PORTD3);//Data aus
  502.             break;
  503.           case true:
  504.             Serial.println("1");
  505.             PORTD |= _BV(PORTD3);//Data an
  506.  
  507.             break;
  508.         }
  509.     */
  510.  
  511.     /*
  512.       digitalWrite(3, myDataOut & (1 << i));
  513.     */
  514.  
  515.  
  516.     if ( myDataOut & (1 << i) ) {
  517.       PORTD |= _BV(PORTD3);//Data an
  518.     } else {
  519.       PORTD &= ~_BV(PORTD3);//Data aus
  520.     }
  521.  
  522.     //register shifts bits on upstroke of clock pin
  523.     PORTD |= _BV(PORTD4);//Clock an
  524.     //zero the data pin after shift to prevent bleed through
  525.     PORTD &= ~_BV(PORTD3);//Data aus
  526.   }
  527. }
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!