21ic电子技术开发论坛 › 单片机与嵌入式系统 › 合泰HT32 MCU › 【ESK32-30519 + ESK32-21001测评】+SPI驱动WS2812B ...
返回列表 发新帖我要提问

[开发板与模块] 【ESK32-30519 + ESK32-21001测评】+SPI驱动WS2812B

[复制链接]
 楼主| 袁胜富 发表于 2022-9-13 19:04 | 显示全部楼层 |阅读模式
<
ws2812, ws2812b, HT32F54253, ESK32-30519, ESK32-21001, HT32spi驱动
本帖最后由 eltonchang2001 于 2022-11-9 13:53 编辑

一、概述     

      最近得到合泰的HT32F54253开发板，恰好手里有一个WS2812B的RGB灯模块，那就点灯吧。一开始决定用SPI+PDMA的方式点亮的，奈何加了PDMA后代码跑死了，一直看手册和官方别的PMDA例程也没得到解决，索性不发SPI+PDMA驱动WS2812B，那就发一个不带PDMA的吧。

二、WS2812B的理论学习

    数据传输时间
   数据传输时间.png
   时序和级联使用
    数据表示.png
     数据传输方法和数据组成
    传输方式.png       通过以上图片和参考数据手册得知，WS2812B的数据传输速率是800KHZ。1s/800KHZ=1.25us。WS2812B有VCC、GND、DIN，DOUT四个引脚，数据从DIN流入从DOUT流出，使用多颗灯的时候需要以级联的方式使用。WS2812B由RGB三原色的比例可以显示很多中颜色。其一包数据由24bit构成，绿色（Green）占8位，红色（Red）占8位，蓝色（Blue)占8位，要显示要想显示的颜色只需要改变R、G、B值。其中G排最高位，R中间，B最低位。

三、HT32F54253的SPI知识和如何驱动ws2812B讲解

   本次实验选择的是SPI0，由于只用到发送引脚，我只初始化了MOSI引脚(PA5)，PA5要使用复用功能5才能作为SPI0的MOSI功能。用过芯片的用户手册查得SPI0外设挂载时钟总线AHB频率为60MHZ，经过8分频后为7.5MHZ给SPI0使用。由于分频之后SPI0的工作频率为7.5MHZ，所在SPI0在发送1bit数据就得花费1s/7.5MHZ≈133ns，经过计算发送一字节数据就得花费8*133ns=1.06us.从WS2812B资料中得知，266ns的0码高电平时间符合，800ns的1码高电平时间也符合。所以SPI在8分频的情况下发送8位数据，其中2位用来代表0码的高电平时间，6位用来表示1码的高电平时间。通过这样的模拟，成功点亮了WS2812B。
四、代码实践

      头文件
