介绍一款单总线智能RGB LED WS2812B

thorn · 发表于 2016-4-19 22:30:47

很有意思的国产货，原本用于灯带、光彩工程用途；个人拿来做点小玩意还是不错的
5050封装，芯片与全彩LEG封装在一起，只用4个引脚，两电源脚一个数据输入DIN 一个数据输出DO
每一只芯片为一个全彩“像素“，各个像素头尾相接，DIN端接受从控制器传输过来的数据，前24bit数据被第一个像素点提取后，送到像素点内部的数据锁存器，剩余的数据经过内部整形处理电路整形放大后通过DO端口开始转发输出给下一个级联的像素点，每经过一个像素点的传输，信号减少24bit，一路传递下去

内置信号整形电路，任何一个像素点收到信号后经过波形整形再输出，保证线路波形畸变不会累加
内置上电复位和掉电复位电路。每个像素点的三基色颜色可实现256级亮度显示，完成16777216种颜色的全真色彩显示
串行级联接口，能通过一根信号线完成数据的接收与解码
任意两点传传输距离在不超过3米时无需增加任何电路。（实测10M Cat5e传输信号可正常工作）
datasheet：

pazulin · 发表于 2016-4-19 23:15:16

taobao有产品吗？

dzrs0620 · 发表于 2016-4-19 23:21:41

好像上次有一个说实现了流水灯却无法实现呼吸灯的帖子也提到了这个LED，淘宝价5毛左右，对于要在一个点实现多种色彩显示的应用也有很高的性价比……

Q男 · 发表于 2016-4-20 00:58:26

我可以说以前有一段时间画这个的板子画到吐了吗?

这个玩意我也做过简单的demo驱动,用的MEGA8.

开发的时候必须要示波器,时序要求挺严格的.....

友提:正脉宽略微宽一些,有助于远距离的传输....

嵌入汇编吧,程序的调用周期需要考虑的.....

Q男 · 发表于 2016-4-20 01:05:43

就是从这个玩意开始，
我养成了开大buffer的习惯。
计算数据，关中断，发数据，开中断，处理其它事情。

这玩意发送数据的时候，必须关中断。

为了一个红外接收头的响应，
甚至不得不采用双核……
囧

zyw19987 · 发表于 2016-4-20 05:20:49

Q男发表于 2016-4-20 01:05
就是从这个玩意开始，
我养成了开大buffer的习惯。
计算数据，关中断，发数据，开中断，处理其它事情。

灯条很长的时候，关中断会造成红外接收不行啊，用STM8S003做没弄好。期待你例程

Q男 · 发表于 2016-4-20 07:54:18

zeroXone 发表于 2016-4-20 01:22
用带DMA的UART或者SPI就行了，调节UART或SPI的分频做好好时序，没必要控制中断，STM32都带DMA，比较好控 ...

这个玩意的时序是靠占空比来决定发送的数据是1还是0，或者是复位通讯接口的。

所以DMA.SPI根本不行的

Q男 · 发表于 2016-4-20 07:58:24

zyw19987 发表于 2016-4-20 05:20
灯条很长的时候，关中断会造成红外接收不行啊，用STM8S003做没弄好。期待你例程 ...

双核，用两片003，一片负责专门发数据，另外一片负责接收红外。红外接收解码成功之后，用io口通知。

这样只是给人的感觉会慢一些，但是不会按键失灵的感觉

这个是我当时能够想到的最好方法了。

huangqi412 · 发表于 2016-4-20 08:01:35

Q男发表于 2016-4-20 00:58
我可以说以前有一段时间画这个的板子画到吐了吗?

这个玩意我也做过简单的demo驱动,用的MEGA8.

两个m8？果然双核

huangqi412 · 发表于 2016-4-20 08:06:53

Q男发表于 2016-4-20 07:58
双核，用两片003，一片负责专门发数据，另外一片负责接收红外。红外接收解码成功之后，用io口通知。

这 ...

。。。spi不像串口有前导和结束位是纯数据只要你选择合适波特率就能发自己脉冲极端情况我把波特率提高10倍行不行然后发ff和00 相当高采样率实际往往能设计成一个字节发多于一个脉冲

xwkm · 发表于 2016-4-20 08:13:14

