21ic电子技术开发论坛 › 单片机与嵌入式系统 › 极海MCU › 【APM32E103xE测评】基于APM32E103的RGB七彩渐变呼吸灯 ...
返回列表 发新帖我要提问

[APM32E1] 【APM32E103xE测评】基于APM32E103的RGB七彩渐变呼吸灯

[复制链接]
 楼主| lilijin1995 发表于 2022-8-14 21:32 | 显示全部楼层 |阅读模式
本帖最后由 lilijin1995 于 2022-8-16 14:04 编辑

【APM32E103xE测评】基于APM32E103的RGB七彩渐变呼吸灯附送渐变算法并配置1ms Systick移植了MultiTimer
非常荣幸在“二姨家”申请到了“APM32E103ZE MINI板”，由于手头上有一个简单的控灯项目，所以直接想在APM32E103ZE跑跑看；
本贴分以下几个部分：

  • 硬件介绍：
      硬件主要有12V的RGB灯板和RGB-MOS管驱动板；如下图
微信图片_20220814215342.jpg
另有原理图如下：
微信截图_20220814215616.png 微信截图_20220814215636.png

  • 软件介绍：
      软件主要分两部分：
      1. MultiTimer移植：          MultiTimer是开源项目 ，一款可无限扩展的软件定时器，作者0x1abin，目前收获 95 个 star，遵循 MIT 开源许可协议。MultiTimer 是一个软件定时器扩展模块，可无限扩展你所需的定时器任务，取代传统的标志位判断方式， 更优雅更便捷地管理程序的时间触发时序。
         首先需要配置Systick为1ms中断一次SysTick_Config(SystemCoreClock / 1000)，
复制
  1. int main(void)
    

  2. {
    

  3.     SysTick_Config(SystemCoreClock / 1000);
    

  4.     Board_Init();    
    

  5.     while(1)
    

  6.     {
    

  7.           MultiTimerYield();
    

  8.     }
    

  9. }
并在SysTick_Handler中自加
复制
  1. void SysTick_Handler(void)
    

  2. {
    

  3.     tick++;
    

  4. }<span style="background-color: rgb(255, 255, 255);">        </span>
接着我们添加MultiTimer代码
复制
  1. #include "MultiTimer.h"
    

  2. #include <stdio.h>
    

  3. /* Timer handle list head. */
    

  4. static MultiTimer* timerList = NULL;
    

  5. /* Timer tick */
    

  6. static PlatformTicksFunction_t platformTicksFunction = NULL;
    

  7. int MultiTimerInstall(PlatformTicksFunction_t ticksFunc)
    

  8. {
    

  9.     platformTicksFunction = ticksFunc;
    

  10.     return 0;
    

  11. }
    

  12. int MultiTimerStart(MultiTimer* timer, uint64_t timing, MultiTimerCallback_t callback, void* userData)
    

  13. {
    

  14.     if (!timer || !callback ) {
    

  15.         return -1;
    

  16.     }
    

  17.     MultiTimer** nextTimer = &timerList;
    

  18.     /* Remove the existing target timer. */
    

  19.     for (; *nextTimer; nextTimer = &(*nextTimer)->next) {
    

  20.         if (timer == *nextTimer) {
    

  21.             *nextTimer = timer->next; /* remove from list */
    

  22.             break;
    

  23.         }
    

  24.     }
    

  25.     /* Init timer. */
    

  26.     timer->deadline = platformTicksFunction() + timing;
    

  27.     timer->callback = callback;
    

  28.     timer->userData = userData;
    

  29.     /* Insert timer. */
    

  30.     for (nextTimer = &timerList;; nextTimer = &(*nextTimer)->next) {
    

  31.         if (!*nextTimer) {
    

  32.             timer->next = NULL;
    

  33.             *nextTimer = timer;
    

  34.             break;
    

  35.         }
    

  36.         if (timer->deadline < (*nextTimer)->deadline) {
    

  37.             timer->next = *nextTimer;
    

  38.             *nextTimer = timer;
    

  39.             break;
    

  40.         }
    

  41.     }
    

  42.     return 0;
    

  43. }
    

  44. int MultiTimerStop(MultiTimer* timer)
    

  45. {
    

  46.     MultiTimer** nextTimer = &timerList;
    

  47.     /* Find and remove timer. */
    

  48.     for (; *nextTimer; nextTimer = &(*nextTimer)->next) {
    

  49.         MultiTimer* entry = *nextTimer;
    

  50.         if (entry == timer) {
    

  51.             *nextTimer = timer->next;
    

  52.             break;
    

  53.         }
    

  54.     }
    

  55.     return 0;
    

  56. }
    

  57. int MultiTimerYield(void)
    

  58. {
    

  59.     MultiTimer* entry = timerList;
    

  60.     for (; entry; entry = entry->next) {
    

  61.         /* Sorted list, just process with the front part. */
    

  62.         if (platformTicksFunction() < entry->deadline) {
    

  63.             return (int)(entry->deadline - platformTicksFunction());
    

  64.         }
    

  65.         /* remove expired timer from list */
    

  66.         timerList = entry->next;
    


  67. 

  68.         /* call callback */
    

  69.         if (entry->callback) {
    

  70.             entry->callback(entry, entry->userData);
    

  71.         }
    

  72.     }
    

  73.     return 0;
    

  74. }


