devbox
花生_TL007
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

杰里6969系列控制RGB彩灯模式_多色彩灯控制程序

作者：花生_TL007 | 2024-03-26 03:53:32

赞

踩

多色彩灯控制程序

目录

1、任务目标

2.跳变（分布调试记录）

2.1 实现RGB灯循环跳变

思路1-----现象1-----原因1-----解决思路1------解决代码1

现象2-----原因2-----解决思路2-----解决代码2

现象3-----原因3-----解决思路3-----解决代码3

现象4---------原因4------------解决思路4-------------------解决代码4ga

3.今日疑惑

1、任务目标

实现可以接收到APP传输过来的数据，可以通过传输的数据前几个字节识别到所需要控制的模式，然后提取数据的后几个字节来分别对RGB灯进行不同的的PWM波控制，从而实现跳变和渐变的效果。

2.跳变（分布调试记录）

2.1 实现RGB灯循环跳变

  1. void handleColor_arrayChange_suddenly(u8 *bt_receive_buffer, u32 length, int *color_mode_record, int color1)
  2. {
  3.  
  4.     int i = 8;
  5.     printf("通过数组控制灯颜色状态\n");
  6.     for (int i = 8; i < (length - 2); i = i + 3)
  7.     {
  8.         handleColorChange(bt_receive_buffer[i], bt_receive_buffer[i + 1], bt_receive_buffer[i + 2]);
  9.         printf("for循环里lllllllllllllllllll\n");    
  10.          delay_2ms(200);    
  11.     }
  12.  
  13.     printf("正在通过数组快捷控制灯颜色和亮度handleColor_arrayChange\n");
  14.  
  15. }

该函数的作用：对需要执行跳变模式时，它会遍历接收到的数组bt_receive_buffer，从第九个字节开始对数据进行处理，并以每次3个字节(byte)的方式调用handleColorChange函数来改变灯的颜色态，也就是按照RGB的顺序赋值。在每次改变颜色之后，它还调用了delay_2ms函数来进行延时操作。

接收到的数据

思路1-----现象1-----原因1-----解决思路1------解决代码1

思路1：首先在while(1)里调用这个函数，先达到可以循环控制RGB灯跳变。再再改为类似while(flag)的形式，来实现退出该循环的效果。

现象1：在while(1)死循环里，LED灯在循环跳遍几轮后程序崩溃，并且通过delay_2ms()这个延时函数观察发现程序崩溃并不出现在运行第几遍，更倾向于固定时间。

原因1：忽略了该程序移植了RTOS操作系统，在某一个比较短的时刻会进行喂狗操作，但是由于该延时为死延时，也被称为堵塞延时。无法及时进行喂狗，所以会对程序进行重启

解决思路1：调用一个定时器，在对应的回调函数timeout_callback中，每10ms检查一下是否满足执行handleColor_arrayChange_suddenly 函数的条件。通过静态局部变量 i 追踪时间，当i达到1000时，因为定时器设置值为10，每计数一次加10，等到1000也刚好是1000ms。此时会对标志位置1，然后就可以执行handleColor_arrayChange_suddenly 函数中的for循环一次。当for循环结束以后会对标志位置0，读取数组的指针会往后移动三个字节同时，回调函数中的i会被重置为0，以便下一次1000ms延时。
其实简单来说，就是每10ms扫描一下，是否满足执行handleColor_arrayChange_suddenly 函数，每1000ms改变标志位。使得满足执行handleColor_arrayChange_suddenly 函数的条件齐全。

解决代码1：

  1. void handleColor_arrayChange_suddenly(u8 *bt_receive_buffer, u32 length, int *color_mode_record, int color1)
  2. {
  3.     static int i = 8;
  4.     printf("通过数组控制灯颜色状态\n");
  5.     for (; (i < (length - 2)) && (time_flag == 1); i = i + 3)
  6.     {
  7.         handleColorChange(bt_receive_buffer[i], bt_receive_buffer[i + 1], bt_receive_buffer[i + 2]);
  8.         printf("for循环里lllllllllllllllllll\n");
  9.         time_flag = 0;
  10.         // delay_2ms(200);
  11.     }
  12.     if (i > (length - 2))
  13.     {
  14.         i = 8;
  15.     }
  16.     printf("正在通过数组快捷控制灯颜色和亮度handleColor_arrayChange\n");
  17.  
  18. }
  19.  
  20. void timeout_callback(void *priv)
  21. {
  22.     static u16 i = 0;
  23.     printf("回调函数\n");
  24.     i = i + 10;
  25.     if (i == 1000)
  26.     {
  27.         printf("ifififiifiifififiififififi\n");
  28.         time_flag = 1;
  29.         i = 0;
  30.     }
  31.     handleColor_arrayChange_suddenly(bt_receive_buffer, length,record, color1);
  32. }

