1 全自动洗衣机功能分析

下面是一个全自动洗衣机的控制面板：

4 _: l' Z3 }+ S, @5 P* |* |

面板上有4个按键：

• 电源：控制洗衣机通电与断电
• 水位：选择洗衣时需要的水位，有1~8个水位
• 程序：选择不同的洗衣模式，有1~10个模式
  / m, p2 l& T/ r8 E  i
  • 01：标准
  • 02：轻柔
  • 03：快速
  • ...
  • 10：桶风干
    + [# L- E" p$ h- e0 a& P
• 启动/暂停：用于启动或暂停洗衣任务
  

面板上还有一个数码管，用于显示当前的工作状态与剩余时间，可显示的工作模式有：

• AA：浸泡
• BB：洗涤
• CC：漂洗
• DD：脱水
  + p# w2 w& k( V, Y

本篇，就按照这款洗衣机的操作方式实现对应的洗衣机控制逻辑。需注意的是：

• 实际的洗衣机有水位检测传感器，本篇中，暂用时间延时模拟水位的增加，且默认开机时水位为0
• 实际的洗衣机中的洗衣模式，会根据不同的模式自动设置清洗次数与每次清洗的时间以及清洗力度，本篇为了简化起见，清洗模式的设置仅用于区分不同的清洗次数
• 某些特殊的清洗模式，如单独的脱水，桶风干等，本篇暂不实现
• 对于状态的显示 ，本篇先以串口打印的实现展示，下篇使用OLED小屏幕来显示不同清洗状态的图标等信息
  * |/ O& V2 E; d& F

/ V6 D; W, b% h2 d3 \8 n
2 画状态图

根据上面分析的全自动洗衣机的功能，以及我们自己使用洗衣机时的经验，可以画出如下的全自动洗衣机的状态图：

6 R3 m! m0 ^0 [# Q, Q9 k

首先是上电开机，洗衣机可能会开机自检，检测洗衣机的各个部件是否正常，次过程很短。

然后就处于空闲状态，此时用户可以设置水位与清洗模式，若不设置，则为默认的水位与洗衣模式。

接着触发开始按键后，就开始清洗了，一般流程就是：加水、清洗、排水、甩干、结束。

根据不同的清洗模式，加水、清洗和排水这3个过程会循环执行一定的次数。

另外，在不同的工作阶段，按下暂停键可以让洗衣任务暂停，再按继续可让洗衣任务继续。

; t# `$ h* j3 O3 b6 K4 d

3 编程实现3.1 多按键检测功能

本篇介绍的洗衣机的按键，仅需要检测按键单击即可，不需要双击与长按功能，因此，可使用介绍的最基础的按键状态机来为洗衣机状态机提供按键事件。

之前介绍的按键状态机，只有一个按键，本篇需要用到4个按键（除去电源键，3个也可以），因此，需要对按键状态机稍加修改，实现按键状态机的复用。

之前介绍的按键状态机，使用了几个全局变量来表示状态，更合理的做法是将其封装起来：

1. typedefstruct {
   . T, y* @% m) j7 z# h  r
2.         KEY_STATUS keyStatus;    <i>//当前循环结束的(状态机的)状态</i>
   
3.         KEY_STATUS nowKeyStatus; <i>//当前状态(每次循环后与pKeyFsmData->keyStatus保持一致)</i>
   
4.         KEY_STATUS lastKeyStatus; <i>//上次状态(用于记录前一状态以区分状态的来源)</i>
   
5.         int keyIdx;
   : m0 H3 o, S: b6 [4 {$ \* K
6. }KeyFsmData;

复制代码

4 j* f' Q0 \. \. K1 \3 H* g

注意，额外增加了一个按键索引值，用来告诉状态机要检测哪个按键。

再将原来的按键状态机程序，通过入参的形式将上述定义的结构体传入，并通过函数返回的形式返回按键是否被按下。

这样修改后的按键状态机，就是一个独立的模块了，可以通过传入不同的参数，实现不同按键的检测。

1. bool key_press_check(KeyFsmData *pKeyFsmData)
   
2. {
   " x! Q$ s1 G' O
3.         bool bPress = false;
   
4.                
   , e6 T" V$ @" q2 s
5.         switch(pKeyFsmData->keyStatus)
   # }! C- [8 v% ^( V! H
6.         {
   
7. <i>//省略...</i>

复制代码

对于本篇需要的4个按键的检测，就可以定义4个数据结构体，分别调用4次状态机函数即可，实现代码的复用。

1. KeyFsmData pKey0FsmData;
   
2. KeyFsmData pKey1FsmData;
   6 q7 O% R' F& b8 b6 f; Z# t! F
3. KeyFsmData pKey2FsmData;
   
4. KeyFsmData pKey3FsmData;
   
5. 
   / @  i0 O: N+ v: ^+ s# k. q
6. void key_check_init(KeyFsmData *pKeyFsmData, int keyIdx)
   
7. {
   
8.         pKeyFsmData->keyStatus = KS_RELEASE;
   
9.         pKeyFsmData->lastKeyStatus = KS_RELEASE;
   
10.         pKeyFsmData->nowKeyStatus = KS_RELEASE;
    6 P& ]. g  W1 I
11.         pKeyFsmData->keyIdx = keyIdx;
    
12. }
    ' v, I+ k% R7 M+ H
13. 
    
14. void multi_key_check_init()
    " ^+ Z% g0 r$ \( ^- J
15. {
    
16.         key_check_init(&pKey0FsmData, 0);
    / i" v, l3 e9 s- J9 A  _) c
17.         key_check_init(&pKey1FsmData, 1);
    
18.         key_check_init(&pKey2FsmData, 2);
    
19.         key_check_init(&pKey3FsmData, 3);
    8 W3 u! O3 z4 T& b% }# K" T8 D) J* p% F
20. }
    & J% t9 f& m2 J! \
21. 
    ! F$ Z/ n3 p6 T' v0 j7 z* ~
22. int g_keyPressIdx = -1;
    2 r' t# A3 o2 T+ d* ~) \) ^. h" M
23. void multi_key_check()
    ; S/ W5 V, p2 g+ @3 w# t& k0 `7 n
24. {
    
25.         bool key0 = key_press_check(&pKey0FsmData);
    
26.         bool key1 = key_press_check(&pKey1FsmData);
    # R/ J) I6 K2 c, y! ?. ~$ |7 ?6 j
27.         bool key2 = key_press_check(&pKey2FsmData);
    
28.         bool key3 = key_press_check(&pKey3FsmData);
    5 y1 c0 t7 n: Z3 i3 a# p
29.         
    5 E) P, @& @& j  R& Y
30.         if (key0 | key1 | key2 | key3)
    
31.         {
    0 q6 W2 ]* X# a% u2 m) |0 z' v
32.                 <i>//printf("key0:%d, key1:%d, key2:%d, key3:%d, \r\n", key0, key1, key2, key3);</i>
    1 y: U# W& G5 ?9 z4 x9 p' t
33.                
    
34.                 if (key0)
      [/ B9 X$ Q; r$ X' ~
35.                 {
    
36.                         g_keyPressIdx = 0;
    # `1 G4 w: [6 H1 J: R; ]% I+ K& E
37.                 }
    
38.                 elseif (key1)
    
39.                 {
    
40.                         g_keyPressIdx = 1;
    ! }' Z, X5 V7 ~/ v5 N* G
41.                 }
    ' `( ?- t4 v" s3 z; _  J
42.                 elseif (key2)
    
43.                 {
    
44.                         g_keyPressIdx = 2;
    
45.                 }
    ( F& ~& h$ r8 s1 K  C
46.                 elseif (key3)
    
47.                 {
    7 J" W1 m% ]/ }$ f  b
48.                         g_keyPressIdx = 3;
    ! E) d6 m$ B( o+ N' u4 v
49.                 }
    
50.         }
    1 g6 A0 {- g3 k
51. }
    * Q6 Z! H. K3 Z# e+ N
52. 
    
53. int get_press_key_idx()
    ) G4 c' i1 ]7 M" u3 `- |! B& O
54. {
    
55.         int idx = g_keyPressIdx;
    5 X3 b0 O$ C5 b7 C
56.         g_keyPressIdx = -1;
    4 r/ P! T, q& J3 H) `7 @
57.         
    6 ^8 J" G, Z+ Z" v2 ]. z1 j
58.         return idx;
    5 R# t/ h1 d. _( N4 k; d$ g
59. }

复制代码

其中，multi_key_check函数，放到50ms周期的定时器中断服务函数中，使按键状态机程序运行起来。

get_press_key_idx函数，用于洗衣机程序来获取不同按键的按下事件，每次获取后，将按键事件清除(g_keyPressIdx设为无效值-1)

" w1 u0 j5 i/ {% J1 a/ u

3.2 洗衣功能

按照上面绘制的洗衣机状态图，使用switch-case法编写对应的程序即可：

1. #define WASHER_STATUS_ENUM(STATUS)                     \
   1 N: N* h: i0 u! H4 [
2.         STATUS(WS_INIT)         /*开机初始化自检*/         \
   # J2 J$ k: K$ f8 ]
3.         STATUS(WS_IDLE)         /*空闲(等待模式设置)状态*/ \
   
4.         STATUS(WS_ADD_WATER)    /*加水状态*/               \
   
5.         STATUS(WS_WASH)         /*清洗状态*/               \
   
6.         STATUS(WS_DRAIN_WATER)  /*排水状态*/               \
   ; ?9 I9 L9 p! m: H$ P
7.         STATUS(WS_SPIN_DRY)     /*甩干状态*/               \
   
8.         STATUS(WS_PAUSE)        /*暂停状态*/               \
   9 v- {5 H: |. E4 q  F% x
9.         STATUS(WS_NUM)          /*状态总数(无效状态)*/
   
10. 
    
11. typedefenum
    ( R. k' U( o7 {- r: H7 z5 }
12. {
    
13.         WASHER_STATUS_ENUM(ENUM_ITEM)
    
14. }WASHER_STATUS;
    
15. 
    ( r2 [7 \' ^! g$ A- }& K- o- K5 y
16. constchar* washer_status_name[] = {
    3 `" v# m+ M6 `3 a
17.         WASHER_STATUS_ENUM(ENUM_STRING)
    & K. @1 S: D: q/ b- j4 D" u
18. };
    
19. 
    
20. WASHER_STATUS g_washerStatus = WS_INIT;    <i>//当前循环结束的(状态机的)状态</i>
    . M4 |% O% Y1 x# V' a2 x
21. WASHER_STATUS g_nowWasherStatus = WS_INIT; <i>//当前状态(每次循环后与pKeyFsmData->keyStatus保持一致)</i>
    
22. WASHER_STATUS g_lastWasherStatus = WS_INIT; <i>//上次状态(用于记录前一状态以区分状态的来源)</i>
    
23. 
    * F; x5 N, p% `% R
24. int g_WorkLoopCnt = 0;
    
25. int g_WaterLevel = 5; <i>//1~8</i>
    2 w& H, W1 m. q3 R: V4 U
26. int g_WashMode = 2; <i>//暂定为清洗次数:1~3</i>
    ( }! A- q& M1 s- S& h+ ~
27. int g_curWashCnt = 0;
    3 m! g# L: \1 ]. s. i
28. 
    
29. void washer_run_loop()
    1 X0 R  g  j8 ?2 w2 n
30. {
    
31.         switch(g_washerStatus)
    : k1 H7 ?. e5 x. _
32.         {
    , I/ E; y( h0 ?; t. U
33.                 <i>/*开机初始化自检*/</i>
    
34.                 case WS_INIT:
    $ L! S. M3 x" ?  {6 _% H& P. h+ y" o
35.                         g_washerStatus = washer_do_init();
    
36.                         break;
    2 p+ I0 i* t$ [0 ~
37.                
    , j8 q% O, c; Y2 m. n
38.                 <i>/*空闲(等待模式设置)状态*/</i>
    
39.                 case WS_IDLE:
    
40.                         g_washerStatus = washer_do_idle();
    
41.                         break;
    
42.                
    " ?3 s: A! B3 Y; t: z
43.                 <i>/*加水状态*/</i>
    
44.                 case WS_ADD_WATER:
    0 ?! @6 I- F" g2 M( s+ J
45.                         g_washerStatus = washer_do_add_water();
    
46.                         break;
    9 D; l) J6 U8 R. x& Q7 w
47.                
    % X2 y0 V  h  v- B; \
48.                 <i>/*清洗状态*/</i>
    
49.                 case WS_WASH:
    
50.                         g_washerStatus = washer_do_wash();
    
51.                         break;
    . c9 Q/ M5 ^) D/ Y5 x6 C
52.                
    
53.                 <i>/*排水状态*/</i>
    
54.                 case WS_DRAIN_WATER:
    - ?0 O/ {( ?+ Z# d- Y
55.                         g_washerStatus = washer_do_drain_water();
    
56.                         break;
    
57.                
    & X- |( l9 y' B$ A+ s
58.                 <i>/*甩干状态*/</i>
    
59.                 case WS_SPIN_DRY:
    . d8 z! ?  w' z$ c5 I
60.                         g_washerStatus = washer_do_spin_dry();
    
61.                         break;
    
62.                
    + M5 n5 h" K: a7 ^; a
63.                 <i>/*暂停状态*/</i>
    
64.                 case WS_PAUSE:
    
65.                         g_washerStatus = washer_do_pause();
    7 V7 q+ z4 O7 i- b- z% x; L
66.                         break;
    
67.                
    
68.                 default: break;
    6 K0 u$ y- ~& ~8 }
69.         }
    
70.         
    
71.         if (g_washerStatus != g_nowWasherStatus)
    - E' {, k, |7 ]) c* x
72.         {
    
73.                 g_lastWasherStatus = g_nowWasherStatus;
    
74.                 g_nowWasherStatus = g_washerStatus;
    
75.                 <i>//printf("new washer status:%d(%s)\r\n", g_washerStatus, washer_status_name[g_washerStatus]);</i>
    
76.         }
    
77. }

复制代码

+ I; ^- C1 y& q3 ~1 m  T

这里将洗衣机不同状态时的处理逻辑，都分别使用函数来实现，并将其返回值作为下一个要跳转的状态。

各个状态的处理函数如下：

1. <i>/*开机初始化自检*/</i>
   , h/ J5 a' `- A, p1 i2 v
2. WASHER_STATUS washer_do_init()
   
3. {
   ! x; W8 m8 y7 F  g+ W
4.         WASHER_STATUS nextStatus = WS_INIT;
   
5.         
   
6.         g_WorkLoopCnt++;
   . i) D5 g1 T( V8 g( D6 b2 W
7.         if (10 == g_WorkLoopCnt) <i>//自检结束</i>
   " L4 e! ~6 k' k! P! c* B! H3 z
8.         {
   6 X; V7 p4 P+ P! O
9.                 printf("default water level:%d\r\n", g_WaterLevel);
   " V" ]  J; t$ ~+ M
10.                 printf("default wash mode:%d\r\n", g_WashMode);
    
11.                 printf("washer idle...\r\n");
    
12.                
    5 u( ]2 Y. P9 |' t; N9 J
13.                 g_WorkLoopCnt = 0;
    
14.                 nextStatus = WS_IDLE;
    
15.         }
    # m( c7 F/ R) w2 O
16.         
    
17.         return nextStatus;
    . L% I/ G, g+ w. J. H
18. }
    . j6 t3 E0 \' \# |4 K0 Z
19. 
    # f% M, p8 P% T4 Z2 c' _: b
20. <i>/*空闲(等待模式设置)状态*/</i>
    
21. WASHER_STATUS washer_do_idle()
    - z: L7 L) p; G/ W& V+ n& X
