STM32

stm32 驱动ws2812

2020-01-07 19:22发布

站内问答 / STM32/STM8
7409 37 37
最近正在用stm32做一个台灯，使用到了ws2812 LED,到网上找ws2812的stm32驱动，找半天找到一个，结果还是用不了。所以决定还是自己动手来吧。
下面的驱动代码贴出来，时候大家要使用也不错的
ws2812.h

  2. #ifndef __WS2812_H
  3. #define __WS2812_H

  5. #ifdef __cplusplus
  6. extern "C"
  7. {
  8. #endif

  10. #include "stm32f10x_conf.h"

  12. // The following macro must be ported to  your platform
  13. // 以下的宏定义请移植到你的IO Pin
  14. #define   ws2812DIN_HIGH()     (GPIOA->BSRR = 0x00001000)
  15. #define   ws2812DIN_LOW()      (GPIOA->BSRR = 0x10000000)
  16. #define   ws2812DIN_INIT()     {
  17.                                                                 RCC->APB2ENR |= 0x01<<2;
  18.                                                                 GPIOA->CRH &= ~(0x000f0000);
  19.                                                                 GPIOA->CRH |= (0x00030000);
  20.                                                                 GPIOA->BSRR |= (0x10000000);
  21.                                                                 }

  23. // RGB structure
  24. typedef struct
  25. {
  26.         // R,G,B color value
  27.     uint8_t ucRedVal;
  28.     uint8_t ucGreenVal;
  29.     uint8_t ucBlueVal;
  30. }RGB_t;
  31. // when you want to use ws2812 , you must call this function
  32. void ws2812_Init(void);
  33. void ws2812_SendRes(void);
  34. void ws2812_SendRGBData(RGB_t xRGB);


  37. /*** typical usage for above API， 典型的使用方法
  38. 　ws2812_Init();
  39.     GRB_t xRGB;
  40.     xRGB.ucRedVal = 0xff;
  41.     xRGB.ucGreenVal = 0x00;
  42.     xRGB.ucBlueVal = 0x00;
  43.     while(1)
  44.     {
  45.             // The first ws2812
  46.             ws2812_SendRGBData(xRGB);
  47.             // The second ws2812
  48.             ws2812_SendRGBData(xRGB);
  49.             // The third ws2812
  50.             ws2812_SendRGBData(xRGB);
  51.             //  The fourth ws2812
  52.             ws2812_SendRGBData(xRGB);
  53.             // send frame seperator
  54.             ws2812_SendRes();


  57.     }

  59. */

  61. #ifdef __cplusplus
  62. }
  63. #endif
  64. #endif
复制代码