最后我们直接开两个定时器即两个线程，一个作为按键扫描，一个作为灯光的控制
复制
  1. #include "Board.h"
    

  2. #if defined (APM32E103_MINI)
    

  3. #include "Board_APM32E103_MINI.c"
    

  4. #include "RGB.h"
    

  5. #include "KEY.h"
    

  6. volatile uint64_t tick = 0;
    

  7. MultiTimer timer1;
    

  8. MultiTimer timer2;
    


  9. 

  10. uint64_t PlatformTicksGetFunc(void)
    

  11. {
    

  12.     return tick;
    

  13. }
    


  14. 

  15. void RGBTimer1Callback(MultiTimer* timer, void *userData)
    

  16. {
    

  17.     switch(RGB_Eff)
    

  18.     {
    

  19.     case DYN_RGB:
    

  20.     {
    

  21.         GradientDreamColor();
    

  22.     }
    

  23.     break;
    

  24.     case DYN_RED:
    

  25.     {
    

  26.         GradientDreamSingleColor(DYN_RED);
    

  27.     }
    

  28.     break;
    

  29.     case DYN_ORANGE:
    

  30.     {
    

  31.         GradientDreamSingleColor(DYN_ORANGE);
    

  32.     }
    

  33.     break;
    

  34.     case DYN_YELLOW:
    

  35.     {
    

  36.         GradientDreamSingleColor(DYN_YELLOW);
    

  37.     }
    

  38.     break;
    

  39.     case DYN_GREE:
    

  40.     {
    

  41.         GradientDreamSingleColor(DYN_GREE);
    

  42.     }
    

  43.     break;
    

  44.     case DYN_CYAN:
    

  45.     {
    

  46.         GradientDreamSingleColor(DYN_CYAN);
    

  47.     }
    

  48.     break;
    

  49.     case DYN_BLUE:
    

  50.     {
    

  51.         GradientDreamSingleColor(DYN_BLUE);
    

  52.     }
    

  53.     break;
    

  54.     case DYN_PURPLE:
    

  55.     {
    

  56.         GradientDreamSingleColor(DYN_PURPLE);
    

  57.     }
    

  58.     break;
    

  59.     case STATICK_RED:
    

  60.     {
    

  61.         SetRGB_PWM(0xFF,0x00,0x00);
    

  62.     }
    

  63.     break;
    

  64.     case STATICK_ORANGE:
    

  65.     {
    

  66.         SetRGB_PWM(225,69,0);
    

  67.     }
    

  68.     break;
    

  69.     case STATICK_YELLOW:
    

  70.     {
    

  71.         SetRGB_PWM(0xFF,0xFF,0x00);
    

  72.     }
    

  73.     break;
    

  74.     case STATICK_GREEN:
    

  75.     {
    

  76.         SetRGB_PWM(0x00,0xFF,0x00);
    

  77.     }
    

  78.     break;
    

  79.     case STATICK_CYAN:
    

  80.     {
    

  81.         SetRGB_PWM(0x00,0xFF,0xFF);
    

  82.     }
    

  83.     break;
    

  84.     case STATICK_BLUE:
    

  85.     {
    

  86.         SetRGB_PWM(0x00,0x00,0xFF);
    

  87.     }
    

  88.     break;
    

  89.     case STATICK_PURPLE:
    

  90.     {
    

  91.         SetRGB_PWM(0xFF,0x00,0xFF);
    

  92.     }
    

  93.     break;
    

  94.     case STATICK_WHITE:
    

  95.     {
    

  96.         SetRGB_PWM(0xFF,0xFF,0xFF);
    

  97.     }
    

  98.     break;
    

  99.     case STATICK_BLACK:
    

  100.     {
    

  101.         SetRGB_PWM(0x00,0x00,0x00);
    

  102.     }
    

  103.     break;
    

  104.     default:
    

  105.         break;
    

  106.     }
    

  107.     MultiTimerStart(timer, 10, RGBTimer1Callback, userData);
    

  108. }

        2. KEY驱动：