22. {
    6 U+ I' K8 `' y! o7 o, v) o3 [
23.         WASHER_STATUS nextStatus = WS_IDLE;
    
24.         
    
25.         const WASHER_KEY key = check_key_press();
    ' X! {6 b* w* \. X- G# v
26.         switch(key)
    % D6 b/ i, M8 L* A9 K2 v- e5 H! h
27.         {
    % o" c+ k* R* X
28.                 case W_KEY_START_PAUSE:
    
29.                         g_WorkLoopCnt = 0;
    5 F9 z1 e9 f( X+ X
30.                         nextStatus = WS_ADD_WATER;
    
31.                         printf("add water...\r\n");
    
32.                 break;
    
33.                
    1 z0 s7 T, J9 I, l$ s$ n# ?4 ]2 G
34.                 case W_KEY_WATER_LEVEL:
      u) }; g1 {3 {( L' o
35.                         g_WaterLevel = (g_WaterLevel == 8) ? 1 : (g_WaterLevel+1);
    
36.                         printf("set water level:%d\r\n", g_WaterLevel);
    ' `3 Y5 a$ H9 ~5 b$ v* h/ o
37.                 break;
    
38.                         
    ! s; n' ~9 K$ h% p. [- B8 H! A
39.                 case W_KEY_WASH_MODE:
    
40.                         g_WashMode = (g_WashMode == 3) ? 1 : (g_WashMode+1);
    0 s* ^6 g- m" W0 h% O
41.                         printf("set wash mode:%d\r\n", g_WashMode);
    2 B  D6 d& x, f4 h  `
42.                 break;
    
43.                
    
44.                 default: break;
    
45.         }
    
46.         
    
47.         return nextStatus;
    
48. }
    
49. 
    0 z2 j! x1 h0 m0 I
50. <i>/*加水状态*/</i>
    - O' u$ g8 s. R% Q/ g
51. WASHER_STATUS washer_do_add_water()
    % m0 M. E, M1 e. ~& f
52. {
    4 U8 n7 S. t2 X: T) L/ X/ t
53.         WASHER_STATUS nextStatus = WS_ADD_WATER;
    
54.         
    ( ~- C( @! _! h0 m; O
55.         const WASHER_KEY key = check_key_press();
    # i1 ]1 U5 Z: b9 M7 _, {
56.         if (key == W_KEY_START_PAUSE)
    
57.         {
    8 E+ @0 Y* |% i' I
58.                 nextStatus = WS_PAUSE;
    ! Y& w0 T* H: ?4 W, B) w
59.                 printf("[%s] pause...\r\n", __func__);
    
60.         }
    2 Y# m. c" A" x0 s8 F- l% i5 a
61.         else
    + D8 ^5 _4 G5 h% v3 R" C
62.         {
    
63.                 g_WorkLoopCnt++;
    
64.                 if (g_WaterLevel == (g_WorkLoopCnt / 10)) <i>//加水结束</i>
    
65.                 {
    
66.                         g_WorkLoopCnt = 0;
    
67.                         nextStatus = WS_WASH;
    . f; C# O, `- y1 b' u
68.                         printf("[%s] done\r\n", __func__);
    : Y. R7 @. t* v- W$ C; ]$ X  ]
69.                         printf("wash...\r\n");
    
70.                 }
    & }! a! o6 Y: [
71.         }
    