复制
  1. #ifndef __SPI_DMA_WS2812_H
    

  2. #define __SPI_DMA_WS2812_H
    


  3. 

  4. #include "ht32.h"
    

  5. #include "ht32_board.h"
    

  6. #include "stdint.h"
    

  7. #include "bsp_sys.h"
    


  8. 

  9. /*
    

  10. 要将系统时钟设置为60M，SPI分频数设置为8，则SPI的通信频率为7.5M，1s/7.5≈133ns 即传输一位数据的时间约为55纳秒（ns）8*133 =1.06us 符合WS2812
    


  11. 

  12.  2*133 = 266ns   6*133 = 799ns  符合WS281X芯片的通信时序。
    


  13. 

  14.  1111 1100high level  （十六进制：0XFC）表示WS281X的1码
    


  15. 

  16.  1100 0000  low level   （十六进制：0XC0）表示WS281X的0码
    

  17. 程序头文件部分： 通过宏的方式定义了灯珠个数和WS281X的0码和1码。
    

  18. */
    


  19. 

  20. //  _____   
    


  21. 

  22. // |     |___|    1111 1100 high level
    


  23. 

  24. //  ___         
    


  25. 

  26. // |   |_____|   1111 0000   low level
    


  27. 


  28. 

  29. #define Delay_ms(wait)  delay_ms(wait)
    


  30. 

  31. #define WS2812B   //选择WS2812B
    

  32. #define PIXEL_NUM1  2     //RGB灯的数量                                         //灯带1灯数（组数）
    

  33. #define PIXEL_NUM2  2                                                          //灯带2灯数（组数）
    

  34. #define PIXEL_NUM3  2                                                          //灯带3灯数（组数）
    

  35. #define PIXEL_NUM4  2                                                          //灯带4灯数（组数）
    


  36. 

  37. #define PIXEL_NUM  (PIXEL_NUM1+PIXEL_NUM2+PIXEL_NUM3+PIXEL_NUM4)//灯数统计
    

  38. #define GRB  24   //3*8 //Red8位 Green8位 Blue8位 加起来24位
    


  39. 

  40. #ifdef WS2812B
    

  41. #define WS_HIGH 0xFC
    

  42. #endif
    

  43. #define WS_LOW  0xC0
    

  44. /*    
    

  45.       R      G      B
    

  46. 红： 255     0      0
    

  47. 黄： 255    255     0
    

  48. 绿：  0     255     0
    

  49. 青：  0     255    255
    

  50. 蓝：  0      0     255
    

  51. 紫： 255     0     255
    

  52. 白： 255    255    255
    

  53. */
    


  54. 

  55. typedef union _rgbPixelBuffer
    

  56. {
    

  57.     struct 
    

  58.     {
    

  59.                         uint8_t PixelBuffer1[PIXEL_NUM1][GRB];
    

  60.                         uint8_t PixelBuffer2[PIXEL_NUM2][GRB];
    

  61.                         uint8_t PixelBuffer3[PIXEL_NUM3][GRB];
    

  62.                         uint8_t PixelBuffer4[PIXEL_NUM4][GRB];
    

  63.     }buff;
    

  64.     uint8_t All_Buffer[PIXEL_NUM][GRB];
    

  65.                 uint8_t Buffer[PIXEL_NUM*GRB];
    

  66. }RGB_PixelBuffer,*PRGB_PixelBuffer;
    


  67. 


  68. 


  69. 

  70. void WS281x_Init(void);
    

  71. void WS281x_CloseAll(void);
    

  72. uint32_t WS281x_Color(uint8_t red, uint8_t green, uint8_t blue);
    

  73. void WS281x_SetPixelColor(uint16_t n, uint32_t GRBColor);
    

  74. void WS281x_SetPixelRGB(uint16_t n ,uint8_t red, uint8_t green, uint8_t blue);
    

  75. void WS281x_Show(void);
    


  76. 

  77. void WS281x_RainbowCycle(uint8_t wait);
    

  78. void WS281x_TheaterChase(uint32_t c, uint8_t wait);
    

  79. void WS281x_ColorWipe(uint32_t c, uint8_t wait);
    

  80. void WS281x_Rainbow(uint8_t wait);
    

  81. void WS281x_TheaterChaseRainbow(uint8_t wait);
    


  82. 


  83. 

  84. void RGB_DEBUG_TEST(void);
    

  85. #endif
    


  86. 


  87. 


  88. 


  89. 


  90. 


  91. 


  92. 


  93. 


  94. 


  95. 


  96. 


  97.