Q男发表于 2016-4-20 07:58
双核，用两片003，一片负责专门发数据，另外一片负责接收红外。红外接收解码成功之后，用io口通知。

这 ...

SPI完全可以,因为不像串口有前导/停止位.可以用特殊的数据构造出来正确的时序.某些机器的串口也可以这么用.

AllEle · 发表于 2016-4-20 08:17:26

这个对时序要求高

Q男 · 发表于 2016-4-20 08:28:13

本帖最后由 Q男于 2016-4-20 08:35 编辑

特殊处理过的DMA/SPI确实可以模拟一些时序，这个的负脉宽时间是0.4uS，正脉宽是0.85uS，反过来就是另外一个bit。

数据×10以后，RAM就有点悬了，正常512个灯需要1.5K的RAM，数据翻倍之后就需要15K，很多低端的MCU根本没那么多。

再说两片003要比一片stm32便宜。

Shaopus · 发表于 2016-4-20 08:33:33

分享下 http://www.amobbs.com/thread-5646991-1-1.html

mii · 发表于 2016-4-20 08:43:52

这玩意采用单线归零编码的方式，我用stm32的PWM，DMA驱动成功，然后调试过程发现发送变换颜色时会有闪烁。最终找到问题是这个刷新频率不能低于400Khz。然后再开一个定时器2MS刷新一次。。就正常了

zqf441775525 · 发表于 2016-4-20 08:53:34

Q男发表于 2016-4-20 07:54
这个玩意的时序是靠占空比来决定发送的数据是1还是0，或者是复位通讯接口的。

所以DMA.SPI根本不行的 ...

WS2811，WS2812这种芯片我都是用DMA+SPI驱动的，很爽，就是比较占RAM，用一个字节表示一位，所以一个全彩灯需要占24字节。

xwkm · 发表于 2016-4-20 09:09:35

Q男发表于 2016-4-20 08:28
特殊处理过的DMA/SPI确实可以模拟一些时序，这个的负脉宽时间是0.4uS，正脉宽是0.85uS，反过来就是另外一个 ...

所以没有必要把整个FB都直接调制成数据。少一些，分次转换发送就可以

xwkm · 发表于 2016-4-20 09:33:48

zqf441775525 发表于 2016-4-20 08:53
WS2811，WS2812这种芯片我都是用DMA+SPI驱动的，很爽，就是比较占RAM，用一个字节表示一位，所以一个全彩 ...

其实可以变通一下.每个周期1.25us,高0.4低0.85.使用3bit编码一个字节刚好卡在点上.就是转换麻烦点.

Q男 · 发表于 2016-4-20 09:46:38

xwkm 发表于 2016-4-20 09:09
所以没有必要把整个FB都直接调制成数据。少一些，分次转换发送就可以

不行的，不能够分次刷。

一次性必须刷完整个灯条，否则时序就会错乱。

这个就是依次移位的处理，错一个比特都不行。

tj7856 · 发表于 2016-4-20 09:47:01

顶收藏了

zqf441775525 · 发表于 2016-4-20 09:59:43

xwkm 发表于 2016-4-20 09:33
其实可以变通一下.每个周期1.25us,高0.4低0.85.使用3bit编码一个字节刚好卡在点上.就是转换麻烦点. ...

嗯，有道理，但是这样做转换起来太麻烦了，但是在RAM紧张的情况下可以考虑这么用。

jingmeidz · 发表于 2016-4-20 10:09:33

这类芯片非常多了，这个芯片也是山寨的，比较早出的是天微

zyw19987 · 发表于 2016-4-20 10:20:06

Q男发表于 2016-4-20 07:58
双核，用两片003，一片负责专门发数据，另外一片负责接收红外。红外接收解码成功之后，用io口通知。

这 ...

我手上有别人的样板，就一个003感觉交互很好哦。
是不是我们有什么资源没有利用起来。

Q男 · 发表于 2016-4-20 10:37:34

zyw19987 发表于 2016-4-20 10:20
我手上有别人的样板，就一个003感觉交互很好哦。
是不是我们有什么资源没有利用起来。 ...

不知道，我当时的需求是只用mega8做一个发送的demo，用按键来改花样。

后期的其他事情没有跟进的，只是一个构想建议。

或许发送的过程中，有汇编来插入检测红外。