72.         
    7 \) F; }/ x1 I( i9 I! k5 Q5 W
73.         return nextStatus;
    5 I' |! `+ `( a, _. u" s# E9 F
74. }
    9 F' K, A; c# W" C
75. 
      S" Y. K: s, {! e4 e$ D
76. <i>/*清洗状态*/</i>
    
77. WASHER_STATUS washer_do_wash()
    , E# `5 z3 H* x9 p0 h% e; H
78. {
    : y4 |! }1 x3 w# H6 ~1 k! t( Q7 [' m
79.         WASHER_STATUS nextStatus = WS_WASH;
    
80.         
    
81.         const WASHER_KEY key = check_key_press();
    
82.         if (key == W_KEY_START_PAUSE)
    9 |" u8 n. g4 Y5 o; s' {
83.         {
    * K" ~6 Y3 S( c" F+ h1 i$ D
84.                 nextStatus = WS_PAUSE;
    
85.                 printf("[%s] pause...\r\n", __func__);
    2 S1 W5 l& }0 r5 ~- S) M# b) U1 @9 U
86.         }
    
87.         else
    
88.         {
    
89.                 g_WorkLoopCnt++;
    7 C# H' v0 l0 H2 e8 I- }
90.                 if (6 == (g_WorkLoopCnt / 10)) <i>//清洗结束</i>
    
91.                 {
    # o2 V, a  \" i+ V. Y9 Y
92.                         g_WorkLoopCnt = 0;
    
93.                         nextStatus = WS_DRAIN_WATER;
    
94.                         printf("[%s] done\r\n", __func__);
    2 e. S  R% |5 t1 X, l' g
95.                         printf("drain water...\r\n");
    : B( w2 L+ `8 @
96.                 }
    
97.         }
    
98.         
    " y2 ]4 Y7 J" ^( T# Z" h) |
99.         return nextStatus;
    
100. }
     
101. 
     
102. <i>/*排水状态*/</i>
     , j# W5 b4 i+ a7 ^( Z/ U! K
103. WASHER_STATUS washer_do_drain_water()
     
104. {
     6 D0 |1 _. j" o
105.         WASHER_STATUS nextStatus = WS_DRAIN_WATER;
     - z# u, @0 n+ s( b- F7 G% F1 x, m
106.         
     
107.         const WASHER_KEY key = check_key_press();
     
108.         if (key == W_KEY_START_PAUSE)
     7 c, w/ n* f6 w" O7 C6 ]% ~$ q
109.         {
     
110.                 nextStatus = WS_PAUSE;
     7 |3 P. v" M: l/ A
111.                 printf("[%s] pause...\r\n", __func__);
     
112.         }
     % m9 h5 z% I6 R
113.         else
     
114.         {
     
115.                 g_WorkLoopCnt++;
     
116.                 if (3 == (g_WorkLoopCnt / 10)) <i>//排水结束</i>
     % f' P- M6 p. j* V* m* k
117.                 {
     ) C% y# u/ `$ e: u% ~
118.                         printf("[%s] done\r\n", __func__);
     
119.                         g_curWashCnt++;
     
120.                         printf("current wash and drain count:%d(target:%d)\r\n", g_curWashCnt, g_WashMode);
     ( H+ g8 ^) H+ f# f0 h: _& N
121.                         g_WorkLoopCnt = 0;
     / U  Z7 U" {7 w! J7 ?
122.                         if (g_WashMode == g_curWashCnt)
     
123.                         {
     ; q% e! k! {9 h$ G' u3 u" b) o7 v+ w
124.                                 printf("spin dry...\r\n");
     
125.                                 nextStatus = WS_SPIN_DRY;
     ' p- n: m5 K$ ?& f4 ?* {/ o( r
126.                         }
     
127.                         else
     # n+ g  G0 L2 K* S9 L5 u* l. T
128.                         {
     & u) m4 X) O/ o' S
129.                                 printf("add water...\r\n");
     
130.                                 nextStatus = WS_ADD_WATER;
     
131.                         }
     - r6 @* J+ x' L( g, u1 M( |; j
132.                 }
     ! e4 x9 X6 m6 |9 {) c. J; M3 i
133.         }
     