源文件，由于没有调通PDMA，故代码中屏蔽了PDMA部分代码
复制
  1. #include "spi_dma_ws2812.h"
    

  2. #include "string.h"
    

  3. RGB_PixelBuffer pixelBuffer;
    

  4. uint32_t SPI_clock;
    

  5.         
    

  6. void WS281x_Init(void)
    

  7. {
    

  8.   SPI_InitTypeDef  SPI_InitStructure;
    

  9. //  PDMACH_InitTypeDef PDMACH_InitStructure;
    

  10.   CKCU_PeripClockConfig_TypeDef CKCUClock = {{0}};
    

  11.   CKCUClock.Bit.SPI0   = 1;//打开SPI0的时钟
    

  12.   CKCUClock.Bit.PA     = 1;//打开GPIOA的时钟
    

  13.   CKCUClock.Bit.AFIO   = 1;//打开复用时钟
    

  14. //        CKCUClock.Bit.PDMA   = 1;//外设DMA时钟
    

  15.   CKCU_PeripClockConfig(CKCUClock, ENABLE);//使能
    

  16.         AFIO_GPxConfig(GPIO_PA,AFIO_PIN_5,AFIO_MODE_5);//GPIOA 的PA5复用为SPI0的MOSI
    

  17.   /* Configure the GPIO pin*/
    

  18.   GPIO_PullResistorConfig(HT_GPIOA, GPIO_PIN_5, GPIO_PR_DOWN);//配置下拉
    

  19.   GPIO_DriveConfig(HT_GPIOA, GPIO_PIN_5,GPIO_DV_4MA);
    

  20.   GPIO_DirectionConfig(HT_GPIOA, GPIO_PIN_5, GPIO_DIR_OUT);
    

  21.         
    

  22. //        PDMACH_InitStructure.PDMACH_DstAddr = (uint32_t)&HT_SPI0->DR;
    

  23. //        PDMACH_InitStructure.PDMACH_SrcAddr = (uint32_t)&pixelBuffer;
    

  24. //        PDMACH_InitStructure.PDMACH_AdrMod  = SRC_ADR_LIN_INC  | DST_ADR_FIX;
    

  25. //        PDMACH_InitStructure.PDMACH_DataSize = WIDTH_8BIT;
    

  26. //        PDMACH_InitStructure.PDMACH_Priority =  VH_PRIO;
    

  27. //        PDMACH_InitStructure.PDMACH_BlkCnt   =  1;
    

  28. //        PDMACH_InitStructure.PDMACH_BlkLen   =  24;
    

  29. //        PDMA_Config(PDMA_CH1, &PDMACH_InitStructure);
    

  30. //        PDMA_EnaCmd(PDMA_CH1, ENABLE);
    

  31. //        PDMA_ClearFlag(PDMA_CH1, PDMA_FLAG_TC | PDMA_INT_GE);
    

  32. //        PDMA_IntConfig(PDMA_CH1, (PDMA_INT_GE | PDMA_INT_TC), ENABLE);
    


  33. 

  34.   /*  SPI Configuration*/
    

  35.         SPI_DeInit(HT_SPI0);
    

  36.   SPI_InitStructure.SPI_Mode = SPI_MASTER;
    

  37.   SPI_InitStructure.SPI_FIFO = SPI_FIFO_DISABLE;
    

  38.   SPI_InitStructure.SPI_DataLength = SPI_DATALENGTH_8;
    

  39.   SPI_InitStructure.SPI_SELMode = SPI_SEL_SOFTWARE;
    

  40.   SPI_InitStructure.SPI_SELPolarity = SPI_SELPOLARITY_HIGH;
    

  41.   SPI_InitStructure.SPI_FirstBit = SPI_FIRSTBIT_MSB;
    

  42.   SPI_InitStructure.SPI_CPOL = SPI_CPOL_HIGH;
    

  43.   SPI_InitStructure.SPI_CPHA = SPI_CPHA_SECOND;
    

  44.   SPI_InitStructure.SPI_TxFIFOTriggerLevel = 0;
    

  45.   SPI_InitStructure.SPI_ClockPrescaler = 8;
    

  46.   SPI_Init(HT_SPI0, &SPI_InitStructure);
    

  47.         SPI_SoftwareSELCmd(HT_SPI0,SPI_SEL_ACTIVE);
    

  48. //        SPI_PDMACmd(HT_SPI0,SPI_PDMAREQ_TX,ENABLE);
    

  49.         SPI_Cmd(HT_SPI0,ENABLE);
    

  50.         WS281x_CloseAll();  //关闭全部的灯
    


  51. 

  52.   delay_ms(100); //关闭全部的灯需要一定的时间  
    

  53.         
    

  54. }
    


  55. 

  56. //uint16_t dATA;
    

  57. //更新颜色显示（在设定颜色后将颜色数据存入缓存只有执行该函数后才会进行显示）
    

  58. void WS281x_Show(void)
    

  59. {
    

  60. //        //关闭通道 才能重新写入传输值
    

  61. //  PDMA_EnaCmd(PDMA_CH1, DISABLE);
    

  62. //        SPI_Cmd(HT_SPI0,DISABLE);
    

  63. //        PDMA_TranSizeConfig(PDMA_CH1,1,24);
    

  64. //  //开启通道
    

  65. //        SPI_Cmd(HT_SPI0,ENABLE);
    

  66. //  PDMA_EnaCmd(PDMA_CH1, ENABLE);
    

  67. //        PDMA_SwTrigCmd(PDMA_CH1, ENABLE);
    

  68. //        SPI_SoftwareSELCmd(HT_SPI0,SPI_SEL_ACTIVE);
    

  69. //  while (PDMA_GetFlagStatus(PDMA_CH1, PDMA_FLAG_TC) != SET);
    

  70. //  PDMA_ClearFlag(PDMA_CH1, PDMA_FLAG_GE|PDMA_FLAG_TC);
    

  71. //        dATA=SPI_ReceiveData(HT_SPI0);
    

  72.         int i = 0,k=0;
    

  73. //        for(i=0;i<PIXEL_NUM;i++)
    

  74. //        {
    

  75. //                for(j=0;j<GRB;j++)
    

  76. //                {
    

  77. //                        SPI_SendData(HT_SPI0,(u32)pixelBuffer.All_Buffer[i][j]);
    

  78. //                        for(k=0;k<10;k++)
    

  79. //                        {
    

  80. //                                __NOP();
    

  81. //                        }
    

  82. //                }
    

  83. //        }
    

  84.         for(i=0;i<PIXEL_NUM*GRB;i++)
    

  85.         {
    

  86.                 SPI_SendData(HT_SPI0,(u32)pixelBuffer.Buffer[i]);
    

  87.                 for(k=0;k<10;k++)
    

  88.                 {
    

  89.                         __NOP();
    

  90.                 }
    

  91.         }
    

  92.         
    

  93. }
    

  94. //配置完成之后便可以构思底层控制函数了，为了方便多个LED灯珠的可控制首先要定义一个缓冲区pixelBuffer[PIXEL_NUM][24]\
    

  95. 通过设定颜色将数据填入缓冲区再通过更新函数将数据传入到LED灯珠上。
    

  96. //关闭所有灯珠
    

  97. void WS281x_CloseAll(void)
    

  98. {
    

  99.   uint16_t i;
    

  100.   uint8_t j;
    

  101.   
    

  102.   for(i = 0; i < PIXEL_NUM; ++i)
    

  103.   {
    

  104.     for(j = 0; j < GRB; ++j)
    

  105.     {
    

  106.       pixelBuffer.All_Buffer[i][j] = WS_LOW;
    

  107.     }
    

  108.   }
    

  109.   WS281x_Show(); 
    

  110. }
    


  111. 


  112. 

  113. uint32_t WS281x_Color(uint8_t red, uint8_t green, uint8_t blue)
    

  114. {
    

  115.   return green << 16 | red << 8 | blue;
    

  116. }
    


  117. 

  118. void WS281x_SetPixelColor(uint16_t n, uint32_t GRBColor)
    

  119. {
    

  120.   uint8_t i;
    

  121.   if(n < PIXEL_NUM)
    

  122.   {
    

  123.     for(i = 0; i < GRB; i++)
    

  124.     {
    

  125.       pixelBuffer.All_Buffer[n][i] = ((GRBColor << i) & 0x800000) ? WS_HIGH : WS_LOW;
    

  126.     }
    

  127.   }
    

  128. }
    


  129. 

  130. void WS281x_SetPixelRGB(uint16_t n ,uint8_t red, uint8_t green, uint8_t blue)
    

  131. {
    

  132.   uint8_t i;
    

  133.   
    

  134.   if(n < PIXEL_NUM)
    

  135.   {
    

  136.     for(i = 0; i < GRB; ++i)
    

  137.     {
    

  138.       pixelBuffer.All_Buffer[n][i] = (((WS281x_Color(red,green,blue) << i) & 0X800000) ? WS_HIGH : WS_LOW);
    

  139.     }
    

  140.   }
    

  141. }
    


  142. 

  143. // Input a value 0 to 255 to get a color value.
    

  144. // The colours are a transition r - g - b - back to r.
    

  145. uint32_t WS281x_Wheel(uint8_t wheelPos) {
    

  146.   wheelPos = 255 - wheelPos;
    

  147.   if(wheelPos < 85) {
    

  148.     return WS281x_Color(255 - wheelPos * 3, 0, wheelPos * 3);
    

  149.   }
    

  150.   if(wheelPos < 170) {
    

  151.     wheelPos -= 85;
    

  152.     return WS281x_Color(0, wheelPos * 3, 255 - wheelPos * 3);
    

  153.   }
    

  154.   wheelPos -= 170;
    

  155.   return WS281x_Color(wheelPos * 3, 255 - wheelPos * 3, 0);
    

  156. }
    


  157. 

  158. // Fill the dots one after the other with a color
    

  159. void WS281x_ColorWipe(uint32_t c, uint8_t wait) {
    

  160.   for(uint16_t i=0; i<PIXEL_NUM; i++) {
    

  161.     WS281x_SetPixelColor(i, c);
    

  162.     WS281x_Show();
    

  163.     Delay_ms(wait);
    

  164.   }
    

  165. }
    


  166. 

  167. void WS281x_Rainbow(uint8_t wait) {
    

  168.   uint16_t i, j;
    


  169. 

  170.   for(j=0; j<256; j++) {
    

  171.     for(i=0; i<PIXEL_NUM; i++) {
    

  172.       WS281x_SetPixelColor(i, WS281x_Wheel((i+j) & 255));
    

  173.     }
    

  174.     WS281x_Show();
    

  175.     Delay_ms(wait);
    

  176.   }
    

  177. }
    


  178. 

  179. // Slightly different, this makes the rainbow equally distributed throughout
    

  180. void WS281x_RainbowCycle(uint8_t wait) {
    

  181.   uint16_t i, j;
    


  182. 

  183.   for(j=0; j<256*5; j++) { // 5 cycles of all colors on wheel
    

  184.     for(i=0; i< PIXEL_NUM; i++) {
    

  185.       WS281x_SetPixelColor(i,WS281x_Wheel(((i * 256 / PIXEL_NUM) + j) & 255));
    

  186.     }
    

  187.     WS281x_Show();
    

  188.     Delay_ms(wait);
    

  189.   }
    

  190. }
    


  191. 

  192. //Theatre-style crawling lights.
    

  193. void WS281x_TheaterChase(uint32_t c, uint8_t wait) {
    

  194.   for (int j=0; j<10; j++) {  //do 10 cycles of chasing
    

  195.     for (int q=0; q < 3; q++) {
    

  196.       for (uint16_t i=0; i < PIXEL_NUM; i=i+3) {
    

  197.         WS281x_SetPixelColor(i+q, c);    //turn every third pixel on
    

  198.       }
    

  199.       WS281x_Show();
    


  200. 

  201.       Delay_ms(wait);
    


  202. 

  203.       for (uint16_t i=0; i < PIXEL_NUM; i=i+3) {
    

  204.         WS281x_SetPixelColor(i+q, 0);        //turn every third pixel off
    

  205.       }
    

  206.     }
    

  207.   }
    

  208. }
    


  209. 

  210. //Theatre-style crawling lights with rainbow effect
    

  211. void WS281x_TheaterChaseRainbow(uint8_t wait) {
    

  212.   for (int j=0; j < 256; j++) {     // cycle all 256 colors in the wheel
    

  213.     for (int q=0; q < 3; q++) {
    

  214.       for (uint16_t i=0; i < PIXEL_NUM; i=i+3) {
    

  215.         WS281x_SetPixelColor(i+q, WS281x_Wheel( (i+j) % 255));    //turn every third pixel on
    

  216.       }
    

  217.       WS281x_Show();
    


  218. 

  219.       Delay_ms(wait);
    


  220. 

  221.       for (uint16_t i=0; i < PIXEL_NUM; i=i+3) {
    

  222.         WS281x_SetPixelColor(i+q, 0);        //turn every third pixel off
    

  223.       }
    

  224.     }
    

  225.   }
    

  226. }
    


  227. 


  228. 

  229. // Slightly different, this makes the rainbow equally distributed throughout
    

  230. void WS2812_RainbowRotate(uint16_t wait) {
    

  231.         uint16_t i, j;
    


  232. 

  233.         for (j = 0; j < 256 * 5; j++) { // 5 cycles of all colors on wheel
    

  234.                 for (i = 0; i < PIXEL_NUM; i++) {
    

  235.                         WS281x_SetPixelColor(i,  WS281x_Wheel(((i * 256 / PIXEL_NUM) + j) & 255));
    

  236.                 }
    

  237.                 WS281x_Show();
    

  238.     Delay_ms(wait);
    

  239.         }
    

  240. }
    

  241. //hsv和rgb互相转
    

  242. float retmax(float a, float b, float c)                            //求最大值
    

  243. {
    

  244.         float max = 0;
    

  245.         max = a;
    

  246.         if (max < b)
    

  247.                 max = b;
    

  248.         if (max < c)
    

  249.                 max = c;
    

  250.         return max;
    

  251. }
    

  252. float retmin(float a, float b, float c)                            //求最小值
    

  253. {
    

  254.         float min = 0;
    

  255.         min = a;
    

  256.         if (min > b)
    

  257.                 min = b;
    

  258.         if (min > c)
    

  259.                 min = c;
    

  260.         return min;
    

  261. }
    

  262. //R,G,B参数传入范围（0~100）
    

  263. //转换结果h(0~360),s(0~100),v(0~100)
    

  264. void rgb_to_hsv(uint16_t *H, uint16_t *S, uint16_t *V, uint8_t r, uint8_t g, uint8_t b) {
    

  265.         float max = 0, min = 0;
    

  266.         float R = (float)r;
    

  267.         float G = (float)g;
    

  268.         float B = (float)b;
    

  269.         float h, s, v;
    


  270. 

  271.         R = R / 255.0;
    

  272.         G = G / 255.0;
    

  273.         B = B / 255.0;
    


  274. 

  275.         max = retmax(R, G, B);
    

  276.         min = retmin(R, G, B);
    

  277.         v = max;
    

  278.         if (max == 0)
    

  279.                 s = 0;
    

  280.         else
    

  281.                 s = 1 - (min / max);
    


  282. 

  283.         if (max == min)
    

  284.                 h = 0;
    

  285.         else if (max == R && G >= B)
    

  286.                 h = 60 * ((G - B) / (max - min));
    

  287.         else if (max == R && G < B)
    

  288.                 h = 60 * ((G - B) / (max - min)) + 360;
    

  289.         else if (max == G)
    

  290.                 h = 60 * ((B - R) / (max - min)) + 120;
    

  291.         else if (max == B)
    

  292.                 h = 60 * ((R - G) / (max - min)) + 240;
    


  293. 

  294.         v = v * 100;
    

  295.         s = s * 100;
    


  296. 

  297.         *H = (int) h;
    

  298.         *S = (int) s;
    

  299.         *V = (int) v;
    

  300. }
    


  301. 

  302. //参数入参范围h(0~360),s(0~100),v(0~100),这里要注意，要把s,v缩放到0~1之间
    

  303. //转换结果R(0~100),G(0~100),B(0~100)，如需转换到0~255，只需把后面的乘100改成乘255
    

  304. void hsv_to_rgb(int h, int s, int v, uint8_t *r, uint8_t *g, uint8_t *b) {
    

  305.         float C = 0, X = 0, Y = 0, Z = 0;
    

  306.         int i = 0;
    

  307.         float H = (float) (h);
    

  308.         float S = (float) (s) / 100.0;
    

  309.         float V = (float) (v) / 100.0;
    

  310.         float R, G, B;
    

  311.         if (S == 0)
    

  312.                 R = G = B = V;
    

  313.         else {
    

  314.                 H = H / 60;
    

  315.                 i = (int) H;
    

  316.                 C = H - i;
    


  317. 

  318.                 X = V * (1 - S);
    

  319.                 Y = V * (1 - S * C);
    

  320.                 Z = V * (1 - S * (1 - C));
    

  321.                 switch (i) {
    

  322.                 case 0:
    

  323.                         R = V;
    

  324.                         G = Z;
    

  325.                         B = X;
    

  326.                         break;
    

  327.                 case 1:
    

  328.                         R = Y;
    

  329.                         G = V;
    

  330.                         B = X;
    

  331.                         break;
    

  332.                 case 2:
    

  333.                         R = X;
    

  334.                         G = V;
    

  335.                         B = Z;
    

  336.                         break;
    

  337.                 case 3:
    

  338.                         R = X;
    

  339.                         G = Y;
    

  340.                         B = V;
    

  341.                         break;
    

  342.                 case 4:
    

  343.                         R = Z;
    

  344.                         G = X;
    

  345.                         B = V;
    

  346.                         break;
    

  347.                 case 5:
    

  348.                         R = V;
    

  349.                         G = X;
    

  350.                         B = Y;
    

  351.                         break;
    

  352.                 }
    

  353.         }
    

  354.         R = R * 255;
    

  355.         G = G * 255;
    

  356.         B = B * 255;
    

  357.         *r = (int) R;
    

  358.         *g = (int) G;
    

  359.         *b = (int) B;
    

  360. }
    


  361. 


  362. 


  363. 


  364. 

  365. void RGB_DEBUG_TEST(void)
    

  366. {
    

  367.         int i,j;
    

  368.         for(i=0;i<3;i++)
    

  369.         {
    

  370.                 
    

  371.                 for(j=0;j<8;j++)
    

  372.                 {
    

  373.                         if(i==0)
    

  374.                         {
    

  375.                                 WS281x_ColorWipe(WS281x_Color(255, 0, 255), 10); // Red
    

  376.                         }
    

  377.                         else if(i==1)
    

  378.                         {
    

  379.                                 WS281x_ColorWipe(WS281x_Color(0, 255, 255), 10); // Green
    

  380.                         }
    

  381.                         else
    

  382.                         {
    

  383.                                 WS281x_ColorWipe(WS281x_Color(255, 255, 0), 10); // Blue
    

  384.                         }
    

  385.                 }
    

  386.         }
    

  387.                 for(i=0;i<3;i++)
    

  388.         {
    

  389.                 
    

  390.                 for(j=0;j<8;j++)
    

  391.                 {
    

  392.                         if(i==0)
    

  393.                         {
    

  394.                                 WS281x_ColorWipe(WS281x_Color(255, 0, 0), 10); // Red
    

  395.                         }
    

  396.                         else if(i==1)
    

  397.                         {
    

  398.                                 WS281x_ColorWipe(WS281x_Color(0, 255, 0), 10); // Green
    

  399.                         }
    

  400.                         else
    

  401.                         {
    

  402.                                 WS281x_ColorWipe(WS281x_Color(0, 0, 255), 10); // Blue
    

  403.                         }
    

  404.                 }
    

  405.         }
    

  406.                 for(i=0;i<3;i++)
    

  407.         {
    

  408.                 
    

  409.                 for(j=0;j<8;j++)
    

  410.                 {
    

  411.                         if(i==0)
    

  412.                         {
    

  413.                                 WS281x_ColorWipe(WS281x_Color(255, 0, 0), 10); // Red
    

  414.                                 Delay_ms(100);
    

  415.                                 WS281x_ColorWipe(WS281x_Color(0, 255, 0), 10); // Green
    

  416.                         }
    

  417.                         else if(i==1)
    

  418.                         {
    

  419.                                 WS281x_ColorWipe(WS281x_Color(0, 255, 0), 10); // Green
    

  420.                                 Delay_ms(100);
    

  421.                                 WS281x_ColorWipe(WS281x_Color(255, 0, 0), 10); // Red
    

  422.                         }
    

  423.                         else
    

  424.                         {
    

  425.                                 WS281x_ColorWipe(WS281x_Color(0, 0, 255), 10); // Blue
    

  426.                                 Delay_ms(100);
    

  427.                                 WS281x_ColorWipe(WS281x_Color(0, 255, 0), 10); // Green
    

  428.                                 Delay_ms(100);
    

  429.                                 WS281x_ColorWipe(WS281x_Color(0, 0, 255), 10); // Blue
    

  430.                                 Delay_ms(100);
    

  431.                                 WS281x_ColorWipe(WS281x_Color(255, 0, 0), 10); // Red
    

  432.                         }
    

  433.                 }
    

  434.         }
    

  435.         WS2812_RainbowRotate(2);
    

  436.         // Some example procedures showing how to display to the pixels:
    

  437.         WS281x_ColorWipe(WS281x_Color(255, 0, 0), 10); // Red
    

  438.         WS281x_ColorWipe(WS281x_Color(0, 255, 0), 10); // Green
    

  439.         WS281x_ColorWipe(WS281x_Color(0, 0, 255), 10); // Blue
    


  440. 


  441. 

  442.         WS281x_TheaterChase(WS281x_Color(127, 127, 127), 10); // White
    

  443.         WS281x_TheaterChase(WS281x_Color(127, 0, 0), 10); // Red
    

  444.         WS281x_TheaterChase(WS281x_Color(0, 0, 127), 10); // Blue
    


  445. 

  446.         WS281x_Rainbow(10);
    

  447.         WS281x_RainbowCycle(10);
    

  448.         WS281x_TheaterChaseRainbow(10);
    

  449.         WS281x_CloseAll();
    


  450. 

  451. }

