设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › WS2811灯光系统单片机程序 22路全彩控制器
返回列表 发新帖
查看: 9849|回复: 18
打印 上一主题 下一主题
收起左侧

WS2811灯光系统单片机程序 22路全彩控制器

  [复制链接]
跳转到指定楼层
楼主
ID:128799 发表于 2016-7-1 12:07 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
WS2811灯光程序，单片机22路全彩控制器.
1、从左往右扫
2、从右往左扫
3、从中间向两边扫
4、从两边向中间扫
单片机源程序如下:
  1. #include "includes.h"
  2. //T_POINT idata szPoint[20];

  4. #if 0
  5.                 DelayN10ms(100);
  6.                 pt.r=10;pt.g=0,pt.b=0;
  7.                 memcpy(&szPoint[0],&pt,sizeof(T_POINT));
  8.                 pt.r=0;pt.g=10,pt.b=0;
  9.                 memcpy(&szPoint[1],&pt,sizeof(T_POINT));
  10.                 pt.r=0;pt.g=0,pt.b=10;
  11.                 memcpy(&szPoint[2],&pt,sizeof(T_POINT));
  12.                 WS2811_Setout(&szPoint,3);
  13. #endif


  16. T_POINT code Design2[]=
  17. {
  18. #if 1
  19.         {255,0,42},
  20.         {255,0,78},
  21.         {255,0,184},
  22.         {248,0,255},
  23.         {177,0,255},

  25.         {71,0,255},
  26.         {0,42,255},
  27.         {0,113,255},
  28.         {0,184,255},
  29.         {0,220,255},

  31.         {0,255,255},
  32.         {0,255,213},
  33.         {0,255,142},
  34.         {78,255,71},
  35.         {149,255,0},

  37.         {220,255,0},
  38.         {255,213,0},
  39.         {255,177,0},
  40.         {255,71,0},
  41.         {255,0,0},
  42. #else
  43.         {10,0,0},
  44.         {0,10,0},
  45.         {0,0,10},
  46.         {10,0,0},
  47.         {0,10,0},
  48.         {0,0,10},
  49.         {10,0,0},
  50.         {0,10,0},
  51.         {0,0,10},
  52.         {10,0,0},
  53.         {0,10,0},
  54.         {0,0,10},
  55.         {10,0,0},
  56.         {0,10,0},
  57.         {0,0,10},
  58.         {10,0,0},
  59.         {0,10,0},
  60.         {0,0,10},
  61.         {10,0,0},
  62.         {0,10,0},

  64. #endif
  65. };

  67. T_POINT code Design[]=
  68. {
  69.         {255,0,0},
  70.         {255,0,10},
  71.         {255,0,20},
  72.         {255,0,30},
  73.         {255,0,42},
  74.         {255,0,50},
  75.         {255,0,58},
  76.         {255,0,66},
  77.         {255,0,72},
  78.         {255,0,78},
  79.         {255,0,90},
  80.         {255,0,110},
  81.         {255,0,130},
  82.         {255,0,150},
  83.         {255,0,184},
  84.         {245,0,200},
  85.         {230,0,215},
  86.         {222,0,230},
  87.         {200,0,238},
  88.         {190,0,245},
  89.         {177,0,255},
  90.         {160,0,255},
  91.         {140,0,255},
  92.         {130,0,255},
  93.         {120,0,255},
  94.         {110,0,255},
  95.         {100,0,255},
  96.         {95,0,255},
  97.         {85,0,255},
  98.         {71,0,255},
  99.         {56,8,255},
  100.         {40,16,255},
  101.         {30,24,255},
  102.         {20,32,255},
  103.         {10,36,255},
  104.         {0,42,255},
  105.         {0,57,255},
  106.         {0,72,255},
  107.         {0,87,255},
  108.         {0,95,255},
  109.         {0,98,255},
  110.         {0,102,255},
  111.         {0,113,255},
  112.         {0,184,255},
  113.         {0,190,255},
  114.         {0,200,255},
  115.         {0,210,255},
  116.         {0,220,255},
  117.         {0,230,255},
  118.         {0,240,255},
  119.         {0,255,255},
  120.         {0,255,245},
  121.         {0,255,235},
  122.         {0,255,225},
  123.         {0,255,215},
  124.         {0,255,200},
  125.         {0,255,190},
  126.         {0,255,180},
  127.         {0,255,170},
  128.         {10,255,160},
  129.         {20,255,150},
  130.         {30,255,140},
  131.         {40,255,130},
  132.         {50,255,120},
  133.         {60,255,110},
  134.         {70,255,100},
  135.         {78,255,90},
  136.         {90,255,80},
  137.         {95,255,71},
  138.         {100,255,60},
  139.         {105,255,50},
  140.         {110,255,40},
  141.         {120,255,30},
  142.         {130,255,20},
  143.         {140,255,10},
  144.         {149,255,0},
  145.         {160,255,0},
  146.         {170,255,0},
  147.         {180,255,0},
  148.         {190,255,0},
  149.         {200,255,0},
  150.         {210,255,0},
  151.         {220,255,0},
  152.         {230,245,0},
  153.         {240,235,0},
  154.         {245,225,0},
  155.         {255,213,0},
  156.         {255,208,0},
  157.         {255,200,0},
  158.         {255,190,0},
  159.         {255,180,0},
  160.         {255,177,0},
  161.         {255,170,0},
  162.         {255,160,0},
  163.         {255,150,0},
  164.         {255,140,0},
  165.         {255,130,0},
  166.         {255,120,0},
  167.         {255,110,0},
  168.         {255,100,0},
  169.         {255,90,0},
  170.         {255,80,0},
  171.         {255,75,0},
  172.         {255,60,0},
  173.         {255,50,0},
  174.         {255,40,0},
  175.         {255,30,0},
  176.         {255,20,0},
  177.         {255,10,0},
  178.         {255,0,0},
  179. };
  180. void WS2811_Setout2(int index)
  181. {//748
  182.         int k=10;
  183.         uchar cnt=0;
  184.         while(1)
  185.         {
  186.                 WS2811_SendByte(Design[index].r);
  187.                 WS2811_SendByte(Design[index].b);
  188.                 WS2811_SendByte(Design[index].g);
  189.                 index++;
  190.                 if(index==110)
  191.                 {
  192.                         index=0;
  193.                 }
  194.                 if(++cnt==110)
  195.                 {
  196.                         break;
  197.                 }
  198.         }
  199.         IO_DIN=1;
  200.         IO_DIN=0;
  201.         while(k--)
  202.         {
  203.                 _nop_();               
  204.         }
  205. }
  206. void WS2811_Setout4(int index)
  207. {//748
  208.         int k=10;
  209.         uchar cnt=0;
  210.         while(1)
  211.         {
  212.                 WS2811_SendByte(Design[index].r);
  213.                 WS2811_SendByte(Design[index].b);
  214.                 WS2811_SendByte(Design[index].g);
  215.                 index+=2;
  216.                 if(index>=110)
  217.                 {
  218.                         index=0;
  219.                 }
  220.                 if(++cnt==55)
  221.                 {
  222.                         break;
  223.                 }
  224.         }
  225.         cnt=0;
  226.         while(1)
  227.         {
  228.                 WS2811_SendByte(Design[index].r);
  229.                 WS2811_SendByte(Design[index].b);
  230.                 WS2811_SendByte(Design[index].g);
  231.                 index-=2;
  232.                 if(index<0)
  233.                 {
  234.                         index=109;
  235.                 }
  236.                 if(++cnt==55)
  237.                 {
  238.                         break;
  239.                 }
  240.         }
  241.         IO_DIN=1;
  242.         IO_DIN=0;
  243.         while(k--)
  244.         {
  245.                 _nop_();               
  246.         }
  247. }

  249. void WS2811_Setout3(int index)
  250. {//748
  251.         int k=10;
  252.         uchar cnt=0,n;
  253.        
  254. //        while(1)
  255.         {
  256.                 //----------------
  257.                 for(n=0;n<4;n++)
  258.                 {
  259.                         WS2811_SendByte(Design2[index].r);
  260.                         WS2811_SendByte(Design2[index].b);
  261.                         WS2811_SendByte(Design2[index].g);
  262.                 }
  263.                 if(++index==20)
  264.                 {
  265.                         index=0;
  266.                 }
  267.                 //----------------
  268.                 for(n=0;n<4;n++)
  269.                 {
  270.                         WS2811_SendByte(Design2[index].r);
  271.                         WS2811_SendByte(Design2[index].b);
  272.                         WS2811_SendByte(Design2[index].g);
  273.                 }
  274.                 if(++index==20)
  275.                 {
  276.                         index=0;
  277.                 }
  278.                 //----------------
  279.                 for(n=0;n<3;n++)
  280.                 {
  281.                         WS2811_SendByte(Design2[index].r);
  282.                         WS2811_SendByte(Design2[index].b);
  283.                         WS2811_SendByte(Design2[index].g);
  284.                 }
  285.                 if(++index==20)
  286.                 {
  287.                         index=0;
  288.                 }
  289.                 //----------------
  290.                 for(n=0;n<3;n++)
  291.                 {
  292.                         WS2811_SendByte(Design2[index].r);
  293.                         WS2811_SendByte(Design2[index].b);
  294.                         WS2811_SendByte(Design2[index].g);
  295.                 }
  296.                 if(++index==20)
  297.                 {
  298.                         index=0;
  299.                 }
  300.                 //----------------
  301.                 for(n=0;n<3;n++)
  302.                 {
  303.                         WS2811_SendByte(Design2[index].r);
  304.                         WS2811_SendByte(Design2[index].b);
  305.                         WS2811_SendByte(Design2[index].g);
  306.                 }
  307.                 if(++index==20)
  308.                 {
  309.                         index=0;
  310.                 }
  311.                 //----------------
  312.                 for(n=0;n<2;n++)
  313.                 {
  314.                         WS2811_SendByte(Design2[index].r);
  315.                         WS2811_SendByte(Design2[index].b);
  316.                         WS2811_SendByte(Design2[index].g);
  317.                 }
  318.                 if(++index==20)
  319.                 {
  320.                         index=0;
  321.                 }
  322.                 //----------------
  323.                 for(n=0;n<2;n++)
  324.                 {
  325.                         WS2811_SendByte(Design2[index].r);
  326.                         WS2811_SendByte(Design2[index].b);
  327.                         WS2811_SendByte(Design2[index].g);
  328.                 }
  329.                 if(++index==20)
  330.                 {
  331.                         index=0;
  332.                 }
  333.                 //----------------
  334.                 for(n=0;n<2;n++)
  335.                 {
  336.                         WS2811_SendByte(Design2[index].r);
  337.                         WS2811_SendByte(Design2[index].b);
  338.                         WS2811_SendByte(Design2[index].g);
  339.                 }
  340.                 if(++index==20)
  341.                 {
  342.                         index=0;
  343.                 }
  344.                 //----------------
  345.                 for(n=0;n<2;n++)
  346.                 {
  347.                         WS2811_SendByte(Design2[index].r);
  348.                         WS2811_SendByte(Design2[index].b);
  349.                         WS2811_SendByte(Design2[index].g);
  350.                 }
  351.                 if(++index==20)
  352.                 {
  353.                         index=0;
  354.                 }
  355.                 //----------------
  356.                 for(n=0;n<2;n++)
  357.                 {
  358.                         WS2811_SendByte(Design2[index].r);
  359.                         WS2811_SendByte(Design2[index].b);
  360.                         WS2811_SendByte(Design2[index].g);
  361.                 }
  362.                 if(++index==20)
  363.                 {
  364.                         index=0;
  365.                 }
  366.                 //----------------
  367.                 for(n=0;n<2;n++)
  368.                 {
  369.                         WS2811_SendByte(Design2[index].r);
  370.                         WS2811_SendByte(Design2[index].b);
  371.                         WS2811_SendByte(Design2[index].g);
  372.                 }
  373.                 if(++index==20)
  374.                 {
  375.                         index=0;
  376.                 }
  377.                 //----------------
  378.                 for(n=0;n<2;n++)
  379.                 {
  380.                         WS2811_SendByte(Design2[index].r);
  381.                         WS2811_SendByte(Design2[index].b);
  382.                         WS2811_SendByte(Design2[index].g);
  383.                 }
  384.                 if(++index==20)
  385.                 {
  386.                         index=0;
  387.                 }
  388.                 //----------------
  389.                 for(n=0;n<5;n++)
  390.                 {
  391.                         WS2811_SendByte(Design2[index].r);
  392.                         WS2811_SendByte(Design2[index].b);
  393.                         WS2811_SendByte(Design2[index].g);
  394.                 }
  395.                 if(++index==20)
  396.                 {
  397.                         index=0;
  398.                 }
  399.                 //----------------
  400.                 for(n=0;n<8;n++)
  401.                 {
  402.                         WS2811_SendByte(Design2[index].r);
  403.                         WS2811_SendByte(Design2[index].b);
  404.                         WS2811_SendByte(Design2[index].g);
  405.                 }
  406.                 if(++index==20)
  407.                 {
  408.                         index=0;
  409.                 }
  410.                 //----------------
  411.                 for(n=0;n<7;n++)
  412.                 {
  413.                         WS2811_SendByte(Design2[index].r);
  414.                         WS2811_SendByte(Design2[index].b);
  415.                         WS2811_SendByte(Design2[index].g);
  416.                 }
  417.                 if(++index==20)
  418.                 {
  419.                         index=0;
  420.                 }
  421.                 //----------------
  422.                 for(n=0;n<7;n++)
  423.                 {
  424.                         WS2811_SendByte(Design2[index].r);
  425.                         WS2811_SendByte(Design2[index].b);
  426.                         WS2811_SendByte(Design2[index].g);
  427.                 }
  428.                 if(++index==20)
  429.                 {
  430.                         index=0;
  431.                 }
  432.                 //----------------
  433.                 for(n=0;n<5;n++)
  434.                 {
  435.                         WS2811_SendByte(Design2[index].r);
  436.                         WS2811_SendByte(Design2[index].b);
  437.                         WS2811_SendByte(Design2[index].g);
  438.                 }
  439.                 if(++index==20)
  440.                 {
  441.                         index=0;
  442.                 }
  443.                 //----------------
  444.                 for(n=0;n<4;n++)
  445.                 {
  446.                         WS2811_SendByte(Design2[index].r);
  447.                         WS2811_SendByte(Design2[index].b);
  448.                         WS2811_SendByte(Design2[index].g);
  449.                 }
  450.                 if(++index==20)
  451.                 {
  452.                         index=0;
  453.                 }
  454.                 //----------------
  455.                 for(n=0;n<3;n++)
  456.                 {
  457.                         WS2811_SendByte(Design2[index].r);
  458.                         WS2811_SendByte(Design2[index].b);
  459.                         WS2811_SendByte(Design2[index].g);
  460.                 }
  461.                 if(++index==20)
  462.                 {
  463.                         index=0;
  464.                 }
  465.                 //----------------
  466.                 //for(n=0;n<1;n++)
  467.                 {
  468.                         WS2811_SendByte(Design2[index].r);
  469.                         WS2811_SendByte(Design2[index].b);
  470.                         WS2811_SendByte(Design2[index].g);
  471.                 }



  475.         }
  476.         IO_DIN=1;
  477.         IO_DIN=0;
  478.         while(k--)
  479.         {
  480.                 _nop_();               
  481.         }
  482. }

  484. ucharc SPEED1[]={10,8, 6, 4,2,0};
  485. ucharc SPEED[]= {20,15,10,6,2,0};
  486. void main(void)
  487. {
  488.         int ind=19;
  489.         uchar cnt;
  490.     Init_Data();                // 初始化各种端口和数据
  491.     while(1)
  492.     {
  493. #if 1
  494. /*
  495. 1、从左往右扫
  496. 2、从右往左扫
  497. 3、从中间向两边扫
  498. 4、从两边向中间扫
  499. */
  500.                 for(cnt=0;cnt<3;cnt++)
  501.                 {
  502.                         for(ind=0;ind<110;ind++)
  503.                         {
  504.                                 WS2811_Setout2(ind);
  505.                                 DelayN10ms(SPEED1[gSpeed]);
  506.                         }
  507.                 }
  508.                 for(cnt=0;cnt<3;cnt++)
  509.                 {
  510.                         for(ind=109;ind>=0;ind--)
  511.                         {
  512.                                 WS2811_Setout2(ind);
  513.                                 DelayN10ms(SPEED1[gSpeed]);
  514.                         }
  515.                 }
  516.                 //33333333333
  517.                 for(cnt=0;cnt<3;cnt++)
  518.                 { //3.从55-110-1-54扫描
  519.                         for(ind=55;ind<110;ind++)
  520.                         {
  521.                                 WS2811_Setout2(ind);
  522.                                 DelayN10ms(SPEED1[gSpeed]);
  523.                         }
  524.                         for(ind=0;ind<55;ind++)
  525.                         {
  526.                                 WS2811_Setout2(ind);
  527.                                 DelayN10ms(SPEED1[gSpeed]);
  528.                         }
  529.                 }
  530.                 //444444444444444
  531.                 for(cnt=0;cnt<3;cnt++)
  532.                 {  //4.从54-1-110-55扫描
  533.                         for(ind=54;ind>=0;ind--)
  534.                         {
  535. ……………………

  537. …………限于本文篇幅 余下代码请从51黑下载附件…………
复制代码




源码下载：
WS2811_LEDs.zip.7z (37.95 KB, 下载次数: 305)
自行车

评分

参与人数 3黑币 +60 收起 理由
b2329164 + 5 很给力！
zlscom + 5 赞一个！
admin + 50 共享资料的黑币奖励！

查看全部评分

分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏9 分享淘帖 顶顶2 踩踩

相关帖子
回复

使用道具 举报

沙发
ID:89286 发表于 2017-1-4 21:22 | 只看该作者
Thanks for sharing, i like it
回复

使用道具 举报

板凳
ID:196720 发表于 2017-5-4 22:30 | 只看该作者
刚好需要，正在学单片机呢。谢谢分享
回复

使用道具 举报

地板
ID:194871 发表于 2017-5-4 23:13 | 只看该作者
谢谢分享
回复

使用道具 举报

5#
ID:208818 发表于 2017-6-8 15:14 | 只看该作者
谢谢楼主
回复

使用道具 举报

6#
ID:212044 发表于 2017-6-17 12:18 | 只看该作者
交流一下好嘛
回复

使用道具 举报

7#
ID:212044 发表于 2017-6-17 12:39 | 只看该作者
黑币不够，非常想下载这个资源，求通过
回复

使用道具 举报

8#
ID:231659 发表于 2017-9-7 14:26 | 只看该作者
謝大大分享 剛好正在使用
回复

使用道具 举报

9#
ID:252372 发表于 2017-11-23 16:50 | 只看该作者
LZ是用的，延时的方式还是PWM输出的方式控制？
回复

使用道具 举报

10#
ID:262595 发表于 2017-12-17 19:21 | 只看该作者
可以很强
回复

使用道具 举报

11#
ID:289056 发表于 2018-3-8 10:32 | 只看该作者
开始学习了
回复

使用道具 举报

12#
ID:161115 发表于 2018-4-18 13:43 | 只看该作者
好好学习一下，感谢楼主无私的分享！
回复

使用道具 举报

13#
ID:270200 发表于 2018-4-23 13:36 | 只看该作者
给力，下载看看
回复

使用道具 举报

14#
ID:270200 发表于 2018-4-23 13:38 | 只看该作者

学习一下感谢楼主无私的分享！
回复

使用道具 举报

15#
ID:202754 发表于 2018-6-29 14:56 | 只看该作者


学习一下感谢楼主无私的分享！
回复

使用道具 举报

16#
ID:578093 发表于 2019-7-4 20:09 | 只看该作者
正在学习这个IC的用法 赞一个！
回复

使用道具 举报

17#
ID:712612 发表于 2020-3-29 23:27 | 只看该作者
Thanks for sharing, i like it
回复

使用道具 举报

18#
ID:249416 发表于 2023-9-18 22:59 | 只看该作者
谢谢坛主。学习了。
回复

使用道具 举报

19#
ID:433219 发表于 2023-9-19 14:00 | 只看该作者
  一路多少颗灯珠？
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

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

Powered by 单片机教程网

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