21ic电子技术开发论坛 › 单片机与嵌入式系统 › GigaDevice GD32 MCU › 【技术分享】GD32台阶流水灯项目之亮灯流程完善 ...
返回列表 发新帖我要提问本帖赏金: 30.00元(功能说明)

【技术分享】GD32台阶流水灯项目之亮灯流程完善

[复制链接]
4521|2
 楼主| blust5 发表于 2023-8-14 11:29 | 显示全部楼层 |阅读模式
流水灯, GD32
本帖最后由 blust5 于 2023-8-14 11:30 编辑

#申请原创#   @21小跑堂 @21小跑堂 @21小跑堂


书接上回，之前写了一篇“【技术分享】GD32台阶流水灯项目之硬件问题与改善”，里面介绍了项目背景和硬件相关内容，以及LED驱动芯片的驱动部分代码。
9928364d996b1dc83d.png
链接：
【技术分享】GD32台阶流水灯项目之硬件问题与改善
https://bbs.21ic.com/icview-3319996-1-1.html?fromuser=blust5
硬件板图：
3065064d996c0cf54e.png
9728364d996c96cda1.png
实物照片图：
5242164d996d1c81ab.png
下面开始分享软件部分内容。
先来简单介绍一下大致的软件逻辑。
项目有两个人体传感器，分别安装在楼梯底部和顶部。当感应到人走过时，从走过的方向开始逐级点亮台阶灯，同时扶手上的流水灯也同步点亮；当人走过之后，台阶灯和流水灯再逐级熄灭。
板子上有按键和数码管，可以通过按键来设置台阶数量、流水灯数量、台阶亮灯频率以及灯的亮度等信息。同时板子上有存储芯片，可以将设置的信息保存在存储芯片里。不过开发过程中发现单片机内部FLASH空间足够使用，所以后面删除了存储芯片，直接将信息参数存储到FLASH的尾部了。
由此可见，程序除了基本驱动框架之外，主要部分就是按键扫描识别、数码管显示、以及流水灯控制逻辑。
其中按键扫描识别、数码管显示两部分属于很常用的功能，网上例程也有很多，这里就不详细展开介绍了，具体内容可以查看最终程序包里的内容。
这里主要介绍流水灯控制逻辑的实现和完善。
先来说下一开始的流程代码。一开始就是最简单的实现流水灯效果：有人走过，触发人体传感器信号，然后台阶开始按照设定参数逐级点亮，全部点亮之后开始逐级熄灭，直至最终全部熄灭，流程结束。
各个代码功能模块如下：
流程触发代码：
复制
  1. void led_step_start(uint8_t mode)
    

  2. {
    

  3.     step_up_down_flag = mode;
    

  4.     led_on_off_flag = 1;
    

  5.     step_time_cnt = para_data[DATA_STEP_TIME];
    

  6. }

流水灯流程处理代码：
复制
  1. void led_step_process()
    

  2. {
    

  3.     if(step_up_down_flag != 0)
    

  4.     {
    

  5.         if(led_on_off_flag == 1)
    

  6.         {
    

  7.             step_time_cnt ++;
    

  8.             if(step_time_cnt >= para_data[DATA_STEP_TIME])
    

  9.             {
    

  10.                 step_time_cnt = 0;
    

  11.                 if(ws_step_led_ctrl(led_on_off_flag, step_up_down_flag) == 1)
    

  12.                 {
    

  13.                     led_on_off_flag = 2;
    

  14.                 }
    

  15.             }
    

  16.         }
    

  17.         else if(led_on_off_flag == 2)
    

  18.         {
    

  19.             step_time_cnt ++;
    

  20.             if(step_time_cnt >= para_data[DATA_STEP_TIME])
    

  21.             {
    

  22.                 step_time_cnt = 0;
    

  23.                 if(ws_step_led_ctrl(led_on_off_flag, step_up_down_flag) == 1)
    

  24.                 {
    

  25.                     led_on_off_flag = 0;
    

  26.                     step_up_down_flag = 0;
    

  27.                 }
    

  28.             }
    

  29.         }
    

  30.     }
    

  31. }