134.         
     & x3 g7 t3 g' |% U( e2 w
135.         return nextStatus;
     
136. }
     6 T4 E5 r1 l4 a# B1 B. R' j
137. 
     . C3 d2 v. k: k- d; E$ {6 n
138. <i>/*甩干状态*/</i>
     
139. WASHER_STATUS washer_do_spin_dry()
     
140. {
     
141.         WASHER_STATUS nextStatus = WS_SPIN_DRY;
     
142.         
     ) b4 b% a; j" m8 Q
143.         const WASHER_KEY key = check_key_press();
     $ z  e# N: _9 H1 Z8 w: d3 C
144.         if (key == W_KEY_START_PAUSE)
     
145.         {
     
146.                 nextStatus = WS_PAUSE;
     ( n" P1 m& M. S5 }2 w
147.                 printf("[%s] pause...\r\n", __func__);
     + J: m! k8 W/ k# ^% d
148.         }
     & s) h% @7 _' A- g! W- e
149.         else
     
150.         {
     7 U; o% M- y! E5 V0 `6 o/ |
151.                 g_WorkLoopCnt++;
     , g' Q  I. e) k: C
152.                 if (100 == g_WorkLoopCnt) <i>//甩干结束</i>
     6 Q& P& H3 e) C! N* B- e) l
153.                 {
     
154.                         g_WorkLoopCnt = 0;
     / L( @' A& ~4 }$ H2 ?
155.                         nextStatus = WS_IDLE;
     8 z( ~/ `' l5 d6 k: v  t
156.                         printf("[%s] done\r\n", __func__);
     # @' \& f3 u( \
157.                         printf("enter idle mode\r\n");
     
158.                 }
     
159.         }
     4 b6 V0 K6 G) Y( z, H" B
160.         
     
161.         return nextStatus;
     
162. }
     