现象2-----原因2-----解决思路2-----解决代码2

现象2：灯快速闪烁熄灭

原因2： handleColor_arrayChange_suddenly(bt_receive_buffer, length,record, color1);这里调用函数时传入的参数为局部变量。需要传入实际的参数。

解决思路2：在执行前先传入一次实参，然后利用全局变量保存下来，方便回调函数中使用。

解决代码2：

  1.  
  2. // 定义全局指针变量
  3. u8 *global_bt_receive_buffer;
  4. int global_length;
  5. int *global_color_mode_record;
  6. int global_color1;
  7. volatile u8 time_flag = 1;
  8. u16 timer_id = 123;
  9. void *private_data = NULL; // 设置私有参数为NULL
  10. u32 timeout_msec = 10;     // 设置定时时间为10毫秒
  11. u8 priority = 1;           // 设置优先级为1
  12. void handleColor_arrayChange_suddenly(u8 *bt_receive_buffer, u32 length, int *color_mode_record, int color1)
  13. {
  14.  
  15.     static int i = 8;
  16.     printf("通过数组控制灯颜色状态\n");
  17.     for (; (i < (length - 2)) && (time_flag == 1); i = i + 3)
  18.     {
  19.         handleColorChange(bt_receive_buffer[i], bt_receive_buffer[i + 1], bt_receive_buffer[i + 2]);
  20.         printf("for循环里lllllllllllllllllll\n");
  21.         time_flag = 0;
  22.         // delay_2ms(200);
  23.     }
  24.     if (i > (length - 2))
  25.     {
  26.         i = 8;
  27.     }
  28.     printf("正在通过数组快捷控制灯颜色和亮度handleColor_arrayChange\n");
  29.     global_bt_receive_buffer = bt_receive_buffer;
  30.     global_length = length;
  31.     global_color_mode_record;
  32.     global_color1 = color1;
  33. }
  34.  
  35. void timeout_callback(void *priv)
  36. {
  37.  
  38.     static u16 i = 0;
  39.     printf("回调函数\n");
  40.  
  41.     i = i + 10;
  42.     if (i == 1000)
  43.     {
  44.         printf("ifififiifiifififiififififi\n");
  45.         time_flag = 1;
  46.         i = 0;
  47.     }
  48.     handleColor_arrayChange_suddenly(global_bt_receive_buffer, global_length, global_color_mode_record, global_color1);
  49. }
  50.  
  51.  
  52.  
  53. case 56:
  54. if (buffer[4] == 10)
  55. {
  56.  
  57.     handleColor_arrayChange_suddenly(buffer, buffer_size, color_mode_record, 0); // 五色跳变
  58.     u16 timer_id = usr_timer_add(private_data, &timeout_callback, timeout_msec, priority);
  59.     printf("%d\n", timer_id);
  60. }

现象3-----原因3-----解决思路3-----解决代码3

现象3：可以实现循环亮灭。但是在多次发送跳变指令后灯闪烁速度加快。并且在发送其他指令时依旧没有结束跳变。

原因3：在执行其他模式时并没有对上一个模式所使用的定时器进行删除操作，并且在重复执行自身时也没有对上次使用的定时器进行删除操作。

解决思路3：设立一个类似互斥量的标志位，但是这个是实时操作系统，想使用互斥量来实现，只有获得互斥量的才可以进行操作。不过在尝试了一下，还是决定先用标志位实现，毕竟不太熟悉。就在每个case的前面增加删除其他定时器的代码，并且将其他定时器可以被创建的标志位置零，以便下次直接使用。增加对应的渐变代码。

