找回密码
 立即注册

QQ登录

只需一步,快速开始

搜索
查看: 2964|回复: 2
收起左侧

LED驱动WS2801单片机程序和资料下载

[复制链接]
ID:71896 发表于 2016-6-21 21:28 | 显示全部楼层 |阅读模式
LED驱动WS2801
0.png 0.png

WS2801单片机程序:
  1. #include<stc12c56.h>
  2. #include"WS2801.H"
  3. #define u8 unsigned char
  4. #define u16 unsigned int
  5. #define u32 unsigned long
  6. u8 num=0,MODE=0,GAME_NUM=0,R_PWM=0,G_PWM=0,B_PWM=0,WATEN_NUM=0;
  7. u8 bdata  set=0;
  8. sbit  F_CLOCK=set^0;
  9. sbit  F_INC=set^1;
  10. sbit  F_WATER=set^2;

  11. u8 status_mode=0;
  12. u16 mode_count=0;
  13. bit flag=0,StackerGame_flag=0;
  14. void T0_Init(void)                          //PWM初始化
  15. {
  16.         TMOD=0x01;
  17.         TH0=170;
  18.         TL0=200;
  19.         EA=1;
  20.         ET0=1;
  21.         TR0=1;
  22. }
  23. void exter0() interrupt 1   
  24. {
  25.         TH0=200;  
  26.         TL0=200;
  27.         mode_count++;
  28.         if(mode_count>=3000)
  29.         {
  30.                  mode_count=0;
  31.                 status_mode++;
  32.                 if(status_mode>38)
  33.                 {
  34.                           status_mode=0;
  35.                 }
  36.         }
  37.         WS2801_Write_data();
  38.         CLK=0;                //MT9221时钟信号
  39.         DATA=0;                    //MT9221数据信号
  40. }
  41. void RGB_7_SE_MAN()                                   //7单色慢闪
  42. {
  43.         static u32 count=60000;
  44.         u8 i;
  45.         switch (count)
  46.         {
  47.                 case 60000:       
  48.                 {
  49.                         for(i=0;i<150;i++)
  50.                         {
  51.                                 RGB_DATA[i]=255;
  52.                                 RGB_DATA[i+1]=0;
  53.                                 RGB_DATA[i+2]=0;
  54.                                 i++;i++;
  55.                         }
  56.                 }break;
  57.                 case 120000:       
  58.                 {
  59.                         for(i=0;i<150;i++)
  60.                         {
  61.                                 RGB_DATA[i]=0;
  62.                                 RGB_DATA[i+1]=255;
  63.                                 RGB_DATA[i+2]=0;
  64.                                 i++;i++;
  65.                         }
  66.                 }break;
  67.                 case 180000:       
  68.                 {
  69.                         for(i=0;i<150;i++)
  70.                         {
  71.                                 RGB_DATA[i]=0;
  72.                                 RGB_DATA[i+1]=0;
  73.                                 RGB_DATA[i+2]=255;
  74.                                 i++;i++;
  75.                         }
  76.                 }break;
  77.                 case 240000:       
  78.                 {
  79.                         for(i=0;i<150;i++)
  80.                         {
  81.                                 RGB_DATA[i]=255;
  82.                                 RGB_DATA[i+1]=255;
  83.                                 RGB_DATA[i+2]=0;
  84.                                 i++;i++;
  85.                         }
  86.                 }break;
  87.                 case 300000:       
  88.                 {
  89.                         for(i=0;i<150;i++)
  90.                         {
  91.                                 RGB_DATA[i]=0;
  92.                                 RGB_DATA[i+1]=255;
  93.                                 RGB_DATA[i+2]=255;
  94.                                 i++;i++;
  95.                         }
  96.                 }break;
  97.                 case 360000:       
  98.                 {
  99.                         for(i=0;i<150;i++)
  100.                         {
  101.                                 RGB_DATA[i]=255;
  102.                                 RGB_DATA[i+1]=0;
  103.                                 RGB_DATA[i+2]=255;
  104.                                 i++;i++;
  105.                         }
  106.                 }break;
  107.                 case 420000:       
  108.                 {
  109.                         for(i=0;i<150;i++)
  110.                         {
  111.                                 RGB_DATA[i]=255;
  112.                                 RGB_DATA[i+1]=255;
  113.                                 RGB_DATA[i+2]=255;
  114.                                 i++;i++;
  115.                         }
  116.                 }
  117.                 count=0;
  118.                 break;
  119.         }
  120.         count++;
  121. }
  122. void RGB_7_SE_BIAN(u16 num)                                //7单色渐变
  123. {
  124.         static u8 count=0;
  125.         static u16 count_k=0;
  126.         u8 i,k;
  127.         switch(count)
  128.         {
  129.                 case 0:
  130.                 {
  131.                         if(count_k>=num)
  132.                         {
  133.                                  count_k=0;
  134.                                 k++;
  135.                                 if(k>=255)
  136.                                 {
  137.                                          count=1;
  138.                                 }
  139.                                 for(i=0;i<150;i++)
  140.                                 {
  141.                                         RGB_DATA[i]=k;
  142.                                         RGB_DATA[i+1]=0;
  143.                                         RGB_DATA[i+2]=0;
  144.                                         i++;i++;
  145.                                 }
  146.                         }
  147.                 }
  148.                 count_k++;
  149.                 break;
  150.                 case 1:
  151.                 {
  152.                         if(count_k>=num)
  153.                         {
  154.                                  count_k=0;
  155.                                 k++;
  156.                                 if(k>=255)
  157.                                 {
  158.                                          count=2;
  159.                                 }
  160.                                 for(i=0;i<150;i++)
  161.                                 {
  162.                                         RGB_DATA[i]=255-k;
  163.                                         RGB_DATA[i+1]=0;
  164.                                         RGB_DATA[i+2]=0;
  165.                                         i++;i++;
  166.                                 }
  167.                         }
  168.                 }
  169.                 count_k++;
  170.                 break;
  171.                 case 2:
  172.                 {
  173.                         if(count_k>=num)
  174.                         {
  175.                                  count_k=0;
  176.                                 k++;
  177.                                 if(k>=255)
  178.                                 {
  179.                                          count=3;
  180.                                 }
  181.                                 for(i=0;i<150;i++)
  182.                                 {
  183.                                         RGB_DATA[i]=0;
  184.                                         RGB_DATA[i+1]=k;
  185.                                         RGB_DATA[i+2]=0;
  186.                                         i++;i++;
  187.                                 }
  188.                         }
  189.                 }
  190.                 count_k++;
  191.                 break;
  192.                 case 3:
  193.                 {
  194.                         if(count_k>=num)
  195.                         {
  196.                                  count_k=0;
  197.                                 k++;
  198.                                 if(k>=255)
  199.                                 {
  200.                                          count=4;
  201.                                 }
  202.                                 for(i=0;i<150;i++)
  203.                                 {
  204.                                         RGB_DATA[i]=0;
  205.                                         RGB_DATA[i+1]=255-k;
  206.                                         RGB_DATA[i+2]=0;
  207.                                         i++;i++;
  208.                                 }
  209.                         }
  210.                 }
  211.                 count_k++;
  212.                 break;
  213.                 case 4:
  214.                 {
  215.                         if(count_k>=num)
  216.                         {
  217.                                  count_k=0;
  218.                                 k++;
  219.                                 if(k>=255)
  220.                                 {
  221.                                          count=5;
  222.                                 }
  223.                                 for(i=0;i<150;i++)
  224.                                 {
  225.                                         RGB_DATA[i]=0;
  226.                                         RGB_DATA[i+1]=0;
  227.                                         RGB_DATA[i+2]=k;
  228.                                         i++;i++;
  229.                                 }
  230.                         }
  231.                 }
  232.                 count_k++;
  233.                 break;
  234.                 case 5:
  235.                 {
  236.                         if(count_k>=num)
  237.                         {
  238.                                  count_k=0;
  239.                                 k++;
  240.                                 if(k>=255)
  241.                                 {
  242.                                          count=6;
  243.                                 }
  244.                                 for(i=0;i<150;i++)
  245.                                 {
  246.                                         RGB_DATA[i]=0;
  247.                                         RGB_DATA[i+1]=0;
  248.                                         RGB_DATA[i+2]=255-k;
  249.                                         i++;i++;
  250.                                 }
  251.                         }
  252.                 }
  253.                 count_k++;
  254.                 break;
  255.                 case 6:
  256.                 {
  257.                         if(count_k>=num)
  258.                         {
  259.                                  count_k=0;
  260.                                 k++;
  261.                                 if(k>=255)
  262.                                 {
  263.                                          count=7;
  264.                                 }
  265.                                 for(i=0;i<150;i++)
  266.                                 {
  267.                                         RGB_DATA[i]=k;
  268.                                         RGB_DATA[i+1]=k;
  269.                                         RGB_DATA[i+2]=0;
  270.                                         i++;i++;
  271.                                 }
  272.                         }
  273.                 }
  274.                 count_k++;
  275.                 break;
  276.                 case 7:
  277.                 {
  278.                         if(count_k>=num)
  279.                         {
  280.                                  count_k=0;
  281.                                 k++;
  282.                                 if(k>=255)
  283.                                 {
  284.                                          count=8;
  285.                                 }
  286.                                 for(i=0;i<150;i++)
  287.                                 {
  288.                                         RGB_DATA[i]=255-k;
  289.                                         RGB_DATA[i+1]=255-k;
  290.                                         RGB_DATA[i+2]=0;
  291.                                         i++;i++;
  292.                                 }
  293.                         }
  294.                 }
  295.                 count_k++;
  296.                 break;
  297.                 case 8:
  298.                 {
  299.                         if(count_k>=num)
  300.                         {
  301.                                  count_k=0;
  302.                                 k++;
  303.                                 if(k>=255)
  304.                                 {
  305.                                          count=9;
  306.                                 }
  307.                                 for(i=0;i<150;i++)
  308.                                 {
  309.                                         RGB_DATA[i]=0;
  310.                                         RGB_DATA[i+1]=k;
  311.                                         RGB_DATA[i+2]=k;
  312.                                         i++;i++;
  313.                                 }
  314.                         }
  315.                 }
  316.                 count_k++;
  317.                 break;
  318.                 case 9:
  319.                 {
  320.                         if(count_k>=num)
  321.                         {
  322.                                  count_k=0;
  323.                                 k++;
  324.                                 if(k>=255)
  325.                                 {
  326.                                          count=10;
  327.                                 }
  328.                                 for(i=0;i<150;i++)
  329.                                 {
  330.                                         RGB_DATA[i]=0;
  331.                                         RGB_DATA[i+1]=255-k;
  332.                                         RGB_DATA[i+2]=255-k;
  333.                                         i++;i++;
  334.                                 }
  335.                         }
  336.                 }
  337.                 count_k++;
  338.                 break;
  339.                 case 10:
  340.                 {
  341.                         if(count_k>=num)
  342.                         {
  343.                                  count_k=0;
  344.                                 k++;
  345.                                 if(k>=255)
  346.                                 {
  347.                                          count=11;
  348.                                 }
  349.                                 for(i=0;i<150;i++)
  350.                                 {
  351.                                         RGB_DATA[i]=k;
  352.                                         RGB_DATA[i+1]=0;
  353.                                         RGB_DATA[i+2]=k;
  354.                                         i++;i++;
  355.                                 }
  356.                         }
  357.                 }
  358.                 count_k++;
  359.                 break;
  360.                 case 11:
  361.                 {
  362.                         if(count_k>=num)
  363.                         {
  364.                                  count_k=0;
  365.                                 k++;
  366.                                 if(k>=255)
  367.                                 {
  368.                                          count=0;
  369.                                 }
  370.                                 for(i=0;i<150;i++)
  371.                                 {
  372.                                         RGB_DATA[i]=255-k;
  373.                                         RGB_DATA[i+1]=0;
  374.                                         RGB_DATA[i+2]=255-k;
  375.                                         i++;i++;
  376.                                 }
  377.                         }
  378.                 }
  379.                 count_k++;
  380.                 break;
  381.         }
  382. }

  383. void RGBZUO_YOU(u16 num)                                //7彩向左覆盖
  384. {
  385.         static u8 count=0;
  386.         static u16 count_k=0;
  387.         static u8 i,k,beijing=0;
  388.         if(count==0)
  389.         {
  390.                 if(count_k>=num)
  391.                 {
  392.                          count_k=0;
  393.                        
  394.                         for(i=0;i<150;i++)
  395.                         {       
  396.                                 if(i<k)
  397.                                 {
  398.                                         RGB_DATA[i]=255;
  399.                                 }
  400.                                 else
  401.                                 {
  402.                                          RGB_DATA[i]=0;
  403.                                 }
  404.                                 RGB_DATA[i+1]=0;
  405.                                 RGB_DATA[i+2]=beijing;
  406.                                 i++;i++;
  407.                         }
  408.                         k++;k++;k++;
  409.                         if(k>=150)
  410.                         {
  411.                                  count=1;
  412.                                 k=0;i=0;count_k=0;
  413.                                 beijing=255;
  414.                         }
  415.                 }
  416.                 count_k++;
  417.         }
  418.         if(count==1)
  419.         {
  420.                 if(count_k>=num)
  421.                 {
  422.                          count_k=0;
  423.                        
  424.                         for(i=0;i<150;i++)
  425.                         {       
  426.                                 if(i<k)
  427.                                 {
  428.                                         RGB_DATA[i+2]=0;
  429.                                 }
  430.                                 else
  431.                                 {
  432.                                          RGB_DATA[i+2]=255;
  433.                                 }
  434.                                 RGB_DATA[i]=255;
  435.                                 RGB_DATA[i+1]=0;
  436.                                 i++;i++;
  437.                         }
  438.                         k++;k++;k++;
  439.                         if(k>=150)
  440.                         {
  441.                                  count=2;
  442.                                 k=0;i=0;count_k=0;
  443.                                 beijing=255;
  444.                         }
  445.                 }
  446.                 count_k++;
  447.         }
  448.         if(count==2)
  449.         {
  450.                 if(count_k>=num)
  451.                 {
  452.                          count_k=0;
  453.                        
  454.                         for(i=0;i<150;i++)
  455.                         {       
  456.                                 if(i<k)
  457.                                 {
  458.                                         RGB_DATA[i+1]=255;
  459.                                 }
  460.                                 else
  461.                                 {
  462.                                          RGB_DATA[i+1]=0;
  463.                                 }
  464.                                 RGB_DATA[i]=beijing;
  465.                                 RGB_DATA[i+2]=0;
  466.                                 i++;i++;
  467.                         }
  468.                         k++;k++;k++;
  469.                         if(k>=150)
  470.                         {
  471.                                  count=3;
  472.                                 k=0;i=0;count_k=0;
  473.                                 beijing=255;
  474.                         }
  475.                 }
  476.                 count_k++;
  477.         }
  478.         if(count==3)
  479.         {
  480.                 if(count_k>=num)
  481.                 {
  482.                          count_k=0;
  483.                        
  484.                         for(i=0;i<150;i++)
  485.                         {       
  486.                                 if(i<k)
  487.                                 {
  488.                                         RGB_DATA[i]=0;
  489.                                 }
  490.                                 else
  491.                                 {
  492.                                          RGB_DATA[i]=255;
  493.                                 }
  494.                                 RGB_DATA[i+1]=255;
  495.                                 RGB_DATA[i+2]=0;
  496.                                 i++;i++;
  497.                         }
  498.                         k++;k++;k++;
  499.                         if(k>=150)
  500.                         {
  501.                                  count=4;
  502.                                 k=0;i=0;count_k=0;
  503.                                 beijing=255;
  504.                         }
  505.                 }
  506.                 count_k++;
  507.         }
  508.         if(count==4)
  509.         {
  510.                 if(count_k>=num)
  511.                 {
  512.                          count_k=0;
  513.                        
  514.                         for(i=0;i<150;i++)
  515.                         {       
  516.                                 if(i<k)
  517.                                 {
  518.                                         RGB_DATA[i+2]=255;
  519.                                 }
  520.                                 else
  521.                                 {
  522.                                          RGB_DATA[i+2]=0;
  523.                                 }
  524.                                 RGB_DATA[i]=0;
  525.                                 RGB_DATA[i+1]=beijing;
  526.                                 i++;i++;
  527.                         }
  528.                         k++;k++;k++;
  529.                         if(k>=150)
  530.                         {
  531.                                  count=5;
  532.                                 k=0;i=0;count_k=0;
  533.                                 beijing=255;
  534.                         }
  535.                 }
  536.                 count_k++;
  537.         }
  538.         if(count==5)
  539.         {
  540.                 if(count_k>=num)
  541.                 {
  542.                          count_k=0;
  543.                        
  544.                         for(i=0;i<150;i++)
  545.                         {       
  546.                                 if(i<k)
  547.                                 {
  548.                                         RGB_DATA[i+1]=0;
  549.                                 }
  550.                                 else
  551.                                 {
  552.                                          RGB_DATA[i+1]=255;
  553.                                 }
  554.                                 RGB_DATA[i]=0;
  555.                                 RGB_DATA[i+2]=beijing;
  556.                                 i++;i++;
  557.                         }
  558.                         k++;k++;k++;
  559.                         if(k>=150)
  560.                         {
  561.                                  count=0;
  562.                                 k=0;i=0;count_k=0;
  563.                                 beijing=255;
  564.                         }
  565.                 }
  566.                 count_k++;
  567.         }
  568.                
  569. }

  570. void  CLOCK_SELECT(u8 byte)
  571. {
  572.         switch(byte)
  573.         {
  574.                 case 0:        RGB_DATA[0]=0;RGB_DATA[1]=0;RGB_DATA[2]=0xff;break;               //r
  575.                 case 1:        RGB_DATA[0]=0;RGB_DATA[1]=0xff;RGB_DATA[2]=0;break;              //r
  576.                 case 2:        RGB_DATA[0]=0xff;RGB_DATA[1]=0;RGB_DATA[2]=0;break;             //r
  577.                 case 3:        RGB_DATA[0]=0;RGB_DATA[1]=0xff;RGB_DATA[2]=0xff;break;         //r
  578.                 case 4:        RGB_DATA[0]=0xff;RGB_DATA[1]=0xff;RGB_DATA[2]=0;break;        //r
  579.                 case 5:        RGB_DATA[0]=0xff;RGB_DATA[1]=0;RGB_DATA[2]=0xff;break;       //r
  580.                 case 6:        RGB_DATA[0]=0xff;RGB_DATA[1]=0xff;RGB_DATA[2]=0xff;break;   //r
  581.         }
  582. }
  583. void  SERVER_CLOCK(u32 delay)
  584. {
  585.         static u32 count=0;
  586.         u8 i,j=147;
  587.         if(count>=delay)
  588.         {       
  589.                 count=0;
  590.                 for(i=0;i<50;i++)
  591.                 {
  592.                                 RGB_DATA[j+3]=RGB_DATA[j];          //B  23-24   22-23
  593.                                 j-=1;
  594.                                 RGB_DATA[j+3]=RGB_DATA[j];     //G
  595.                                 j-=1;
  596.                                 RGB_DATA[j+3]=RGB_DATA[j];    //R
  597.                                 j-=1;
  598.                 }       
  599.                  MODE+=1;                 
  600.                  if(MODE>=7)
  601.                  {
  602.                          MODE=0;
  603.                  }
  604.                 CLOCK_SELECT(MODE);           //七彩颜色选择
  605.         }
  606.         count++;                                                                                       
  607. }
  608. void  SERVER_3SE(u32 delay)
  609. {       
  610.         static u32 count=0;
  611.         u8 i,j=120,k;   //72颗灯  9=3*3  其中3代表要移的灯数  加1是指向他的前面一个数
  612.         if(count>=delay)
  613.         {       
  614.                 count=0;
  615.                 for(k=0;k<9;k++)        //8*9=72颗
  616.                 {
  617.                         for(i=0;i<15;i++)
  618.                         {
  619.                                         RGB_DATA[i+j+15]=RGB_DATA[j+i];          //B  23-24   22-23       
  620.                         }       
  621.                         j-=15;  //指向上一个数组的头       
  622.                 }                 
  623.                  MODE+=1;                 
  624.                  if(MODE>=7)
  625.                  MODE=0;
  626.                 CLOCK_SELECT(MODE);           //七彩颜色选择       
  627.                 for(i=1;i<5;i++)
  628.                 {
  629.                         RGB_DATA[3*i+0]=RGB_DATA[0];
  630.                         RGB_DATA[3*i+1]=RGB_DATA[1];
  631.                         RGB_DATA[3*i+2]=RGB_DATA[2];       
  632.                 }
  633.         }
  634.         count++;
  635. }
  636. void  StackerGame(u32 delay)
  637. {
  638.         u8 i;
  639.         static u32 count=0;
  640.         if(count>=delay)
  641.         {       
  642.                 count=0;
  643.         for(i=0;i<3;i++)
  644.                 {                                
  645.                         if(num>=(150-GAME_NUM))
  646.                         {
  647.                 if(F_CLOCK==1)
  648.                                         MODE+=1;      //这部分是出七彩的效果  
  649.                                
  650.                                 if(MODE>=7)       //七到了之后就要出七彩
  651.                                         {
  652.                                                 MODE=0;
  653.                                                 F_CLOCK=1;
  654.                                         }

  655.                                 CLOCK_SELECT(MODE);                                               
  656.                             num=0;
  657.                             GAME_NUM+=3;         //执行这里说明转换一次完成 已经到尾         
  658.                           if(GAME_NUM==150)
  659.                                 {               
  660.                                     MODE+=1;
  661.                                         if(F_CLOCK==1)
  662.                                                 {
  663.                                                         F_CLOCK=0;
  664.                                                         MODE=0;
  665.                                                 }
  666.                                         GAME_NUM=0;
  667.                                         for(i=0;i<150;i++)
  668.                                                 {
  669.                                                         RGB_DATA[i]=0;  //清数据
  670.                                                 }
  671.                                         break;
  672.                                 }         
  673.                         }  
  674.                   RGB_DATA[num+3]=RGB_DATA[num];
  675.                   RGB_DATA[num]=0;                               
  676.                   num++;                            //交换数据
  677.            }
  678.         }count++;
  679. }
  680. void main()
  681. {
  682.         status_mode=0;
  683.         T0_Init();
  684.         while(1)
  685.         {
  686.                 switch (status_mode)
  687.                 {
  688.                         case 0:
  689.                         case 1:
  690.                         case 2:
  691.                         {
  692.                                 RGB_7_SE_MAN();
  693.                         }
  694.                         break;
  695.                         case 3:
  696.                         case 4:
  697.                         case 5:
  698.                         case 6:
  699.                         {
  700.                                 RGB_7_SE_BIAN(2000);//2000);
  701.                         }
  702.                         break;       
  703.                         case 7:
  704.                         case 8:
  705.                         case 9:
  706.                         case 10:
  707.                         {
  708.                                 SERVER_CLOCK(100000);
  709.                         }
  710.                         break;
  711.                         case 11:
  712.                         case 12:
  713.                         case 13:
  714.                         case 14:
  715.                         {
  716.                                 RGBZUO_YOU(10000);
  717.                         }
  718.                         break;
  719.                         case 15:
  720.                         case 16:
  721.                         case 17:
  722.                         case 18:
  723.                         {
  724.                                 SERVER_CLOCK(100000);
  725.                         }
  726.                         break;
  727.                         case 19:
  728.                         case 20:
  729.                         case 21:
  730.                         case 22:
  731.                         {
  732.                                 SERVER_3SE(300000);
  733.                         }break;       
  734.                         case 23:
  735.                         case 24:
  736.                         case 25:
  737.                         case 26:
  738.                         case 27:
  739.                         case 28:
  740.                         case 29:
  741.                         case 30:
  742.                         case 31:
  743.                         case 32:
  744.                         case 33:
  745.                         case 34:
  746.                         case 35:
  747.                         case 36:
  748.                         case 37:
  749.                         case 38:
  750.                         {
  751.                                 StackerGame(4470);
  752.                         }
  753.                         break;       
  754.                 }
  755.         }
  756. }
复制代码



LED驱动WS2801.rar (809.38 KB, 下载次数: 59)
回复

使用道具 举报

ID:541161 发表于 2019-5-18 09:44 | 显示全部楼层
这个 原件在那个仿真软件可以找到
回复

使用道具 举报

ID:21069 发表于 2019-5-18 15:57 | 显示全部楼层
这个蛮实用,仿真也很是那么回事,不过51就只能看看了,实物最少要24M才能运行
回复

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表