五、实物效果展示



效果展示.jpg





回复 赏

举报

相关帖子
51xlf 发表于 2023-1-5 11:14 | 显示全部楼层
spi+dma的形式驱动的。              
回复 赏

举报

plsbackup 发表于 2023-1-5 11:42 | 显示全部楼层
这个对电流的要求很大吗？              
回复 赏

举报

kkzz 发表于 2023-1-5 17:43 | 显示全部楼层
直接定时器延时就能实现的吧。              
回复 赏

举报

jimmhu 发表于 2023-1-6 15:21 | 显示全部楼层
不使用dma，那就是得占用非常多的时间了？
回复 赏

举报

robincotton 发表于 2023-1-6 19:16 | 显示全部楼层
这个可以驱动多少个ws2812呢
回复 赏

举报

wwppd 发表于 2023-2-5 13:13 | 显示全部楼层
用WS2812制作的灯带控制程序非常实用
回复 赏

举报

sheflynn 发表于 2023-2-5 14:11 | 显示全部楼层
通过硬件SPI的可以很巧妙的模拟出WS2812的通信时序,用spi的8位数据模拟ws281x的一位数据。
回复 赏

举报

nomomy 发表于 2023-2-6 12:42 | 显示全部楼层
通过配置SPI的8个时钟周期满足WS2812B所需要的1位所占用的时间
回复 赏