解决代码3：

  1. // 定义全局指针变量
  2. u8 *global_bt_receive_buffer_gradually;
  3. u32 global_length_gradually;
  4. volatile u8 time_flag_gradually = 1;
  5. /* 通过数组控制灯颜色和亮度，现象为颜色渐变*/
  6. void handleColor_arrayChange_gradually(u8 *bt_receive_buffer, u32 length)
  7. {
  8.  
  9.     // 获取初始亮度
  10.     u8 initial_red_value = bt_receive_buffer[0];
  11.     u8 initial_green_value = bt_receive_buffer[1];
  12.     u8 initial_blue_value = bt_receive_buffer[2];
  13.     printf("通过数组控制灯颜色状态\n");
  14.     static int i = 5;
  15.     static int j = 0;
  16.     u8 STEPS = 30;
  17.  
  18.     for (; (i < (length - 5))&&(time_flag_gradually == 1); i = i + 3)
  19.     {
  20.         u8 target_red_value = bt_receive_buffer[i + 3];
  21.         u8 target_green_value = bt_receive_buffer[i + 4];
  22.         u8 target_blue_value = bt_receive_buffer[i + 5];
  23.  
  24.         // 计算每个颜色通道的增量
  25.         int red_increment = (target_red_value - initial_red_value) / STEPS;
  26.         int green_increment = (target_green_value - initial_green_value) / STEPS;
  27.         int blue_increment = (target_blue_value - initial_blue_value) / STEPS;
  28.  
  29.         // 逐步更新颜色值，使其渐变到目标值
  30.         for (; (j < STEPS) && (time_flag_gradually == 1); j++)
  31.         {
  32.             printf("jjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj\n");
  33.             u8 current_red_value = initial_red_value + (red_increment * j);
  34.             u8 current_green_value = initial_green_value + (green_increment * j);
  35.             u8 current_blue_value = initial_blue_value + (blue_increment * j);
  36.             printf("回调函数渐变hddddddddddddddddddddddddddddddddddddddddddddd%d\n", time_flag_gradually);
  37.             handleColorChange(current_red_value, current_green_value, current_blue_value);
  38.             time_flag_gradually = 0;
  39.  
  40.             // delay_2ms(24); // 延时一段时间，控制灯的变化速度
  41.         }
  42.         if (j >= STEPS)
  43.         {
  44.             printf("j >= STEPSj >= STEPSj >= STEPSj >= STEPSj >= STEPSj >= STEPSj >= STEPSj >= STEPSj >= STEPSj >= STEPSj >= STEPSj >= STEPS\n");
  45.             j = 0;
  46.         }
  47.  
  48.         printf("第一组 RGB 值已经渐变到第二组一样\n");
  49.  
  50.         // 更新初始亮度为目标亮度，以便下一组渐变
  51.         initial_red_value = target_red_value;
  52.         initial_green_value = target_green_value;
  53.         initial_blue_value = target_blue_value;
  54.     }
  55.     if (i > length - 5)
  56.     {
  57.         printf("i>length - 5i>length - 5i>length - 5i>length - 5i>length - 5i>length - 5i>length - 5i>length - 5i>length - 5i>length - 5\n");
  58.         i = 5;
  59.     }
  60.  
  61.     printf("jssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss\n");
  62.     global_bt_receive_buffer_gradually = bt_receive_buffer;
  63.     global_length_gradually = length;
  64. }
  65.  
  66. u32 timeout_msec_gradually = 1000; // 设置定时时间为10毫秒
  67. void timeout_callback_gradually(void *priv)
  68. {
  69.     // 每10ms
  70.     printf("回调函数渐变\n");
  71.     printf("回调函数渐变%d\n", time_flag_gradually);
  72.     printf("time_flag_gradually != 0time_flag_gradually != 0time_flag_gradually != 0time_flag_gradually != 0time_flag_gradually != 0\n");
  73.     time_flag_gradually = 1;
  74.     handleColor_arrayChange_gradually(global_bt_receive_buffer_gradually, global_length_gradually);
  75. }

现象4---------原因4------------解决思路4-------------------解决代码4ga

现象4：该模式本来是实现RGB灯渐变，但是并未出现未更改时RGB灯渐变的效果。而是在定时器定时1s时改变一遍颜色，颜色并未一点一点地往目标颜色靠近，而是一下子到了另外比较大的一个颜色。类似颜色跳变

原因4：推测是每次调用该函数时，由于函数一开始会对某些变量进行初始化

        u8 target_red_value = bt_receive_buffer[i + 3];
        u8 target_green_value = bt_receive_buffer[i + 4];
        u8 target_blue_value = bt_receive_buffer[i + 5];

但是在该变化之前理应执行小的for循环里面所有可能值。

解决思路：把所有涉及到的数字都打印出来看

改了很多版，都有其奇奇怪怪的问题，并不能更好地实现，现在贴出代码来进行结构梳理

原代码思路：

记录六个字节，前三个为起始字节，后三个为目标字节。根据插值还有步长可以算出每个通道每次增加的值。每加一次进行适当的延时，到达目标值后切换，记录当前值为起始值，目标值为下三个不超过范围的的字节。循环即可达成颜色渐变。

现的代码思路：
通过设定的定时器产生一个标志位。小的for循环等待标志位的到来，然后开始运行一遍，然后标志位改变退出循环，等待下一个标志位的到来。但是仔细推敲一下问题很多，因为外面还有一个大的for循环。在再次进来的时候会重新初始化程序。

尝试使用全局变量保存参数，但是尝试了代码太臃肿，也不好操作。。。。试了挺多改法没成功，暂时没什么思路了。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/花生_TL007/article/detail/314508
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号