最终亮灯驱动代码：
复制
  1. uint8_t ws_step_led_ctrl(uint8_t on_off, uint8_t up_down)
    

  2. {
    

  3.     static uint16_t step_now = 0;
    

  4.     uint16_t led_on, i;
    

  5.     uint32_t led_set_a, led_set_b;
    


  6. 

  7.     if(on_off == 1)
    

  8.     {
    

  9.         led_set_a = step_color_data;
    

  10.         led_set_b = 0;
    

  11.     }
    

  12.     else if(on_off == 2)
    

  13.     {
    

  14.         led_set_b = step_color_data;
    

  15.         led_set_a = 0;
    

  16.     }
    

  17.     else
    

  18.     {
    

  19.         return 1;
    

  20.     }
    


  21. 

  22.     if(up_down == 1)
    

  23.     {
    

  24.         led_on = step_now + 1;
    


  25. 

  26.         for(i=0; i<para_data[DATA_STEP_NUM]; i++)
    

  27.         {
    

  28.             if(i < led_on)
    

  29.             {
    

  30.                 ws_step_set1(led_set_a);
    

  31.             }
    

  32.             else
    

  33.             {
    

  34.                 ws_step_set1(led_set_b);
    

  35.             }
    

  36.         }
    

  37.         ws_step_reset();
    

  38.     }
    

  39.     else if(up_down == 2)
    

  40.     {
    

  41.         led_on = para_data[DATA_STEP_NUM] - step_now - 1;
    


  42. 

  43.         for(i=0; i<para_data[DATA_STEP_NUM]; i++)
    

  44.         {
    

  45.             if(i < led_on)
    

  46.             {
    

  47.                 ws_step_set1(led_set_b);
    

  48.             }
    

  49.             else
    

  50.             {
    

  51.                 ws_step_set1(led_set_a);

人触发人体传感器信号时，调用流程触发函数led_step_start(mode)，其中mode参数确定触发方向，1为从低往上运行，2为从上往下运行。
然后通过100ms定时中断标志来调用流程处理函数key_press_process()，该函数里标记变量确认是否有待处理流程。有流程需处理时，通过变量累加确定延时间隔，进行亮灯状态改变。然后调用亮灯函数ws_step_led_ctrl()点亮对应的灯，同时确认流程是否完成。流程完成后清除相应标志位。
主函数里对应调用逻辑如下：
复制
  1. if(time_100ms_flag == 1)
    

  2. {
    

  3.     time_100ms_flag = 0;
    

  4.     key_press_process();
    

  5.     if(int_bottom_flag == 1)
    

  6.     {
    

  7.         int_bottom_flag = 0;
    

  8.         led_step_start(1);
    

  9.     }
    

  10.     if(int_top_flag == 1)
    

  11.     {
    

  12.         int_top_flag = 0;
    

  13.         led_step_start(2);
    

  14.     }
    

  15.     led_step_process();
    

  16. }

后面考虑到复杂情况，比如楼梯两边同时来人、一个流程正在运行时又再次触发流程等情况，于是对流程逻辑进行优化。
主要按照以下几点逻辑进行处理：
1、正常响应：触发后台阶按间隔时间依次亮起，所有灯全部亮起后再依次熄灭。
2、双向判断：一个方向触发后，在所有灯亮起时间的2/3内，另一个方向触发，则认为是另一个人进入，进入双向响应逻辑。
3、同向判断：一个方向触发后，在整个流程结束之前，同一个方向再次触发，则进入同向延时逻辑。
4、双向响应逻辑：两个方向同时按照各自的延时向中间亮起，并按照各自的逻辑熄灭，灯最终的亮灭状态取两个方向的叠加（两个逻辑均为灭才是灭，只要有一个逻辑是亮的，最终就是亮的）。
5、同向延时逻辑：第二次触发时另起一个处理逻辑，与第一次触发的逻辑叠加后再最终处理灯的亮灭状态。
在实现上述逻辑之后，基本可以实现较好的效果。同时也有容错效果，逻辑出错后在运行完毕之后会清除状态，不影响下次触发后的逻辑运行。
基于以上功能逻辑，在代码上进行实现时，考虑到在同一个逻辑流程里判断所有状态叠加后的结果相对比较复杂，于是开启两个流程序列，正常响应时启动一个流程序列，二次触发时根据逻辑关系确定启动第二个流程序列。每个流程序列单独运行其自身逻辑，最终灯的状态取两个序列对应位置灯的状态叠加。
最终启动函数需做如下判断：
1、启动时无正在运行逻辑，则直接启动一个逻辑流程；
2、启动时有一个正在运行的流程，则判断是否满足增加流程条件，满足则启动第二流程；
3、启动时有两个正在运行的流程，则判断忽略新流程（正在运行的两个流程为反向）或追加新流程（正在运行的两个流程为同向）。
详细处理函数如下：
复制
  1. void led_step_start(uint8_t mode)
    

  2. {
    

  3.     if(para_adjust_flag == 1)
    

  4.     {
    

  5.         led_step_stop();
    

  6.         return;
    

  7.     }
    


  8. 

  9.     if((up_down_flag_1 == STEP_LED_STOP)&&(up_down_flag_2 == STEP_LED_STOP))    // 没有正在进行的流程
    

  10.     {
    

  11.         up_down_flag_1 = mode;
    

  12.         step_now_1 = 0;
    

  13.         color_now_1 = 0;
    

  14.     }
    

  15.     else if(up_down_flag_1 == STEP_LED_STOP)    // 有一条正在进行的流程
    

  16.     {
    

  17.         if(up_down_flag_2 == mode)   // 新流程与现有流程同方向，直接启动新流程
    

  18.         {
    

  19.             up_down_flag_1 = mode;
    

  20.             step_now_1 = 0;
    

  21.             color_now_1 = 0;
    

  22.         }
    

  23.         else    // 新流程与现有流程反向
    

  24.         {
    

  25.             if(step_now_2 < para_data[DATA_STEP_NUM] * 2 / 3)    // 现有流程运行时间在全亮所需时间的2/3以内，启动新流程
    

  26.             {
    

  27.                 up_down_flag_1 = mode;
    

  28.                 step_now_1 = 0;
    

  29.                 color_now_1 = 0;
    

  30.             }
    

  31.         }
    

  32.     }
    

  33.     else if(up_down_flag_2 == STEP_LED_STOP)    // 有一条正在进行的流程
    

  34.     {
    

  35.         if(up_down_flag_1 == mode)   // 新流程与现有流程同方向，直接启动新流程
    

  36.         {
    

  37.             up_down_flag_2 = mode;
    

  38.             step_now_2 = 0;
    

  39.             color_now_2 = 0;
    

  40.         }
    

  41.         else    // 新流程与现有流程反向
    

  42.         {
    

  43.             if(step_now_1 < para_data[DATA_STEP_NUM] * 2 / 3)    // 现有流程运行时间在全亮所需时间的2/3以内，启动新流程
    

  44.             {
    

  45.                 up_down_flag_2 = mode;
    

  46.                 step_now_2 = 0;
    

  47.                 color_now_2 = 0;
    

  48.             }
    

  49.         }
    

  50.     }
    

  51.     else    // 有两条正在进行的流程
    

  52.     {
    

  53.         if((up_down_flag_1 == up_down_flag_2)&&(up_down_flag_1 == mode))
    

  54.         {    // 现有两条流程同向且与新流程同向，则新流程取代现有流程中运行时间更短的流程，同时运行时间长的流程如果运行至灭灯环节，则重启灭灯流程
    

  55.             if(step_now_1 > step_now_2)
    

  56.             {
    

  57.                 step_now_2 = 0;
    

  58.                 color_now_2 = 0;
    

  59.                 if(step_now_1 > para_data[DATA_STEP_NUM])
    

  60.                 {
    

  61.                     step_now_1 = para_data[DATA_STEP_NUM];
    

  62.                     color_now_1 = para_data[DATA_COLOR_NUM];
    

  63.                 }
    

  64.             }
    

  65.             else
    

  66.             {
    

  67.                 step_now_1 = 0;
    

  68.                 color_now_1 = 0;
    

  69.                 if(step_now_2 > para_data[DATA_STEP_NUM])
    

  70.                 {
    

  71.                     step_now_2 = para_data[DATA_STEP_NUM];
    

  72.                     color_now_2 = para_data[DATA_COLOR_NUM];
    

  73.                 }
    

  74.             }
    

  75.         }
    

  76.     }
    

  77.     step_time_cnt = step_led_time;
    

  78.     color_time_cnt = color_led_time;
    

  79. }

流程处理函数里先是根据各自的标记位进行各自流程状态的切换，然后将两个流程各自位置灯状态叠加后进行亮灯操作。
由于扶手流水灯数量和台阶数量不一定一致，因此扶手流水灯亮灯间隔是根据台阶亮灯总时间换算得来，流程处理函数里也分别对台阶灯流程和扶手灯流程做了对应处理，并在所有灯全亮时增加了一个3倍台阶灯间隔时间的延时，用以改善运行效果。
复制
  1. void led_step_process()
    

  2. {
    

  3.     static uint8_t led_all_on_cnt1 = 0;
    

  4.     static uint8_t led_all_on_cnt2 = 0;
    

  5.     uint8_t i;
    


  6. 

  7.     if(up_down_flag_1 + up_down_flag_2 > 0)
    

  8.     {
    

  9.         //  台阶灯逻辑处理
    

  10.         step_time_cnt ++;
    

  11.         if(step_time_cnt >= step_led_time)
    

  12.         {
    

  13.             step_time_cnt = 0;
    


  14. 

  15.             switch(up_down_flag_1)    // 判断流程1运行方向
    

  16.             {
    

  17.             case STEP_LED_UP:    // 流程运行方向为上行
    

  18.                 step_now_1 ++;
    

  19.                 if(step_now_1 <= para_data[DATA_STEP_NUM])    // 逐级台阶点亮过程
    

  20.                 {
    

  21.                     for(i=0; i<para_data[DATA_STEP_NUM]; i++)
    

  22.                     {
    

  23.                         if(i < step_now_1)
    

  24.                         {
    

  25.                             led_state_1[i] = 1;
    

  26.                         }
    

  27.                         else
    

  28.                         {
    

  29.                             led_state_1[i] = 0;
    

  30.                         }
    

  31.                     }
    

  32.                     if(step_now_1 == para_data[DATA_STEP_NUM])
    

  33.                     {
    

  34.                         led_all_on_cnt1 ++;
    

  35.                         if(led_all_on_cnt1 <= 3)
    

  36.                         {
    

  37.                             step_now_1 --;
    

  38.                         }
    

  39.                     }
    

  40.                     else
    

  41.                     {
    

  42.                         led_all_on_cnt1 = 0;
    

  43.                     }
    

  44.                 }
    

  45.                 else if(step_now_1 <= para_data[DATA_STEP_NUM]*2)    // 逐级台阶熄灭过程
    

  46.                 {
    

  47.                     for(i=0; i<para_data[DATA_STEP_NUM]; i++)
    

  48.                     {
    

  49.                         if(i < step_now_1 - para_data[DATA_STEP_NUM])
    

  50.                         {
    

  51.                             led_state_1[i] = 0;
    

  52.                         }
    

  53.                         else
    

  54.                         {
    

  55.                             led_state_1[i] = 1;
    

  56.                         }
    

  57.                     }
    

  58.                     if(step_now_1 == para_data[DATA_STEP_NUM]+1)
    

  59.                     {
    

  60.                         color_now_1 = para_data[DATA_COLOR_NUM];
    

  61.                         color_time_cnt = color_led_time;
    

  62.                     }
    

  63.                 }
    

  64.                 else    // 整个流程运行完毕
    

  65.                 {
    

  66.                     up_down_flag_1 = STEP_LED_STOP;
    

  67.                     step_now_1 = 0;
    

  68.                     memset(led_state_1,0,sizeof(led_state_1));
    

  69.                 }
    

  70.                 break;
    

  71.             case STEP_LED_DOWN:    // 过程运行方向为下行
    

  72.                 step_now_1 ++;
    

  73.                 if(step_now_1 <= para_data[DATA_STEP_NUM])    // 逐级台阶点亮过程
    

  74.                 {
    

  75.                     for(i=0; i<para_data[DATA_STEP_NUM]; i++)
    

  76.                     {
    

  77.                         if(i < para_data[DATA_STEP_NUM] - step_now_1)
    

  78.                         {
    

  79.                             led_state_1[i] = 0;
    

  80.                         }
    

  81.                         else
    

  82.                         {
    

  83.                             led_state_1[i] = 1;
    

  84.                         }
    

  85.                     }
    

  86.                     if(step_now_1 == para_data[DATA_STEP_NUM])
    

  87.                     {
    

  88.                         led_all_on_cnt1 ++;
    

  89.                         if(led_all_on_cnt1 <= 3)
    

  90.                         {
    

  91.                             step_now_1 --;
    

  92.                         }
    

  93.                     }
    

  94.                     else
    

  95.                     {
    

  96.                         led_all_on_cnt1 = 0;
    

  97.                     }
    

  98.                 }
    

  99.                 else if(step_now_1 <= para_data[DATA_STEP_NUM]*2)    // 逐级台阶熄灭过程
    

  100.                 {
    

  101.                     for(i=0; i<para_data[DATA_STEP_NUM]; i++)
    

  102.                     {
    

  103.                         if(i < para_data[DATA_STEP_NUM]*2 - step_now_1)
    

  104.                         {
    

  105.                             led_state_1[i] = 1;
    

  106.                         }
    

  107.                         else
    

  108.                         {
    

  109.                             led_state_1[i] = 0;
    

  110.                         }
    

  111.                     }
    

  112.                     if(step_now_1 == para_data[DATA_STEP_NUM]+1)
    

  113.                     {
    

  114.                         color_now_1 = para_data[DATA_COLOR_NUM];
    

  115.                         color_time_cnt = color_led_time;
    

  116.                     }
    

  117.                 }
    

  118.                 else    // 整个流程运行完毕
    

  119.                 {
    

  120.                     up_down_flag_1 = STEP_LED_STOP;
    

  121.                     step_now_1 = 0;
    

  122.                     memset(led_state_1,0,sizeof(led_state_1));
    

  123.                 }
    

  124.                 break;
    

  125.             default:
    

  126.                 up_down_flag_1 = STEP_LED_STOP;
    

  127.                 step_now_1 = 0;
    

  128.                 memset(led_state_1,0,sizeof(led_state_1));
    

  129.                 break;
    

  130.             }
    


  131. 

  132.             switch(up_down_flag_2)    // 判断流程2运行方向
    

  133.             {
    

  134.             case STEP_LED_UP:    // 流程运行方向为上行
    

  135.                 step_now_2 ++;
    

  136.                 if(step_now_2 <= para_data[DATA_STEP_NUM])    // 逐级台阶点亮过程
    

  137.                 {
    

  138.                     for(i=0; i<para_data[DATA_STEP_NUM]; i++)
    

  139.                     {
    

  140.                         if(i < step_now_2)
    

  141.                         {
    

  142.                             led_state_2[i] = 1;
    

  143.                         }
    

  144.                         else
    

  145.                         {
    

  146.                             led_state_2[i] = 0;
    

  147.                         }
    

  148.                     }
    

  149.                     if(step_now_2 == para_data[DATA_STEP_NUM])
    

  150.                     {
    

  151.                         led_all_on_cnt2 ++;
    

  152.                         if(led_all_on_cnt2 <= 3)
    

  153.                         {
    

  154.                             step_now_2 --;
    

  155.                         }
    

  156.                     }
    

  157.                     else
    

  158.                     {
    

  159.                         led_all_on_cnt2 = 0;
    

  160.                     }
    

  161.                 }
    

  162.                 else if(step_now_2 <= para_data[DATA_STEP_NUM]*2)    // 逐级台阶熄灭过程
    

  163.                 {
    

  164.                     for(i=0; i<para_data[DATA_STEP_NUM]; i++)
    

  165.                     {
    

  166.                         if(i < step_now_2 - para_data[DATA_STEP_NUM])
    

  167.                         {
    

  168.                             led_state_2[i] = 0;
    

  169.                         }
    

  170.                         else
    

  171.                         {
    

  172.                             led_state_2[i] = 1;
    

  173.                         }
    

  174.                     }
    

  175.                     if(step_now_2 == para_data[DATA_STEP_NUM]+1)
    

  176.                     {
    

  177.                         color_now_2 = para_data[DATA_COLOR_NUM];
    

  178.                         color_time_cnt = color_led_time;
    

  179.                     }
    

  180.                 }
    

  181.                 else    // 整个流程运行完毕
    

  182.                 {
    

  183.                     up_down_flag_2 = STEP_LED_STOP;
    

  184.                     step_now_2 = 0;
    

  185.                     memset(led_state_2,0,sizeof(led_state_2));
    

  186.                 }
    

  187.                 break;
    

  188.             case STEP_LED_DOWN:    // 过程运行方向为下行
    

  189.                 step_now_2 ++;
    

  190.                 if(step_now_2 <= para_data[DATA_STEP_NUM])    // 逐级台阶点亮过程
    

  191.                 {
    

  192.                     for(i=0; i<para_data[DATA_STEP_NUM]; i++)
    

  193.                     {
    

  194.                         if(i < para_data[DATA_STEP_NUM] - step_now_2)
    

  195.                         {
    

  196.                             led_state_2[i] = 0;
    

  197.                         }
    

  198.                         else
    

  199.                         {
    

  200.                             led_state_2[i] = 1;
    

  201.                         }
    

  202.                     }
    

  203.                     if(step_now_2 == para_data[DATA_STEP_NUM])
    

  204.                     {
    

  205.                         led_all_on_cnt2 ++;
    

  206.                         if(led_all_on_cnt2 <= 3)
    

  207.                         {
    

  208.                             step_now_2 --;
    

  209.                         }
    

  210.                     }
    

  211.                     else
    

  212.                     {
    

  213.                         led_all_on_cnt2 = 0;
    

  214.                     }
    

  215.                 }
    

  216.                 else if(step_now_2 <= para_data[DATA_STEP_NUM]*2)    // 逐级台阶熄灭过程
    

  217.                 {
    

  218.                     for(i=0; i<para_data[DATA_STEP_NUM]; i++)
    

  219.                     {
    

  220.                         if(i < para_data[DATA_STEP_NUM]*2 - step_now_2)
    

  221.                         {
    

  222.                             led_state_2[i] = 1;
    

  223.                         }
    

  224.                         else
    

  225.                         {
    

  226.                             led_state_2[i] = 0;
    

  227.                         }
    

  228.                     }
    

  229.                     if(step_now_2 == para_data[DATA_STEP_NUM]+1)
    

  230.                     {
    

  231.                         color_now_2 = para_data[DATA_COLOR_NUM];
    

  232.                         color_time_cnt = color_led_time;
    

  233.                     }
    

  234.                 }
    

  235.                 else    // 整个流程运行完毕
    

  236.                 {
    

  237.                     up_down_flag_2 = STEP_LED_STOP;
    

  238.                     step_now_2 = 0;
    

  239.                     memset(led_state_2,0,sizeof(led_state_2));
    

  240.                 }
    

  241.                 break;
    

  242.             default:
    

  243.                 up_down_flag_2 = STEP_LED_STOP;
    

  244.                 step_now_2 = 0;
    

  245.                 memset(led_state_2,0,sizeof(led_state_2));
    

  246.                 break;
    

  247.             }
    


  248. 

  249.             for(i=0; i<para_data[DATA_STEP_NUM]; i++)
    

  250.             {
    

  251.                 if(led_state_1[i] + led_state_2[i] > 0)
    

  252.                 {
    

  253.                     ws_step_set1(step_light_data);
    

  254.                 }
    

  255.                 else
    

  256.                 {
    

  257.                     ws_step_set1(0);
    

  258.                 }
    

  259.             }
    

  260.             ws_step_reset();
    

  261.         }
    


  262. 

  263.         // 流水灯逻辑处理
    

  264.         color_time_cnt ++;
    

  265.         if(color_time_cnt >= color_led_time)
    

  266.         {
    

  267.             color_time_cnt = 0;
    


  268. 

  269.             switch(up_down_flag_1)    // 判断流程1运行方向
    

  270.             {
    

  271.             case STEP_LED_UP:    // 流程运行方向为上行
    

  272.                 color_now_1 ++;
    

  273.                 if(color_now_1 <= para_data[DATA_COLOR_NUM])    // 逐级点亮过程
    

  274.                 {
    

  275.                     for(i=0; i<para_data[DATA_COLOR_NUM]; i++)
    

  276.                     {
    

  277.                         if(i < color_now_1)
    

  278.                         {
    

  279.                             led_color_1[i] = 1;
    

  280.                         }
    

  281.                         else
    

  282.                         {
    

  283.                             led_color_1[i] = 0;
    

  284.                         }
    

  285.                     }
    

  286.                     if(color_now_1 == para_data[DATA_COLOR_NUM])
    

  287.                     {
    

  288.                         color_now_1 --;
    

  289.                     }
    

  290.                 }
    

  291.                 else if(color_now_1 <= para_data[DATA_COLOR_NUM]*2)    // 逐级熄灭过程
    

  292.                 {
    

  293.                     for(i=0; i<para_data[DATA_COLOR_NUM]; i++)
    

  294.                     {
    

  295.                         if(i < color_now_1 - para_data[DATA_COLOR_NUM])
    

  296.                         {
    

  297.                             led_color_1[i] = 0;
    

  298.                         }
    

  299.                         else
    

  300.                         {
    

  301.                             led_color_1[i] = 1;
    

  302.                         }
    

  303.                     }
    

  304.                     if(color_now_1 == para_data[DATA_COLOR_NUM]*2)
    

  305.                     {
    

  306.                         color_now_1 --;
    

  307.                     }
    

  308.                 }
    

  309.                 else    // 整个流程运行完毕
    

  310.                 {
    

  311.                     color_now_1 = 0;
    

  312.                     memset(led_color_1,0,sizeof(led_color_1));
    

  313.                 }
    

  314.                 break;
    

  315.             case STEP_LED_DOWN:    // 过程运行方向为下行
    

  316.                 color_now_1 ++;
    

  317.                 if(color_now_1 <= para_data[DATA_COLOR_NUM])    // 逐级点亮过程
    

  318.                 {
    

  319.                     for(i=0; i<para_data[DATA_COLOR_NUM]; i++)
    

  320.                     {
    

  321.                         if(i < para_data[DATA_COLOR_NUM] - color_now_1)
    

  322.                         {
    

  323.                             led_color_1[i] = 0;
    

  324.                         }
    

  325.                         else
    

  326.                         {
    

  327.                             led_color_1[i] = 1;
    

  328.                         }
    

  329.                     }
    

  330.                     if(color_now_1 == para_data[DATA_COLOR_NUM])
    

  331.                     {
    

  332.                         color_now_1 --;
    

  333.                     }
    

  334.                 }
    

  335.                 else if(color_now_1 <= para_data[DATA_COLOR_NUM]*2)    // 逐级熄灭过程
    

  336.                 {
    

  337.                     for(i=0; i<para_data[DATA_COLOR_NUM]; i++)
    

  338.                     {
    

  339.                         if(i < para_data[DATA_COLOR_NUM]*2 - color_now_1)
    

  340.                         {
    

  341.                             led_color_1[i] = 1;
    

  342.                         }
    

  343.                         else
    

  344.                         {
    

  345.                             led_color_1[i] = 0;
    

  346.                         }
    

  347.                     }
    

  348.                     if(color_now_1 == para_data[DATA_COLOR_NUM]*2)
    

  349.                     {
    

  350.                         color_now_1 --;
    

  351.                     }
    

  352.                 }
    

  353.                 else // 整个流程运行完毕
    

  354.                 {
    

  355.                     color_now_1 = 0;
    

  356.                     memset(led_color_1,0,sizeof(led_color_1));
    

  357.                 }
    

  358.                 break;
    

  359.             default:
    

  360.                 color_now_1 = 0;
    

  361.                 memset(led_color_1,0,sizeof(led_color_1));
    

  362.                 break;
    

  363.             }
    


  364. 

  365.             switch(up_down_flag_2)    // 判断流程2运行方向
    

  366.             {
    

  367.             case STEP_LED_UP:    // 流程运行方向为上行
    

  368.                 color_now_2 ++;
    

  369.                 if(color_now_2 <= para_data[DATA_COLOR_NUM])    // 逐级点亮过程
    

  370.                 {
    

  371.                     for(i=0; i<para_data[DATA_COLOR_NUM]; i++)
    

  372.                     {
    

  373.                         if(i < color_now_2)
    

  374.                         {
    

  375.                             led_color_2[i] = 1;
    

  376.                         }
    

  377.                         else
    

  378.                         {
    

  379.                             led_color_2[i] = 0;
    

  380.                         }
    

  381.                     }
    

  382.                     if(color_now_2 == para_data[DATA_COLOR_NUM])
    

  383.                     {
    

  384.                         color_now_2 --;
    

  385.                     }
    

  386.                 }
    

  387.                 else if(color_now_2 <= para_data[DATA_COLOR_NUM]*2)    // 逐级熄灭过程
    

  388.                 {
    

  389.                     for(i=0; i<para_data[DATA_COLOR_NUM]; i++)
    

  390.                     {
    

  391.                         if(i < color_now_2 - para_data[DATA_COLOR_NUM])
    

  392.                         {
    

  393.                             led_color_2[i] = 0;
    

  394.                         }
    

  395.                         else
    

  396.                         {
    

  397.                             led_color_2[i] = 1;
    

  398.                         }
    

  399.                     }
    

  400.                     if(color_now_2 == para_data[DATA_COLOR_NUM]*2)
    

  401.                     {
    

  402.                         color_now_2 --;
    

  403.                     }
    

  404.                 }
    

  405.                 else    // 整个流程运行完毕
    

  406.                 {
    

  407.                     color_now_2 = 0;
    

  408.                     memset(led_color_2,0,sizeof(led_color_2));
    

  409.                 }
    

  410.                 break;
    

  411.             case STEP_LED_DOWN:    // 过程运行方向为下行
    

  412.                 color_now_2 ++;
    

  413.                 if(color_now_2 <= para_data[DATA_COLOR_NUM])    // 逐级点亮过程
    

  414.                 {
    

  415.                     for(i=0; i<para_data[DATA_COLOR_NUM]; i++)
    

  416.                     {
    

  417.                         if(i < para_data[DATA_COLOR_NUM] - color_now_2)
    

  418.                         {
    

  419.                             led_color_2[i] = 0;
    

  420.                         }
    

  421.                         else
    

  422.                         {
    

  423.                             led_color_2[i] = 1;
    

  424.                         }
    

  425.                     }
    

  426.                     if(color_now_2 == para_data[DATA_COLOR_NUM])
    

  427.                     {
    

  428.                         color_now_2 --;
    

  429.                     }
    

  430.                 }
    

  431.                 else if(color_now_2 <= para_data[DATA_COLOR_NUM]*2)    // 逐级熄灭过程
    

  432.                 {
    

  433.                     for(i=0; i<para_data[DATA_COLOR_NUM]; i++)
    

  434.                     {
    

  435.                         if(i < para_data[DATA_COLOR_NUM]*2 - color_now_2)
    

  436.                         {
    

  437.                             led_color_2[i] = 1;
    

  438.                         }
    

  439.                         else
    

  440.                         {
    

  441.                             led_color_2[i] = 0;
    

  442.                         }
    

  443.                     }
    

  444.                     if(color_now_2 == para_data[DATA_COLOR_NUM]*2)
    

  445.                     {
    

  446.                         color_now_2 --;
    

  447.                     }
    

  448.                 }
    

  449.                 else    // 整个流程运行完毕
    

  450.                 {
    

  451.                     color_now_2 = 0;
    

  452.                     memset(led_color_2,0,sizeof(led_color_2));
    

  453.                 }
    

  454.                 break;
    

  455.             default:
    

  456.                 color_now_2 = 0;
    

  457.                 memset(led_color_2,0,sizeof(led_color_2));
    

  458.                 break;
    

  459.             }
    


  460. 

  461.             for(i=0; i<para_data[DATA_COLOR_NUM]; i++)
    

  462.             {
    

  463.                 if(led_color_1[i] + led_color_2[i] > 0)
    

  464.                 {
    

  465.                     ws_color1_set1(color_light_data);
    

  466.                 }
    

  467.                 else
    

  468.                 {
    

  469.                     ws_color1_set1(0);
    

  470.                 }
    

  471.             }
    

  472.             ws_color1_reset();
    


  473. 

  474.             for(i=0; i<para_data[DATA_COLOR_NUM]; i++)
    

  475.             {
    

  476.                 if(led_color_1[i] + led_color_2[i] > 0)
    

  477.                 {
    

  478.                     ws_color2_set1(color_light_data);
    

  479.                 }
    

  480.                 else
    

  481.                 {
    

  482.                     ws_color2_set1(0);
    

  483.                 }
    

  484.             }
    

  485.             ws_color2_reset();
    

  486.         }
    

  487.     }
    

  488. }

由于扶手流水灯的运行时间间隔是计算获取的，因此会有小数部分的丢弃，最终扶手灯全亮时间会短于台阶灯全亮时间。因此在流程处理时，扶手灯全亮之后，会等待台阶灯的信号，最终和台阶灯一起启动灭灯流程（以台阶灯的启动时间为准）。
以上就是台阶流水灯项目关于流水灯处理逻辑部分的代码编写和完善过程。
详细代码在下篇文章解决完bug之后再附上。

回复

收藏 举报

打赏榜单

21小跑堂 打赏了 30.00 元 2023-08-18
理由：恭喜通过原创审核！期待您更多的原创作品~

评论

21小跑堂
书接上回，从软件层面实现流水灯的逻辑。  发表于 2023-8-18 15:17

相关帖子
heisexingqisi 发表于 2023-9-30 11:13 来自手机 | 显示全部楼层
有点花里胡哨的感觉，眼花了容易摔下来
回复

收藏 举报

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

本版积分规则

blust5 Image
个人签名：业精于勤荒于嬉，行成于思毁于随。

72

主题

2999

帖子

11

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