163. 
     1 P1 ?( I* q- u; f
164. <i>/*暂停状态*/</i>
     + g$ I( L5 Q- C
165. WASHER_STATUS washer_do_pause()
     + M9 s! H1 B; E4 U" {
166. {
     % C4 v9 W& b+ b, r
167.         WASHER_STATUS nextStatus = WS_PAUSE;
     ' f" N* V! `, |: U  S: L/ P
168.         
     
169.         const WASHER_KEY key = check_key_press();
     
170.         if (key != W_KEY_NULL)
     
171.         {
     
172.                 switch (g_lastWasherStatus)
       U  @0 q' H/ S* Z& |- t6 }$ O
173.                 {
     2 Y9 u; X- W7 n! n' J# m. \* N
174.                         case WS_ADD_WATER:   nextStatus = WS_ADD_WATER;   printf("resume...\r\n"); break;
     : X. O; H) s4 ?, ]# b& p
175.                         case WS_WASH:        nextStatus = WS_WASH;        printf("resume...\r\n"); break;
     
176.                         case WS_DRAIN_WATER: nextStatus = WS_DRAIN_WATER; printf("resume...\r\n"); break;
     ; S7 p; Z! ^% S) U4 D( W0 d5 w: E8 b
177.                         case WS_SPIN_DRY:    nextStatus = WS_SPIN_DRY;    printf("resume...\r\n"); break;
     7 k! B0 g1 }0 U3 j/ [
178.                         default: break;
     
179.                 }
     4 g- n( Z  N2 ^9 o
180.         }
     
181.         
     
182.         return nextStatus;
     
183. }

复制代码

5 L& \# e! `, k, z+ `9 W( n

对于按键的获取，这里定义了几个对应的功能按键，并从按键状态机函数中获取按键索引，再转为洗衣机程序所需的对应功能按键：

1. typedefenum
   
2. {
   
3.         W_KEY_NULL,        <i>//没有按键按下</i>
   
4.         W_KEY_POWER,       <i>//电源键按下</i>
   
5.         W_KEY_WATER_LEVEL, <i>//水位键按下</i>
   % ]) M% x5 `. }( e- ~
6.         W_KEY_WASH_MODE,   <i>//清洗模式键按下</i>
   
7.         W_KEY_START_PAUSE  <i>//启动/暂停键按下</i>
   ( H/ s% w% g& r3 ]8 z5 t
8. }WASHER_KEY;
   
9. 
   
10. WASHER_KEY check_key_press()
    
11. {
    
12.         WASHER_KEY washerKey = W_KEY_NULL;
    5 W- W# T4 T  T4 K: D5 K- L- {0 K
13.         int idx = get_press_key_idx();
    
14.         if (idx != -1)
    , Z: M5 S4 \! ~0 m
15.         {
    
16.                 switch(idx)
    - ]  L5 A; b& X
17.                 {
    / q8 C7 r4 o9 D" A! H  d) t
18.                         case0: washerKey = W_KEY_POWER; break; <i>//电源键按下</i>
    
19.                         case1: washerKey = W_KEY_WATER_LEVEL; break; <i>//水位键按下</i>
    3 E/ q+ w- Y) l/ E. ~" O3 `$ M5 K