blue1025 · 发表于 2016-4-20 12:22:53

这颗芯片原先做过，这个有量吗，这个芯片好处就是可以直接接24V电压，那个sdi->sdo，有内部整形，可以传很远。

huangqi412 · 发表于 2016-4-20 12:41:06

Q男发表于 2016-4-20 08:28
特殊处理过的DMA/SPI确实可以模拟一些时序，这个的负脉宽时间是0.4uS，正脉宽是0.85uS，反过来就是另外一个 ...

将原始数据切割分块处理内存就少了比如每10个原始数据转换一次码流 stm32可能确实贵了如果再找找别的呢比如新塘 gd. 或者什么的 2块钱一下的m0 肯定有

huangqi412 · 发表于 2016-4-20 12:53:28

Q男发表于 2016-4-20 09:46
不行的，不能够分次刷。

一次性必须刷完整个灯条，否则时序就会错乱。

如果这样好像是不好处理主频没高到切换一次dma设置的时间可以完全忽略

xwkm · 发表于 2016-4-20 13:07:48

Q男发表于 2016-4-20 09:46
不行的，不能够分次刷。

一次性必须刷完整个灯条，否则时序就会错乱。

reset信号是50us。DMA传输完成后，10us都足够转换了

aozima · 发表于 2016-5-21 17:15:30

zqf441775525 发表于 2016-4-20 08:53
WS2811，WS2812这种芯片我都是用DMA+SPI驱动的，很爽，就是比较占RAM，用一个字节表示一位，所以一个全彩 ...

SPI的时钟多少合适？
逻辑0和1的高低电平比例是1:2，而SPI一般是8位，那么转换成SPI的数据对应是什么样的？

zqf441775525 · 发表于 2016-5-21 20:03:32

aozima 发表于 2016-5-21 17:15
SPI的时钟多少合适？
逻辑0和1的高低电平比例是1:2，而SPI一般是8位，那么转换成SPI的数据对应是什么样的 ...

1:3也可以的，SPI的时钟要看是高速还是低速。我倒是没注意SPI怎么设置的，用示波器看下脉宽，就差不多了。

qqtfh · 发表于 2016-5-21 22:19:38

哪有卖？

liaihua1997 · 发表于 2016-5-22 11:19:33

不错的，芯片，还不会用

joiway · 发表于 2016-11-1 18:52:46

收藏并学习，多谢分享！

jackiezeng · 发表于 2016-11-1 19:52:55

真是个好东西，以前想做一个全彩的摇摇棒，板子都画不出来，，，，现在这个应该很轻松就搞定了，

wmdng · 发表于 2016-11-2 16:29:42

标记一下, rgb 串行三色 LED.

daleda · 发表于 2016-11-2 16:42:14

东西不错，收藏备用

一夕nandy · 发表于 2016-11-2 22:22:45

mark 用个LED显示多种信息也是不错的

wkman · 发表于 2016-11-3 09:05:49

流星灯和呼吸灯啊，

clesun · 发表于 2017-10-18 12:45:13

zqf441775525 发表于 2016-4-20 08:53
WS2811，WS2812这种芯片我都是用DMA+SPI驱动的，很爽，就是比较占RAM，用一个字节表示一位，所以一个全彩 ...

有没有例程,有个需求是RGB点阵，上午还头疼怎么安装，用这种就很简单了，

zqf441775525 · 发表于 2017-10-18 14:10:20

clesun 发表于 2017-10-18 12:45
有没有例程,有个需求是RGB点阵，上午还头疼怎么安装，用这种就很简单了， ...

没找到怎么上传文件，就把代码复制过来吧

typedef struct
{
u8 red;
u8 green;
u8 blue;
}_Pixel;