复制
  1. #include "KEY.h"
    

  2. #include "main.h"
    

  3. void KEY_Init(void)
    

  4. {
    

  5.     GPIO_Config_T GPIO_ConfigStruct;
    

  6.     RCM_EnableAPB2PeriphClock(RCM_APB2_PERIPH_GPIOA);
    

  7.     GPIO_ConfigStruct.pin = GPIO_PIN_0|GPIO_PIN_1;                          //PB0--TMR3_CH3
    

  8.     GPIO_ConfigStruct.mode = GPIO_MODE_IN_PU;
    

  9.     GPIO_Config(GPIOA, &GPIO_ConfigStruct);
    

  10. }
    

  11. u8 KEY_Handler(void)
    

  12. {
    

  13.           static u8 key1bounce=0,key2bounce=0; 
    

  14.           u8 key=0;
    

  15.                 if(GPIO_ReadInputBit(GPIOA,GPIO_PIN_0)==BIT_RESET)
    

  16.                 {
    

  17.                         key1bounce=1;
    

  18.                 }else{
    

  19.                         if(key1bounce)
    

  20.                         {
    

  21.                                 key|=0x01;
    

  22.                         }
    

  23.                         key1bounce=0;
    

  24.                         
    

  25.                 }
    

  26.                 if(GPIO_ReadInputBit(GPIOA,GPIO_PIN_1)==BIT_RESET)
    

  27.                 {
    

  28.                         key2bounce=1;
    

  29.                 }else{
    

  30.                         if(key2bounce)
    

  31.                         {
    

  32.                                 key|=0x02;
    

  33.                         }
    

  34.                         key2bounce=0;
    

  35.                         
    

  36.                 }        
    

  37.                 return key;
    

  38. }
         3. RGB驱动：