20.                         case2: washerKey = W_KEY_WASH_MODE; break; <i>//清洗模式键按下</i>
    8 Q5 n: y* Q. Q- ~; y, i
21.                         case3: washerKey = W_KEY_START_PAUSE; break; <i>//启动/暂停键按下</i>
    
22.                         default: break;
    ! I# Q3 ]% }" N4 s( ^" x8 j
23.                 }
    ! R% J3 X% \  Y$ q4 n
24.                 <i>//printf("%s idx:%d -> washerKey:%d\r\n", __func__, idx, washerKey);</i>
    & o2 Y7 F+ N0 b! g* r4 R4 D
25.         }
    
26.         
    , I& ]3 ]) ~% r  t/ M
27.         return washerKey;
    7 j: v: d, U. K  S/ m% V
28. }

复制代码

/ ]8 N1 }: t# }, C6 c" r$ z

洗衣机状态机主程序，可以放到main函数中，每隔100ms调用一次，使其运行起来：

1. int main(void)
   
2. {        
   
3.         delay_init();
   7 W; g/ s3 X4 ~7 o, o. h
4.         KEY_Init();
   
5.         uart_init(115200);
   / M! J9 C! ^; v' ?6 n9 z
6.         TIM3_Int_Init(500-1,7200-1); <i>//调用定时器使得50ms产生一个中断</i>
   
7. 
   5 z+ k0 z5 f0 i9 r1 V% E0 c) S4 T