/****************************************************************
WS2811驱动函数
使用资源：SPI1，DMA1_Channel3，一定数量的RAM
使用方法：
主函数中先调用LED_SPI_LowLevel_Init()对SPI、DMA和GPIO进行初始化
先宏定义LED灯的总个数LED_ALL_Num，再给每个灯的 red，green，blue 三个变量赋值，然后LED_SPI_Update()，即可。
*****************************************************************/
#include "includes.h"
#include "WS2811.h"
#include "stm32f10x_spi.h"
#include "stm32f10x_dma.h"
_Pixel Pixel[LED_ALL_Num];
#define Buffer_ALL_Num (LED_ALL_Num * 24 + 21)
u8 PixelBuffer[Buffer_ALL_Num] = {0};
u16 PixelPointer = 0;
static void SPI_DMA_Init(void)
{
DMA_InitTypeDef DMA_InitStructure;
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);
DMA_DeInit(DMA1_Channel3);
DMA_InitStructure.DMA_BufferSize = Buffer_ALL_Num;
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t) & (SPI1->DR);
DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)PixelBuffer;
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;
DMA_InitStructure.DMA_Priority = DMA_Priority_Low;
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
DMA_InitStructure.DMA_MemoryDataSize = DMA_PeripheralDataSize_Byte;
DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
DMA_InitStructure.DMA_Priority = DMA_Priority_VeryHigh;
DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
DMA_Init(DMA1_Channel3, &DMA_InitStructure); /* DMA1 CH3 = MEM -> DR */
DMA_Cmd(DMA1_Channel3, ENABLE);
}
void LED_SPI_LowLevel_Init(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
SPI_InitTypeDef SPI_InitStructure;
SPI_DMA_Init();
RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1|RCC_APB2Periph_GPIOA, ENABLE);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5;
GPIO_Init(GPIOA, &GPIO_InitStructure);
SPI_I2S_DeInit(SPI1);
SPI_InitStructure.SPI_Direction = SPI_Direction_1Line_Tx;
SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;
SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;
SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_16;
SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
SPI_InitStructure.SPI_CRCPolynomial = 7;
SPI_Init(SPI1, &SPI_InitStructure);
SPI_I2S_DMACmd(SPI1, SPI_I2S_DMAReq_Tx, ENABLE);
SPI_Cmd(SPI1, ENABLE);
}
static void WS2811_SPI_WriteByte(u16 Data)
{
PixelBuffer[PixelPointer] = Data;
PixelPointer ++;
}
static void WS2811_SPI_SendBits(u8 Bits)
{
u8 Zero = 0xc0; //11000000
u8 One = 0xfc; //11111100
u16 i = 0;
for(i = 0x80;i >= 0x01;i >>= 1)
{
WS2811_SPI_WriteByte((Bits & i)?One:Zero);
}
}
static void WS2811_SPI_SendPixel(u16 Sensor_Num)
{
WS2811_SPI_SendBits(Pixel[Sensor_Num].red);
WS2811_SPI_SendBits(Pixel[Sensor_Num].green);
WS2811_SPI_SendBits(Pixel[Sensor_Num].blue);
}
void LED_SPI_Update(void)
{
u16 i;
if(DMA_GetCurrDataCounter(DMA1_Channel3) == 0)
{
for(i=0;i<LED_ALL_Num;i++)
{
WS2811_SPI_SendPixel(i);
}
for (i = 0; i < 20; i++)
{ /* (20+1) * 2.5 = 51.5 ~ 52.5us */
WS2811_SPI_WriteByte(0x00);
}
PixelPointer = 0;
DMA_Cmd(DMA1_Channel3, DISABLE);
DMA_ClearFlag(DMA1_FLAG_TC3);
SPI_DMA_Init();
DMA_Cmd(DMA1_Channel3, ENABLE);
}
}
//以下为用户程序
void Pixel_Color_Init(void)
{
u8 i;
for(i=0;i<LED_ALL_Num;i++)
{
Pixel[i].red = 0x00;
Pixel[i].blue = 0x00;
Pixel[i].green = 0x00;
}
}
void WS2811_Pixel_Light(u16 num,u8 Color)
{
u8 i;
switch(Color)
{
case WS2811_Color_Red:
for(i=0;i<num;i++)
{
Pixel[i].red = 0xff;
Pixel[i].blue = 0x00;
Pixel[i].green = 0x00;
}
for(i=num;i<LED_ALL_Num;i++)
{
Pixel[i].red = 0x00;
Pixel[i].blue = 0x00;
Pixel[i].green = 0x00;
}
break;
case WS2811_Color_Orange:
for(i=0;i<num;i++)
{
Pixel[i].red = 0xff;
Pixel[i].green = 0x7f;
Pixel[i].blue = 0x00;
}
for(i=num;i<LED_ALL_Num;i++)
{
Pixel[i].red = 0x00;
Pixel[i].blue = 0x00;
Pixel[i].green = 0x00;
}
break;
case WS2811_Color_Yellow:
for(i=0;i<num;i++)
{
Pixel[i].red = 0xff;
Pixel[i].green = 0xff;
Pixel[i].blue = 0x00;
}
for(i=num;i<LED_ALL_Num;i++)
{
Pixel[i].red = 0x00;
Pixel[i].blue = 0x00;
Pixel[i].green = 0x00;
}
break;
case WS2811_Color_Green:
for(i=0;i<num;i++)
{
Pixel[i].red = 0x00;
Pixel[i].green = 0xff;
Pixel[i].blue = 0x00;
}
for(i=num;i<LED_ALL_Num;i++)
{
Pixel[i].red = 0x00;
Pixel[i].blue = 0x00;
Pixel[i].green = 0x00;
}
break;
case WS2811_Color_Qing:
for(i=0;i<num;i++)
{
Pixel[i].red = 0x00;
Pixel[i].green = 0xff;
Pixel[i].blue = 0xff;
}
for(i=num;i<LED_ALL_Num;i++)
{
Pixel[i].red = 0x00;
Pixel[i].blue = 0x00;
Pixel[i].green = 0x00;
}
break;
case WS2811_Color_Blue:
for(i=0;i<num;i++)
{
Pixel[i].red = 0x00;
Pixel[i].green = 0x00;
Pixel[i].blue = 0xff;
}
for(i=num;i<LED_ALL_Num;i++)
{
Pixel[i].red = 0x00;
Pixel[i].blue = 0x00;
Pixel[i].green = 0x00;
}
break;
case WS2811_Color_Zi:
for(i=0;i<num;i++)
{
Pixel[i].red = 0x87;
Pixel[i].green = 0x7f;
Pixel[i].blue = 0x78;
}
for(i=num;i<LED_ALL_Num;i++)
{
Pixel[i].red = 0x00;
Pixel[i].blue = 0x00;
Pixel[i].green = 0x00;
}
break;
case WS2811_Color_White:
for(i=0;i<num;i++)
{
Pixel[i].red = 0xff;
Pixel[i].green = 0xff;
Pixel[i].blue = 0xff;
}
for(i=num;i<LED_ALL_Num;i++)
{
Pixel[i].red = 0x00;
Pixel[i].blue = 0x00;
Pixel[i].green = 0x00;
}
break;
default:
break;
}
LED_SPI_Update();
}
void WS2811_Pixel_Flash(void)
{
u8 i;
Pixel_Color_Init();
LED_SPI_Update();
OS_Delay(1000);
//for(j=0;j<WeightSensor_Num;j++)
{
for(i=0;i<LED_ALL_Num;i++)
{
Pixel[i].red = 0xff;
Pixel[i].blue = 0x00;
Pixel[i].green = 0x00;
}
}
LED_SPI_Update();
OS_Delay(1000);
//for(j=0;j<WeightSensor_Num;j++)
{
for(i=0;i<LED_ALL_Num;i++)
{
Pixel[i].red = 0xff;
Pixel[i].green = 0x7f;
Pixel[i].blue = 0x00;
}
}
LED_SPI_Update();
OS_Delay(1000);
//for(j=0;j<WeightSensor_Num;j++)
{
for(i=0;i<LED_ALL_Num;i++)
{
Pixel[i].red = 0xff;
Pixel[i].green = 0xff;
Pixel[i].blue = 0x00;
}
}
LED_SPI_Update();
OS_Delay(1000);
//for(j=0;j<WeightSensor_Num;j++)
{
for(i=0;i<LED_ALL_Num;i++)
{
Pixel[i].red = 0x00;
Pixel[i].green = 0xff;
Pixel[i].blue = 0x00;
}
}
LED_SPI_Update();
OS_Delay(1000);
//for(j=0;j<WeightSensor_Num;j++)
{
for(i=0;i<LED_ALL_Num;i++)
{
Pixel[i].red = 0x00;
Pixel[i].green = 0xff;
Pixel[i].blue = 0xff;
}
}
LED_SPI_Update();
OS_Delay(1000);
//for(j=0;j<WeightSensor_Num;j++)
{
for(i=0;i<LED_ALL_Num;i++)
{
Pixel[i].red = 0x00;
Pixel[i].green = 0x00;
Pixel[i].blue = 0xff;
}
}
LED_SPI_Update();
OS_Delay(1000);
//for(j=0;j<WeightSensor_Num;j++)
{
for(i=0;i<LED_ALL_Num;i++)
{
Pixel[i].red = 0x87;
Pixel[i].green = 0x7f;
Pixel[i].blue = 0x78;
}
}
LED_SPI_Update();
OS_Delay(1000);
//for(j=0;j<WeightSensor_Num;j++)
{
for(i=0;i<LED_ALL_Num;i++)
{
Pixel[i].red = 0xff;
Pixel[i].green = 0xff;
Pixel[i].blue = 0xff;
}
}
}
void WS2811_Pixel_Slow_Light(u8 Color_Flag)
{
u16 i,j;
switch(Color_Flag)
{
case 0:
for(i=0;i<LED_ALL_Light;i++)
{
for(j=0;j<LED_ALL_Num;j++)
{
Pixel[j].red = i;
Pixel[j].blue = 0x00;
Pixel[j].green = 0x00;
}
LED_SPI_Update();
OS_Delay(15);
}
break;
case 1:
for(i=0;i<LED_ALL_Light;i++)
{
for(j=0;j<LED_ALL_Num;j++)
{
Pixel[j].red = 0x00;
Pixel[j].blue = i;
Pixel[j].green = 0x00;
}
LED_SPI_Update();
OS_Delay(15);
}
break;
case 2:
for(i=0;i<LED_ALL_Light;i++)
{
for(j=0;j<LED_ALL_Num;j++)
{
Pixel[j].red = 0;
Pixel[j].blue = 0x00;
Pixel[j].green = i;
}
LED_SPI_Update();
OS_Delay(15);
}
break;
case 3:
for(i=0;i<LED_ALL_Light;i++)
{
for(j=0;j<LED_ALL_Num;j++)
{
Pixel[j].red = i;
Pixel[j].blue = i;
Pixel[j].green = 0x00;
}
LED_SPI_Update();
OS_Delay(15);
}
break;
case 4:
for(i=0;i<LED_ALL_Light;i++)
{
for(j=0;j<LED_ALL_Num;j++)
{
Pixel[j].red = i;
Pixel[j].blue = 0x00;
Pixel[j].green = i;
}
LED_SPI_Update();
OS_Delay(15);
}
break;
case 5:
for(i=0;i<LED_ALL_Light;i++)
{
for(j=0;j<LED_ALL_Num;j++)
{
Pixel[j].red = 0;
Pixel[j].blue = i;
Pixel[j].green = i;
}
LED_SPI_Update();
OS_Delay(15);
}
break;
case 6:
for(i=0;i<LED_ALL_Light;i++)
{
for(j=0;j<LED_ALL_Num;j++)
{
Pixel[j].red = i;
Pixel[j].blue = i;
Pixel[j].green = i;
}
LED_SPI_Update();
OS_Delay(15);
}
break;
case 7:
for(i=0;i<LED_ALL_Light;i++)
{
for(j=0;j<LED_ALL_Num;j++)
{
Pixel[j].red = i;
Pixel[j].blue = i;
Pixel[j].green = i;
}
LED_SPI_Update();
OS_Delay(15);
}
break;
default:break;
}
}
//点亮一卷灯带的50个灯珠
//输入： Flag，决定颜色
// Light，决定亮度
void WS2811_Pixel_Color_Light(u8 Color_Flag,u8 Light)
{
u16 i,j;
switch(Color_Flag)
{
case 0:
for(j=0;j<LED_ALL_Num;j++)
{
Pixel[j].red = Light;
Pixel[j].blue = 0x00;
Pixel[j].green = 0x00;
}
LED_SPI_Update();
break;
case 1:
for(j=0;j<LED_ALL_Num;j++)
{
Pixel[j].red = 0x00;
Pixel[j].blue = Light;
Pixel[j].green = 0x00;
}
LED_SPI_Update();
break;
case 2:
for(j=0;j<LED_ALL_Num;j++)
{
Pixel[j].red = 0;
Pixel[j].blue = 0x00;
Pixel[j].green = Light;
}
LED_SPI_Update();
break;
case 3:
for(j=0;j<LED_ALL_Num;j++)
{
Pixel[j].red = Light;
Pixel[j].blue = Light;
Pixel[j].green = 0x00;
}
LED_SPI_Update();
break;
case 4:
for(j=0;j<LED_ALL_Num;j++)
{
Pixel[j].red = Light;
Pixel[j].blue = 0x00;
Pixel[j].green = Light;
}
LED_SPI_Update();
break;
case 5:
for(j=0;j<LED_ALL_Num;j++)
{
Pixel[j].red = 0;
Pixel[j].blue = Light;
Pixel[j].green = Light;
}
LED_SPI_Update();
break;
case 6:
for(j=0;j<LED_ALL_Num;j++)
{
Pixel[j].red = Light;
Pixel[j].blue = Light;
Pixel[j].green = Light;
}
LED_SPI_Update();
break;
case 7:
for(j=0;j<LED_ALL_Num;j++)
{
Pixel[j].red = Light;
Pixel[j].blue = Light;
Pixel[j].green = Light;
}
LED_SPI_Update();
break;
default:break;
}
}