复制
  1. /*!
    

  2.  * [url=home.php?mod=space&uid=288409]@file[/url]        RGB.c
    

  3.  *
    

  4.  * [url=home.php?mod=space&uid=247401]@brief[/url]       This file provides firmware functions to manage Leds and push-buttons
    

  5.  *
    

  6.  * [url=home.php?mod=space&uid=895143]@version[/url]     V1.0.0
    

  7.  *
    

  8.  * [url=home.php?mod=space&uid=212281]@date[/url]        2021-07-26
    

  9.  *
    

  10.  */
    


  11. 

  12. #include "RGB.h"
    

  13. #include "main.h"
    


  14. 

  15. //RGB
    

  16. RGB_LED_EFFECT RGB_Eff=DYN_RGB;
    


  17. 

  18. void RGB_Init(void)
    

  19. {
    

  20.     GPIO_Config_T GPIO_ConfigStruct;
    

  21.     TMR_BaseConfig_T TMR_TimeBaseStruct;
    

  22.     TMR_OCConfig_T OCcongigStruct;
    


  23. 

  24.     RCM_EnableAPB2PeriphClock((RCM_APB2_PERIPH_T)(RCM_APB2_PERIPH_GPIOA | RCM_APB2_PERIPH_GPIOB));
    

  25.     RCM_EnableAPB1PeriphClock(RCM_APB1_PERIPH_TMR3);
    


  26. 

  27.     GPIO_ConfigStruct.pin = GPIO_PIN_6|GPIO_PIN_7;//PA6--TMR3_CH1
    

  28.     GPIO_ConfigStruct.mode = GPIO_MODE_AF_PP;          //PA7--TMR3_CH2
    

  29.     GPIO_ConfigStruct.speed = GPIO_SPEED_50MHz;
    

  30.     GPIO_Config(GPIOA, &GPIO_ConfigStruct);
    


  31. 

  32.     GPIO_ConfigStruct.pin = GPIO_PIN_0;                          //PB0--TMR3_CH3
    

  33.     GPIO_ConfigStruct.mode = GPIO_MODE_AF_PP;
    

  34.     GPIO_ConfigStruct.speed = GPIO_SPEED_50MHz;
    

  35.     GPIO_Config(GPIOB, &GPIO_ConfigStruct);
    


  36. 

  37.     TMR_TimeBaseStruct.clockDivision = TMR_CLOCK_DIV_1;
    

  38.     TMR_TimeBaseStruct.countMode = TMR_COUNTER_MODE_UP;
    

  39.     TMR_TimeBaseStruct.division = 71;
    

  40.     TMR_TimeBaseStruct.period = 255;
    

  41.     TMR_ConfigTimeBase(TMR3, &TMR_TimeBaseStruct);
    


  42. 

  43.     OCcongigStruct.idleState = TMR_OC_IDLE_STATE_RESET;
    

  44.     OCcongigStruct.mode = TMR_OC_MODE_PWM1;
    

  45.     OCcongigStruct.nIdleState = TMR_OC_NIDLE_STATE_RESET;
    

  46.     OCcongigStruct.nPolarity = TMR_OC_NPOLARITY_HIGH;
    

  47.     OCcongigStruct.outputNState = TMR_OC_NSTATE_ENABLE;
    

  48.     OCcongigStruct.outputState = TMR_OC_STATE_ENABLE;
    

  49.     OCcongigStruct.polarity = TMR_OC_POLARITY_HIGH;
    

  50.     OCcongigStruct.pulse = 0;
    

  51.     TMR_ConfigOC1(TMR3, &OCcongigStruct);
    

  52.     TMR_ConfigOC2(TMR3, &OCcongigStruct);
    

  53.     TMR_ConfigOC3(TMR3, &OCcongigStruct);
    


  54. 

  55.     TMR_ConfigOC1Preload(TMR3, TMR_OC_PRELOAD_ENABLE);
    

  56.     TMR_ConfigOC2Preload(TMR3, TMR_OC_PRELOAD_ENABLE);
    

  57.     TMR_ConfigOC3Preload(TMR3, TMR_OC_PRELOAD_ENABLE);
    

  58.     TMR_EnableAUTOReload(TMR3);
    

  59.     TMR_Enable(TMR3);
    

  60.     TMR_EnablePWMOutputs(TMR3);
    

  61. }
    

  62. void SetRGB_PWM(u16 R,u16 G,u16 B)
    

  63. {
    

  64.     TMR3->CC1=R;
    

  65.     TMR3->CC2=G;
    

  66.     TMR3->CC3=B;
    

  67. }
    

  68. const u8 R[8]= {255,191,127,0,0,0,150,255};
    

  69. const u8 G[8]= {0,69,127,255,127,0,2,0};
    

  70. const u8 B[8]= {0,0,0,0,127,255,134,0};
    

  71. unsigned char abs0(int num)
    

  72. {
    

  73.     if(num>0) return num;
    

  74.     num = -num;
    

  75.     return (unsigned char) num;
    

  76. }
    

  77. u8 ColorToColor(u8 r0,u8 g0,u8 b0, u8 r1,u8 g1,u8 b1,float* RedStep,float* GreenStep,float* BlueStep)
    

  78. {
    

  79.     unsigned char Red0, Green0, Blue0;  // 起始三原色
    

  80.     unsigned char Red1, Green1, Blue1;  // 结果三原色
    

  81.     int                          RedMinus, GreenMinus, BlueMinus;        // 颜色差（color1 - color0）
    

  82.     u8 NStep;
    

  83.     //unsigned long color;                                                        // 结果色
    

  84.     // 绿 红 蓝 三原色分解
    

  85.     Red0   = r0;
    

  86.     Green0 = g0;
    

  87.     Blue0  = b0;
    

  88.     Red1   = r1;
    

  89.     Green1 = g1;
    

  90.     Blue1  = b1;
    

  91.     // 计算需要多少步（取差值的最大值）
    

  92.     RedMinus   = Red1 - Red0;
    

  93.     GreenMinus = Green1 - Green0;
    

  94.     BlueMinus  = Blue1 - Blue0;
    


  95. 

  96.     NStep = ( abs0(RedMinus) > abs0(GreenMinus) ) ? abs0(RedMinus):abs0(GreenMinus);
    

  97.     NStep = ( NStep > abs0(BlueMinus) ) ? NStep:abs0(BlueMinus);
    


  98. 

  99.     // 计算出各色步进值
    

  100.     RedStep[0]   = (float)RedMinus   / NStep;
    

  101.     GreenStep[0] = (float)GreenMinus / NStep;
    

  102.     BlueStep[0]  = (float)BlueMinus  / NStep;
    


  103. 

  104.     // 渐变开始
    

  105. //        for(i=0; i<NStep; i++)
    

  106. //        {
    

  107. //                Red1   = Red0   + (int)(RedStep   * i);
    

  108. //                Green1 = Green0 + (int)(GreenStep * i);
    

  109. //                Blue1  = Blue0  + (int)(BlueStep  * i);
    

  110. //
    

  111. //                //color  = Green1<<16 | Red1<<8 | Blue1;         // 合成  绿红蓝
    

  112. //                SetPWM_for_RGB(Red1,Green1,Blue1);
    

  113. //
    

  114. //                DelayMs(1);                                                // 渐变速度
    

  115. //        }
    

  116.     // 渐变结束
    


  117. 

  118.     return NStep;
    

  119. }
    


  120. 

  121. void GradientDreamSingleColor(RGB_LED_EFFECT type)
    

  122. {
    

  123.     unsigned char Red, Green, Blue;  // 结果三原色
    

  124.     static  u8  first=0,tick=0,cStep=0,tp=1,rgb=0;
    

  125.     static float RedStep, GreenStep, BlueStep;
    

  126.     static RGB_LED_EFFECT typelast=DYN_RED;
    

  127.     if(typelast!=type)
    

  128.     {
    

  129.         SetRGB_PWM(0,0,0);
    

  130.     }
    

  131.     typelast=type;
    


  132. 

  133.     if(first==0)
    

  134.     {
    

  135.         first=1;
    

  136.         switch(type)
    

  137.         {
    

  138.         case DYN_RED:
    

  139.         {
    

  140.             rgb=0;
    

  141.             if(tp==0)
    

  142.             {
    

  143.                 tp=1;
    

  144.                 cStep=ColorToColor(R[rgb],G[rgb],B[rgb],0,0,0,&RedStep,&GreenStep,&BlueStep);
    

  145.             } else {
    

  146.                 tp=0;
    

  147.                 cStep=ColorToColor(0,0,0,R[rgb],G[rgb],B[rgb],&RedStep,&GreenStep,&BlueStep);
    

  148.             }
    

  149.         }
    

  150.         break;
    

  151.         case DYN_ORANGE:
    

  152.         {
    

  153.             rgb=1;
    

  154.             if(tp==0)
    

  155.             {
    

  156.                 tp=1;
    

  157.                 cStep=ColorToColor(R[rgb],G[rgb],B[rgb],0,0,0,&RedStep,&GreenStep,&BlueStep);
    

  158.             } else {
    

  159.                 tp=0;
    

  160.                 cStep=ColorToColor(0,0,0,R[rgb],G[rgb],B[rgb],&RedStep,&GreenStep,&BlueStep);
    

  161.             }
    

  162.         }
    

  163.         break;
    

  164.         case DYN_YELLOW:
    

  165.         {
    

  166.             rgb=2;
    

  167.             if(tp==0)
    

  168.             {
    

  169.                 tp=1;
    

  170.                 cStep=ColorToColor(R[rgb],G[rgb],B[rgb],0,0,0,&RedStep,&GreenStep,&BlueStep);
    

  171.             } else {
    

  172.                 tp=0;
    

  173.                 cStep=ColorToColor(0,0,0,R[rgb],G[rgb],B[rgb],&RedStep,&GreenStep,&BlueStep);
    

  174.             }
    

  175.         }
    

  176.         break;
    

  177.         case DYN_GREE:
    

  178.         {
    

  179.             rgb=3;
    

  180.             if(tp==0)
    

  181.             {
    

  182.                 tp=1;
    

  183.                 cStep=ColorToColor(R[rgb],G[rgb],B[rgb],0,0,0,&RedStep,&GreenStep,&BlueStep);
    

  184.             } else {
    

  185.                 tp=0;
    

  186.                 cStep=ColorToColor(0,0,0,R[rgb],G[rgb],B[rgb],&RedStep,&GreenStep,&BlueStep);
    

  187.             }
    

  188.         }
    

  189.         break;
    

  190.         case DYN_CYAN:
    

  191.         {
    

  192.             rgb=4;
    

  193.             if(tp==0)
    

  194.             {
    

  195.                 tp=1;
    

  196.                 cStep=ColorToColor(R[rgb],G[rgb],B[rgb],0,0,0,&RedStep,&GreenStep,&BlueStep);
    

  197.             } else {
    

  198.                 tp=0;
    

  199.                 cStep=ColorToColor(0,0,0,R[rgb],G[rgb],B[rgb],&RedStep,&GreenStep,&BlueStep);
    

  200.             }
    

  201.         }
    

  202.         break;
    

  203.         case DYN_BLUE:
    

  204.         {
    

  205.             rgb=5;
    

  206.             if(tp==0)
    

  207.             {
    

  208.                 tp=1;
    

  209.                 cStep=ColorToColor(R[rgb],G[rgb],B[rgb],0,0,0,&RedStep,&GreenStep,&BlueStep);
    

  210.             } else {
    

  211.                 tp=0;
    

  212.                 cStep=ColorToColor(0,0,0,R[rgb],G[rgb],B[rgb],&RedStep,&GreenStep,&BlueStep);
    

  213.             }
    

  214.         }
    

  215.         break;
    

  216.         case DYN_PURPLE:
    

  217.         {
    

  218.             rgb=6;
    

  219.             if(tp==0)
    

  220.             {
    

  221.                 tp=1;
    

  222.                 cStep=ColorToColor(R[rgb],G[rgb],B[rgb],0,0,0,&RedStep,&GreenStep,&BlueStep);
    

  223.             } else {
    

  224.                 tp=0;
    

  225.                 cStep=ColorToColor(0,0,0,R[rgb],G[rgb],B[rgb],&RedStep,&GreenStep,&BlueStep);
    

  226.             }
    

  227.         }
    

  228.         break;
    

  229.         default:
    

  230.             break;
    


  231. 


  232. 

  233.         }
    


  234. 

  235.     } else {
    


  236. 

  237.         if(tick<cStep)
    

  238.         {
    

  239.             if(tp==0)
    

  240.             {
    

  241.                 Red   =0+ (int)(RedStep   * tick);
    

  242.                 Green = 0+ (int)(GreenStep * tick);
    

  243.                 Blue  =  0+(int)(BlueStep  *tick);
    

  244.             } else {
    

  245.                 Red   =R[rgb]   + (int)(RedStep   * tick);
    

  246.                 Green = G[rgb]   + (int)(GreenStep * tick);
    

  247.                 Blue  = B[rgb]   + (int)(BlueStep  *tick);
    

  248.             }
    


  249. 

  250.             SetRGB_PWM(Red,Green,Blue);
    


  251. 

  252.         } else {
    

  253.             tick=0;
    

  254.             first=0;
    

  255.         }
    

  256.         tick++;
    


  257. 

  258.     }
    

  259. }
    


  260. 


  261. 

  262. void GradientDreamColor(void)
    

  263. {
    

  264.     unsigned char Red, Green, Blue;  // 结果三原色
    

  265.     static  u8  first=0,i=0,tick=0,cStep=0;
    

  266.     static float RedStep, GreenStep, BlueStep;
    


  267. 

  268.     static  u16  delaytick=0;
    

  269.     if(delaytick++>5)
    

  270.     {
    

  271.         delaytick=0;
    

  272.         if(first==0)
    

  273.         {
    

  274.             first=1;
    

  275.             cStep=ColorToColor(R[i],G[i],B[i],R[i+1],G[i+1],B[i+1],&RedStep,&GreenStep,&BlueStep);
    

  276.         } else {
    


  277. 

  278.             if(tick<cStep)
    

  279.             {
    

  280.                 Red   =R[i]   + (int)(RedStep   * tick);
    

  281.                 Green = G[i]   + (int)(GreenStep * tick);
    

  282.                 Blue  = B[i]   + (int)(BlueStep  *tick);
    

  283.                 SetRGB_PWM(Red,Green,Blue);
    


  284. 

  285.             } else {
    

  286.                 tick=0;
    

  287.                 if(++i>=7)
    

  288.                 {
    

  289.                     i=0;
    


  290. 

  291.                 }
    

  292.                 first=0;
    

  293.             }
    

  294.             tick++;
    

  295.         }
    

  296.     }
    

  297. }
    


  298.