8.         printf("hello\r\n");
   
9.         
   & E- j* d. c7 R4 K# k8 g. F8 }
10.         while(1)
    
11.         {
    ( i& _. e! T- g0 Z5 n0 G
12.                 washer_run_loop();
    9 j0 L, E5 V* N4 B; G" [- v, z. {- t/ J
13.                 delay_ms(100);
      e/ H; \& N: D! q) Q
14.         }
    # e3 `4 R5 Y; }
15. }

复制代码

( ?. a8 g8 U4 h- u, }3.3 测试

将代码烧写到STM32板子中，通过3个按键(电源键暂不使用)操作，并通过串口打印，查看全自动洗衣机的运行情况：

0 F. |) _' Q+ [6 w' F$ R+ B; t+ J

4 |9 k' k1 B" x3 H2 z. w3 Y
" Q! r& M# F3 F1 D$ L4 总结
: `" d$ y- M. }8 T8 c8 R  L$ L

本篇实现了一款全自动洗衣机的基础洗衣控制流程，可实现不同水位与清洗次数的设置，以及任务的暂停与继续。此外，通过对之前按键状态机的进一步优化修改，实现了按键状态机的复用，实现多个按键的检测。下篇文章将进一步进行功能优化，添加OLED小屏幕实现不同状态的可视化展示。

. X' n  X: l9 P! U; V转载自 码农爱学习
7 k: K( D! i2 h
: _4 _2 a. t: d- z' F