复制代码

clesun · 发表于 2017-10-20 11:25:21

zqf441775525 发表于 2017-10-18 14:10
没找到怎么上传文件，就把代码复制过来吧

typedef struct

多谢。问一下，这种灯容易坏吗。这两天搞PTL，得考虑灯坏了替换的问题，

zqf441775525 · 发表于 2017-10-20 13:12:27

clesun 发表于 2017-10-20 11:25
多谢。问一下，这种灯容易坏吗。这两天搞PTL，得考虑灯坏了替换的问题， ...

我用的量不多，不好发表意见

clesun · 发表于 2017-10-20 13:43:54

zqf441775525 发表于 2017-10-20 13:12
我用的量不多，不好发表意见

我看你的代码里用到SPI的sck和MOSI两个管脚，这样和普通IO比效果会更好？

stm8s · 发表于 2017-10-20 13:49:57

灯上pwm调光频率太低了才~415HZ WS2801调光频率高一点 ~2150HZ ,本人十分讨厌PWM直接调光

zqf441775525 · 发表于 2017-10-20 20:09:03

clesun 发表于 2017-10-20 13:43
我看你的代码里用到SPI的sck和MOSI两个管脚，这样和普通IO比效果会更好？

对，用SPI+DMA，可以很方便的获得WS2811的控制波形
也可以用TIM+DMA+GPIO做。