举报

lihuami 发表于 2023-2-7 20:00 | 显示全部楼层
使用的方法是PWM+DMA传输,也有SPI和直接延时等方法
回复 赏

举报

sanfuzi 发表于 2023-2-7 20:12 | 显示全部楼层
怎么操作WS2812B彩灯实现模块的多显示呢？
回复 赏

举报

mickit 发表于 2023-2-7 20:23 | 显示全部楼层
ws2812和ws2812b能混用吗
回复 赏

举报

jackcat 发表于 2023-2-7 20:29 | 显示全部楼层
直接使用IO口进行电平反转要方便  
回复 赏

举报

cashrwood 发表于 2023-2-7 20:40 | 显示全部楼层
驱动ws2812的时候一般采用PWM或者SPI的方式
回复 赏

举报

deliahouse887 发表于 2023-2-7 21:38 | 显示全部楼层
WS2812通信速度为1M比较合适,不会造成乱码,通信很稳定。
回复 赏

举报

sesefadou 发表于 2023-2-7 21:47 | 显示全部楼层
WS2812B是个好东西,在很多场合,都能使用。
回复 赏

举报

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

本版积分规则

袁胜富

32

主题

163

帖子

2

粉丝
快速回复 在线客服 返回列表 返回顶部
袁胜富

32

主题

163

帖子

2

粉丝
快速回复 在线客服 返回列表 返回顶部