最后实验可以看我们的视频：
https://www.bilibili.com/video/BV1ZT411A77M/?vd_source=2bbde87de845d5220b1d8ba075c12fb0

并附上代码

APM32E10x_SDK_V1.0.zip

1.62 MB, 下载次数: 13
回复 赏

举报

lajfda001 发表于 2022-8-16 10:17 | 显示全部楼层
代码整洁，没有任何的瑕疵，感谢楼主的分享。
回复 赏

举报

单片小菜 发表于 2022-8-16 10:51 | 显示全部楼层
你用的是最小系统板吗？还是别的？
回复 赏

举报

jflahdink09 发表于 2022-8-16 11:17 | 显示全部楼层
可以传一下视频吗？看看视频的效果如何
回复 赏

举报

 楼主| lilijin1995 发表于 2022-8-16 13:58 | 显示全部楼层
jflahdink09 发表于 2022-8-16 11:17
可以传一下视频吗？看看视频的效果如何

https://www.bilibili.com/video/BV1ZT411A77M/?vd_source=2bbde87de845d5220b1d8ba075c12fb0
回复 赏

举报

 楼主| lilijin1995 发表于 2022-8-16 13:59 | 显示全部楼层
单片小菜 发表于 2022-8-16 10:51
你用的是最小系统板吗？还是别的？