ws2812.c 文件


  3. #include "ws2812.h"

  5. /*
  6. * @Desc: delay a approximate us
  7. * @Args: ulUs, us about to delay
  8. * @Returns: None
  9. */
  10. static void
  11. DelayUs(uint32_t ulUs)
  12. {
  13.         uint32_t j;
  14.         while(ulUs--)
  15.         {
  16.                 j = 12;
  17.                 while(j)
  18.                 {
  19.                         j--;
  20.                 }
  21.         }
  22. }


  25. /*
  26. * @Desc: delay a number of nop for your platform(one nop equal to 13.9 ns)
  27. * @Args: ulNopNum, nop number
  28. * @Returns: None
  29. *
  30. */
  31. static void
  32. DelayNop(uint32_t ulNopNum)
  33. {
  34.         while(ulNopNum)
  35.         {
  36.                 __NOP();
  37.                 ulNopNum--;
  38.         }
  39. }


  42. /*
  43. * @Desc: init ws2812, just init io Pin,
  44. *   you must call this function firstly whenever
  45. *   you want to use ws28128
  46. * @Args: None
  47. * @Returns: None
  48. *
  49. */
  50. void
  51. ws2812_Init(void)
  52. {
  53.         ws2812DIN_INIT();
  54. }


  57. /*
  58. * @Desc: send rgb value to a ws2812,
  59. * @Args: xRGB, rgb value container variable
  60. * @Returns: NOne
  61. *
  62. */
  63. void
  64. ws2812_SendRGBData(RGB_t xRGB)
  65. {
  66.         uint32_t i = 0;
  67.         uint32_t ulColor = 0;
  68.         // put blue color  bit to ulColor
  69.         for(i = 0; i < 8; i++)
  70.         {
  71.                 ulColor = ((xRGB.ucBlueVal & 0x01) | (ulColor << 1));
  72.                 xRGB.ucBlueVal >>= 1;
  73.         }
  74.         // put red color  bit to ulColor
  75.         for(i = 8; i < 16; i++)
  76.         {
  77.                 ulColor = ((xRGB.ucRedVal & 0x01) | (ulColor << 1));
  78.                 xRGB.ucRedVal >>= 1;
  79.         }
  80.         // put green color bit to ulColor
  81.         for(i = 16; i < 24; i++)
  82.         {
  83.                 ulColor = ((xRGB.ucGreenVal & 0x01) | (ulColor << 1));
  84.                 xRGB.ucGreenVal >>= 1;
  85.         }
  86.         // send 24 bits color data
  87.         for(i = 0; i < 24; i++)
  88.         {
  89.                 if((ulColor & (uint32_t)0x01))
  90.                 {
  91.                         ws2812DIN_HIGH();
  92.                         DelayNop(20);
  93.                         ws2812DIN_LOW();
  94.                 }
  95.                 else
  96.                 {
  97.                         ws2812DIN_HIGH();
  98.                         ws2812DIN_LOW();
  99.                         DelayNop(20);
  100.                 }
  101.                 ulColor >>= 1;
  102.         }
  103. }

  105. /*
  106. * @Desc: send　a frame seperator
  107. * @Args: None
  108. * @Returns: None
  109. */
  110. void
  111. ws2812_SendRes(void)
  112. {
  113.     ws2812DIN_LOW();
  114.     DelayUs(100);
  115. }

复制代码
友情提示: 此问题已得到解决，问题已经关闭,关闭后问题禁止继续编辑，回答。
37条回答
hyz_avr
2020-01-08 13:10
用delay软件延时的吗,还是用dma+pwm驱动的好点.