YS126 · 发表于 2017-10-21 09:09:20

Q男发表于 2016-4-20 07:58
双核，用两片003，一片负责专门发数据，另外一片负责接收红外。红外接收解码成功之后，用io口通知。

这 ...

很多单片机就已经集成双核了，没必要用两个单片机。

fengyunyu · 发表于 2017-10-21 13:29:08

单线通信，用过

qtechzdh · 发表于 2017-10-21 13:55:25

哈哈，规格书把贴片厂工人下班要干的工作都规定了

拿着个做个10x10的小型的LED桌面小屏幕，会不会很好玩儿。

4317mjh · 发表于 2017-10-21 20:14:31

这种是不是叫菊花链？

mkliop · 发表于 2017-11-14 22:38:37

1024X768的像素需要39万成本价

justdomyself · 发表于 2018-4-18 22:26:24

YS126 发表于 2017-10-21 09:09
很多单片机就已经集成双核了，没必要用两个单片机。

推荐几个双核单片机呗

banye2010 · 发表于 2018-4-18 23:44:33

Q男发表于 2016-4-20 07:54
这个玩意的时序是靠占空比来决定发送的数据是1还是0，或者是复位通讯接口的。

所以DMA.SPI根本不行的 ...

FPGA 可以用软核，自己写个外设，干这个事情

weatt123456789 · 发表于 2018-10-25 13:11:21

Q男发表于 2016-4-20 01:05
就是从这个玩意开始，
我养成了开大buffer的习惯。
计算数据，关中断，发数据，开中断，处理其它事情。

如果是串口就没这么多毛病了

介绍一款单总线智能RGB LED WS2812B

本帖子中包含更多资源

阿莫论坛20周年了！感谢大家的支持与爱护！！