二姨家发的APM32E103xE Mini板
回复 赏

举报

单片小菜 发表于 2022-8-16 16:20 | 显示全部楼层
lilijin1995 发表于 2022-8-16 13:59
二姨家发的APM32E103xE Mini板

厉害的，不错，不错的！
回复 赏

举报

juliestephen 发表于 2022-8-16 19:53 | 显示全部楼层
这个如何调整占空比呢？  
回复 赏

举报

 楼主| lilijin1995 发表于 2022-8-17 10:08 | 显示全部楼层
juliestephen 发表于 2022-8-16 19:53
这个如何调整占空比呢？
复制
  1. void SetRGB_PWM(u16 R,u16 G,u16 B)
    

  2. {
    

  3.     TMR3->CC1=R;
    

  4.     TMR3->CC2=G;
    

  5.     TMR3->CC3=B;
    

  6. }



设置比较值就可以
回复 赏

举报

wengh2016 发表于 2022-8-18 17:23 | 显示全部楼层
使用pwm吗   
回复 赏

举报

duo点 发表于 2022-8-18 17:30 来自手机 | 显示全部楼层
厉害了，不错不错
回复 赏

举报

duo点 发表于 2022-8-18 17:30 来自手机 | 显示全部楼层
支持一下
回复 赏

举报

uiint 发表于 2022-8-18 17:58 | 显示全部楼层
APM32E103性能怎么样  
回复 赏

举报

 楼主| lilijin1995 发表于 2022-9-7 09:23 | 显示全部楼层
uiint 发表于 2022-8-18 17:58
APM32E103性能怎么样

强大，很强
回复 赏

举报

lzbf 发表于 2022-9-8 08:43 | 显示全部楼层
这个可以驱动ws8212吗
回复 赏

举报

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

本版积分规则

lilijin1995

56

主题

165

帖子

8

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

56

主题

165

帖子

8

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