http://www.cnblogs.com/shangdawei/p/4762102.html

  1. #include "ws2812.h"
  2. #include <stm32f4xx.h>
  3. #include <stm32f4xx_rcc.h>
  4. #include <stm32f4xx_gpio.h>
  5. #include <stm32f4xx_tim.h>
  6. #include <stm32f4xx_dma.h>

  8. static uint16_t PWM_Buffer[ PWM_BUFFER_SIZE ];
  9. uint32_t frame_pos = 0;
  10. int incomplete_return = 0;

  12. void Update_Buffer( uint16_t* buffer );

  14. static void start_dma( void )
  15. {
  16.   static DMA_InitTypeDef dma_init =
  17.   { .DMA_BufferSize = PWM_BUFFER_SIZE, .DMA_Channel = DMA_Channel_5, .DMA_DIR =
  18.     DMA_DIR_MemoryToPeripheral, .DMA_FIFOMode = DMA_FIFOMode_Disable,
  19.     .DMA_FIFOThreshold = DMA_FIFOThreshold_HalfFull, .DMA_Memory0BaseAddr =
  20.       (uint32_t) PWM_Buffer, .DMA_MemoryBurst = DMA_MemoryBurst_Single,
  21.     .DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord, .DMA_MemoryInc =
  22.       DMA_MemoryInc_Enable, .DMA_Mode = DMA_Mode_Circular,
  23.     .DMA_PeripheralBaseAddr = (uint32_t) &TIM3->CCR4, .DMA_PeripheralBurst =
  24.       DMA_PeripheralBurst_Single, .DMA_PeripheralDataSize =
  25.       DMA_PeripheralDataSize_HalfWord, .DMA_PeripheralInc =
  26.       DMA_PeripheralInc_Disable, .DMA_Priority = DMA_Priority_Medium };
  27.   
  28.   DMA_Init( DMA1_Stream2, &dma_init );
  29.   DMA_Cmd( DMA1_Stream2, ENABLE );
  30.   TIM_DMACmd( TIM3, TIM_DMA_CC4, ENABLE );
  31. }

  33. static void init_buffers( void )
  34. {
  35.   for ( int i = 0; i < PWM_BUFFER_SIZE; i++ )
  36.   {
  37.     PWM_Buffer[ i ] = 0;
  38.   }
  39.   for ( int i = 0; i < FRAMEBUFFER_SIZE; i++ )
  40.   {
  41.     ws2812_framebuffer[ i ].red = 0;
  42.     ws2812_framebuffer[ i ].green = 0;
  43.     ws2812_framebuffer[ i ].blue = 0;
  44.   }
  45. }

  47. void ws2812_init( )
  48. {
  49.   init_buffers( );
  50.   
  51.   //InitStructures...
  52.   GPIO_InitTypeDef GPIO_InitStructure;
  53.   TIM_TimeBaseInitTypeDef TIM_TimeBase_InitStructure;
  54.   TIM_OCInitTypeDef TIM_OC_InitStructure;
  55.   NVIC_InitTypeDef nvic_init;
  56.   
  57.   //Clock für GPIO setzen
  58.   RCC_AHB1PeriphClockCmd( RCC_AHB1Periph_GPIOC, ENABLE );
  59.   
  60.   //Clock für TIM4 setzen
  61.   RCC_APB1PeriphClockCmd( RCC_APB1Periph_TIM3, ENABLE );
  62.   
  63.   //GPIO_PIN konfigurieren
  64.   
  65.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
  66.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
  67.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
  68.   GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
  69.   GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
  70.   GPIO_Init( GPIOC, &GPIO_InitStructure );
  71.   
  72.   //GPIO Alternate function verbinden
  73.   GPIO_PinAFConfig( GPIOC, GPIO_PinSource9, GPIO_AF_TIM3 );
  74.   
  75.   TIM_TimeBase_InitStructure.TIM_ClockDivision = TIM_CKD_DIV1;
  76.   TIM_TimeBase_InitStructure.TIM_CounterMode = TIM_CounterMode_Up;
  77.   TIM_TimeBase_InitStructure.TIM_Period = 104;
  78.   TIM_TimeBase_InitStructure.TIM_Prescaler = 0;
  79.   TIM_TimeBaseInit( TIM3, &TIM_TimeBase_InitStructure );
  80.   
  81.   TIM_OC_InitStructure.TIM_OCMode = TIM_OCMode_PWM1;
  82.   TIM_OC_InitStructure.TIM_OCIdleState = TIM_OCIdleState_Reset;
  83.   TIM_OC_InitStructure.TIM_OCNIdleState = TIM_OCNIdleState_Set;
  84.   TIM_OC_InitStructure.TIM_OCPolarity = TIM_OCPolarity_High;
  85.   TIM_OC_InitStructure.TIM_OCNPolarity = TIM_OCNPolarity_High;
  86.   TIM_OC_InitStructure.TIM_OutputState = TIM_OutputState_Enable;
  87.   TIM_OC_InitStructure.TIM_OutputNState = TIM_OutputNState_Disable;
  88.   TIM_OC_InitStructure.TIM_Pulse = 0;
  89.   TIM_OC4Init( TIM3, &TIM_OC_InitStructure );
  90.   
  91.   TIM_CtrlPWMOutputs( TIM3, ENABLE );
  92.   
  93.   TIM_OC4PreloadConfig( TIM3, TIM_OCPreload_Enable );
  94.   TIM_ARRPreloadConfig( TIM3, ENABLE );
  95.   
  96.   TIM_CCxCmd( TIM3, TIM_Channel_4, TIM_CCx_Enable );
  97.   TIM_Cmd( TIM3, ENABLE );
  98.   
  99.   // DMA
  100.   RCC_AHB1PeriphClockCmd( RCC_AHB1Periph_DMA1, ENABLE );
  101.   TIM_DMACmd( TIM3, TIM_DMA_CC4, ENABLE );
  102.   DMA_ITConfig( DMA1_Stream2, DMA_IT_HT, ENABLE );
  103.   DMA_ITConfig( DMA1_Stream2, DMA_IT_TC, ENABLE );
  104.   
  105.   start_dma( );
  106.   
  107.   // NVIC for DMA
  108.   nvic_init.NVIC_IRQChannel = DMA1_Stream2_IRQn;
  109.   nvic_init.NVIC_IRQChannelPreemptionPriority = 4;
  110.   nvic_init.NVIC_IRQChannelSubPriority = 0;
  111.   nvic_init.NVIC_IRQChannelCmd = ENABLE;
  112.   NVIC_Init( &nvic_init );
  113. }

  115. // writes the pwm values of one byte into the array which will be used by the dma
  116. static inline void color2pwm( uint16_t ** const dest, const uint8_t color )
  117. {
  118.   uint8_t mask = 0x80;
  119.   
  120.   do
  121.   {
  122.     if ( color & mask )
  123.     {
  124.       * *dest = 49;
  125.     }
  126.     else
  127.     {
  128.       * *dest = 20;
  129.     }
  130.     *dest += 1;
  131.     mask >>= 1;
  132.   }while ( mask != 0 );
  133. }

  135. void Update_Buffer( uint16_t* buffer )
  136. {
  137.   struct led *framebufferp;
  138.   uint32_t i, j;
  139.   uint16_t * bufp;
  140.   
  141.   for ( i = 0; i < ( PWM_BUFFER_SIZE / 2 ) / 24; i++ )
  142.   {
  143.     if ( incomplete_return )
  144.     {
  145.       incomplete_return = 0;
  146.       for ( j = 0; j < 24; j++ )
  147.       {
  148.         buffer[ i * 24 + j ] = 0;
  149.       }
  150.       
  151.     }
  152.     else
  153.     {
  154.       if ( frame_pos == FRAMEBUFFER_SIZE )
  155.       {
  156.         incomplete_return = 1;
  157.         frame_pos = 0;
  158.         
  159.         for ( j = 0; j < 24; j++ )
  160.         {
  161.           buffer[ i * 24 + j ] = 0;
  162.         }
  163.       }
  164.       else
  165.       {
  166.         framebufferp = &ws2812_framebuffer[ frame_pos++ ];
  167.         bufp = buffer + ( i * 24 );
  168.         
  169.         // edit here to change order of colors in "ws2812_framebuffer" (0x00RRGGBB, 0x00GGBBRR, etc)
  170.         // the chip needs G R B
  171.         color2pwm( &bufp, framebufferp->green ); // green
  172.         color2pwm( &bufp, framebufferp->red ); // red
  173.         color2pwm( &bufp, framebufferp->blue ); // blue
  174.       }
  175.     }
  176.   }
  177. }

  179. void DMA1_Stream2_IRQHandler( void )
  180. {
  181.   // Half-Transfer completed
  182.   if ( DMA_GetITStatus( DMA1_Stream2, DMA_IT_HTIF2 ) )
  183.   {
  184.     DMA_ClearITPendingBit( DMA1_Stream2, DMA_IT_HTIF2 );
  185.     Update_Buffer( PWM_Buffer );
  186.   }
  187.   
  188.   // Transfer completed
  189.   if ( DMA_GetITStatus( DMA1_Stream2, DMA_IT_TCIF2 ) )
  190.   {
  191.     DMA_ClearITPendingBit( DMA1_Stream2, DMA_IT_TCIF2 );
  192.     Update_Buffer( PWM_Buffer + ( PWM_BUFFER_SIZE / 2 ) );
  193.   }
  194.   
  195. }
复制代码

一周热门 更多>