1 /*
2  * Copyright (c) 2022 HiSilicon (Shanghai) Technologies CO., LIMITED.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include <stdio.h>
17 #include <stdlib.h>
18 #include <memory.h>
19 #include <hi_time.h>
20 #include <hi_watchdog.h>
21 #include "iot_errno.h"
22 #include "iot_gpio.h"
23 #include "ssd1306_oled.h"
24 #include "app_demo_i2c_oled.h"
25 #include "iot_gpio_ex.h"
26 #include "app_demo_gl5537_1.h"
27 #include "app_demo_multi_sample.h"
28 
29 #define DELAY_TIMES_100 100
30 #define DELAY_TIMES_5   5
31 
32 #define PWM_FRQ_50      50
33 #define PWM_FRQ_10      10
34 #define PWM_FRQ_100     100
35 #define PWM_FRQ_20      20
36 
37 #define TICK_COUNT_MAX  255
38 #define PAIR_2          2
39 
40 GlobalStatusType globalStaType = {0};
41 
42 /* Set key status */
SetKeyStatus(HiColorfulLightMode setSta)43 unsigned char SetKeyStatus(HiColorfulLightMode setSta)
44 {
45     globalStaType.g_currentMode = setSta;
46     return globalStaType.g_currentMode;
47 }
48 /* Set key status */
SetKeyType(HiColorfulLightMode setSta)49 unsigned char SetKeyType(HiColorfulLightMode setSta)
50 {
51     globalStaType.g_currentType = setSta;
52     return globalStaType.g_currentType;
53 }
54 
55 /* GetKeyStatus */
GetKeyStatus(GlobalStatuDef staDef)56 unsigned char GetKeyStatus(GlobalStatuDef staDef)
57 {
58     unsigned char status = 0;
59     switch (staDef) {
60         case MENU_SELECT:
61             status = globalStaType.g_menuSelect;
62             break;
63         case MENU_MODE:
64             status = globalStaType.g_menuMode;
65             break;
66         case CURRENT_MODE:
67             status = globalStaType.g_currentMode;
68             break;
69         case CURRENT_TYPE:
70             status = globalStaType.g_currentType;
71             break;
72         case KEY_DOWN_FLAG:
73             status = globalStaType.g_keyDownFlag;
74             break;
75         case OC_BEEP_STATUS:
76             status = globalStaType.g_ocBeepStatus;
77             break;
78         case SOMEONE_WALKING:
79             status = globalStaType.g_someoneWalkingFlag;
80             break;
81         default:
82             break;
83     }
84     return status;
85 }
86 
87 /* factory test HiSpark board */
HisparkBoardTest(IotGpioValue value)88 void HisparkBoardTest(IotGpioValue value)
89 {
90     IoSetFunc(HI_GPIO_9, 0); // GPIO9
91     IoTGpioSetDir(HI_GPIO_9, IOT_GPIO_DIR_OUT); // GPIO9
92     IoTGpioSetOutputVal(HI_GPIO_9, value); // GPIO9
93 }
94 /* gpio init */
GpioControl(unsigned int gpio, unsigned int id, IotGpioDir dir, IotGpioValue gpioVal, unsigned char val)95 void GpioControl(unsigned int gpio, unsigned int id, IotGpioDir dir, IotGpioValue  gpioVal,
96                  unsigned char val)
97 {
98     IoSetFunc(gpio, val);
99     IoTGpioSetDir(id, dir);
100     IoTGpioSetOutputVal(id, gpioVal);
101 }
102 /* pwm init */
PwmInit(unsigned int id, unsigned char val, unsigned int port)103 void PwmInit(unsigned int id, unsigned char val, unsigned int port)
104 {
105     IoSetFunc(id, val); /* PWM0 OUT */
106     IoTPwmInit(port);
107 }
108 /* gpio key init */
HiSwitchInit(unsigned int id, unsigned char val, unsigned int idx, IotGpioDir dir, IotIoPull pval)109 void HiSwitchInit(unsigned int id, unsigned char val,
110                   unsigned int idx, IotGpioDir dir, IotIoPull pval)
111 {
112     IoSetFunc(id, val);
113     IoTGpioSetDir(idx, dir);
114     IoSetPull(id, pval);
115 }
116 
117 /*
118  * VCC：5V
119  * blue:  gpio12 yellow
120  * green: gpio11 green
121  * red: gpio10 red
122  * switch ：
123  * gpio7 switch1
124  * gpio5 switch2
125  */
126 
TestGpioInit(void)127 void TestGpioInit(void)
128 {
129     // switch2,GPIO5,GPIO8,0
130     HiSwitchInit(HI_GPIO_5, 0, HI_GPIO_5, IOT_GPIO_DIR_IN, IOT_IO_PULL_UP);
131     // switch2,GPIO5,GPIO8,0
132     HiSwitchInit(HI_GPIO_8, 0, HI_GPIO_8, IOT_GPIO_DIR_IN, IOT_IO_PULL_UP);
133 
134     PwmInit(HI_GPIO_10, HI_PWM_OUT, HI_PWM1); // GPIO10 PWM port1,5
135     PwmInit(HI_GPIO_11, HI_PWM_OUT, HI_PWM2); // GPIO11 PWM port2,5
136     PwmInit(HI_GPIO_12, HI_PWM_OUT, HI_PWM3); // GPIO12 PWM port3,5
137 }
138 
139 /* 所有pwm的占空比为1，所有灯熄灭 */
AllLightOut(void)140 void AllLightOut(void)
141 {
142     IoTPwmStart(HI_PWM1, PWM_LOW_DUTY, PWM_SMALL_DUTY); /* 1 */
143     IoTPwmStart(HI_PWM2, PWM_LOW_DUTY, PWM_SMALL_DUTY); /* 2 */
144     IoTPwmStart(HI_PWM3, PWM_LOW_DUTY, PWM_SMALL_DUTY); /* 3 */
145 }
146 
147 /*
148  * 三色灯控制模式：每按一下类型S1按键，在绿灯亮、黄灯亮、红灯亮，三个状态之间切换
149  * mode:1.control mode
150  * type:1.red on,2.yellow on,3.green on,RED_ON = 1,YELLOW_ON,GREEN_ON,
151  */
ControlModeSample(void)152 void ControlModeSample(void)
153 {
154     unsigned char currentType = 0;
155     unsigned char currentMode = 0;
156 
157     currentMode = GetKeyStatus(CURRENT_MODE);
158     currentType = GetKeyStatus(CURRENT_TYPE);
159     while (1) {
160         switch (GetKeyStatus(CURRENT_TYPE)) {
161             case RED_ON:
162                 IoTPwmStart(HI_PWM1, PWM_DUTY, PWM_SMALL_DUTY); /* 1 */
163                 IoTPwmStart(HI_PWM2, PWM_LOW_DUTY, PWM_SMALL_DUTY); /* 2 */
164                 IoTPwmStart(HI_PWM3, PWM_LOW_DUTY, PWM_SMALL_DUTY); /* 3 */
165                 break;
166             case YELLOW_ON:
167                 IoTPwmStart(HI_PWM1, PWM_LOW_DUTY, PWM_SMALL_DUTY); /* 1 */
168                 IoTPwmStart(HI_PWM2, PWM_DUTY, PWM_SMALL_DUTY); /* 2 */
169                 IoTPwmStart(HI_PWM3, PWM_LOW_DUTY, PWM_SMALL_DUTY); /* 3 */
170                 break;
171             case GREEN_ON:
172                 IoTPwmStart(HI_PWM1, PWM_LOW_DUTY, PWM_SMALL_DUTY); /* 1 */
173                 IoTPwmStart(HI_PWM2, PWM_LOW_DUTY, PWM_SMALL_DUTY); /* 2 */
174                 IoTPwmStart(HI_PWM3, PWM_DUTY, PWM_SMALL_DUTY); /* 3 */
175                 break;
176             default:
177                 break;
178         }
179 
180         if ((currentMode != GetKeyStatus(CURRENT_MODE)) || (currentType != GetKeyStatus(CURRENT_TYPE))) {
181             AllLightOut();
182             break;
183         }
184         hi_sleep(SLEEP_1_MS);
185     }
186 }
187 
188 /* 中断检测函数，每10ms检测一次 */
DelayAndCheckKeyInterrupt(unsigned int delayTime)189 unsigned char DelayAndCheckKeyInterrupt(unsigned int delayTime)
190 {
191     unsigned int cycleCount = delayTime / DELAY_10_MS;
192     unsigned char currentType = 0;
193     unsigned char currentMode = 0;
194 
195     currentMode = GetKeyStatus(CURRENT_MODE);
196     currentType = GetKeyStatus(CURRENT_TYPE);
197 
198     for (unsigned int i = 0; i < cycleCount; i++) {
199         if ((currentMode != GetKeyStatus(CURRENT_MODE)) || (currentType != GetKeyStatus(CURRENT_TYPE))) {
200             return KEY_DOWN_INTERRUPT;
201         }
202         hi_udelay(DELAY_5_MS); // 10ms
203         hi_sleep(SLEEP_1_MS);
204     }
205     return HI_NULL;
206 }
207 
208 /* 红、黄、绿每1秒轮流亮 */
CycleForOneSecond(void)209 void CycleForOneSecond(void)
210 {
211     while (1) {
212         IoTPwmStart(HI_PWM1, PWM_DUTY, PWM_SMALL_DUTY); /* 1 */
213         if (DelayAndCheckKeyInterrupt(DELAY_1_S) == KEY_DOWN_INTERRUPT) {
214             IoTPwmStart(HI_PWM1, PWM_LOW_DUTY, PWM_SMALL_DUTY); /* 1 */
215             break;
216         }
217 
218         IoTPwmStart(HI_PWM1, PWM_LOW_DUTY, PWM_SMALL_DUTY); /* 1 */
219         IoTPwmStart(HI_PWM2, PWM_DUTY, PWM_SMALL_DUTY); /* 2 */
220 
221         if (DelayAndCheckKeyInterrupt(DELAY_1_S) == KEY_DOWN_INTERRUPT) {
222             IoTPwmStart(HI_PWM2, PWM_LOW_DUTY, PWM_SMALL_DUTY); /* 2 */
223             break;
224         }
225 
226         IoTPwmStart(HI_PWM2, PWM_LOW_DUTY, PWM_SMALL_DUTY); /* 2 */
227         IoTPwmStart(HI_PWM3, PWM_DUTY, PWM_SMALL_DUTY); /* 3 */
228 
229         if (DelayAndCheckKeyInterrupt(DELAY_1_S) == KEY_DOWN_INTERRUPT) {
230             IoTPwmStart(HI_PWM3, PWM_LOW_DUTY, PWM_SMALL_DUTY); /* 3 */
231             break;
232         }
233         IoTPwmStart(HI_PWM3, PWM_LOW_DUTY, PWM_SMALL_DUTY); /* 3 */
234         hi_sleep(SLEEP_1_MS);
235     }
236 }
237 
238 /* 红、黄、绿每0.5秒轮流亮 */
CycleForHalfSecond(void)239 void CycleForHalfSecond(void)
240 {
241     while (1) {
242         IoTPwmStart(HI_PWM1, PWM_DUTY, PWM_SMALL_DUTY); /* 1 */
243         if (DelayAndCheckKeyInterrupt(DELAY_500_MS) == KEY_DOWN_INTERRUPT) {
244             IoTPwmStart(HI_PWM1, PWM_LOW_DUTY, PWM_SMALL_DUTY); /* 1 */
245             break;
246         }
247         IoTPwmStart(HI_PWM1, PWM_LOW_DUTY, PWM_SMALL_DUTY); /* 1 */
248         IoTPwmStart(HI_PWM2, PWM_DUTY, PWM_SMALL_DUTY); /* 2 */
249 
250         if (DelayAndCheckKeyInterrupt(DELAY_500_MS) == KEY_DOWN_INTERRUPT) {
251             IoTPwmStart(HI_PWM2, PWM_LOW_DUTY, PWM_SMALL_DUTY); /* 2 */
252             break;
253         }
254 
255         IoTPwmStart(HI_PWM2, PWM_LOW_DUTY, PWM_SMALL_DUTY); /* 2 */
256         IoTPwmStart(HI_PWM3, PWM_DUTY, PWM_SMALL_DUTY); /* 3 */
257 
258         if (DelayAndCheckKeyInterrupt(DELAY_500_MS) == KEY_DOWN_INTERRUPT) {
259             IoTPwmStart(HI_PWM3, PWM_LOW_DUTY, PWM_SMALL_DUTY); /* 3 */
260             break;
261         }
262         IoTPwmStart(HI_PWM3, PWM_LOW_DUTY, PWM_SMALL_DUTY); /* 3 */
263         hi_sleep(SLEEP_1_MS);
264     }
265 }
266 
267 /* 红、黄、绿每0.25秒轮流亮 */
CycleForQuarterSecond(void)268 void CycleForQuarterSecond(void)
269 {
270     while (1) {
271         IoTPwmStart(HI_PWM1, PWM_DUTY, PWM_SMALL_DUTY); /* 1 */
272 
273         if (DelayAndCheckKeyInterrupt(DELAY_250_MS) == KEY_DOWN_INTERRUPT) {
274             IoTPwmStart(HI_PWM1, PWM_LOW_DUTY, PWM_SMALL_DUTY); /* 1 */
275             break;
276         }
277 
278         IoTPwmStart(HI_PWM1, PWM_LOW_DUTY, PWM_SMALL_DUTY); /* 1 */
279         IoTPwmStart(HI_PWM2, PWM_DUTY, PWM_SMALL_DUTY); /* 2 */
280 
281         if (DelayAndCheckKeyInterrupt(DELAY_250_MS) == KEY_DOWN_INTERRUPT) {
282             IoTPwmStart(HI_PWM2, PWM_LOW_DUTY, PWM_SMALL_DUTY); /* 2 */
283             break;
284         }
285 
286         IoTPwmStart(HI_PWM2, PWM_LOW_DUTY, PWM_SMALL_DUTY); /* 2 */
287         IoTPwmStart(HI_PWM3, PWM_DUTY, PWM_SMALL_DUTY); /* 3 */
288 
289         if (DelayAndCheckKeyInterrupt(DELAY_250_MS) == KEY_DOWN_INTERRUPT) {
290             IoTPwmStart(HI_PWM3, PWM_LOW_DUTY, PWM_SMALL_DUTY); /* 3 */
291             break;
292         }
293         IoTPwmStart(HI_PWM3, PWM_LOW_DUTY, PWM_SMALL_DUTY); /* 3 */
294         hi_sleep(SLEEP_1_MS);
295     }
296 }
297 
298 /*
299  * mode:2.Colorful light
300  * type:1.period by 1s,2.period by 0.5s,3.period by 0.25s
301  * 模式2：炫彩模式，每按一下S2，不同的炫彩类型，
302  * 类型1：红、黄、绿三色灯每隔1秒轮流亮
303  * 类型2：红、黄、绿每0.5秒轮流亮
304  * 类型3：红、黄、绿每0.25秒轮流亮。
305  */
306 
ColorfulLightSample(void)307 void ColorfulLightSample(void)
308 {
309     unsigned char currentType = 0;
310     unsigned char currentMode = 0;
311 
312     currentMode = GetKeyStatus(CURRENT_MODE);
313     currentType = GetKeyStatus(CURRENT_TYPE);
314 
315     while (1) {
316         switch (GetKeyStatus(CURRENT_TYPE)) {
317             case CYCLE_FOR_ONE_SECOND:
318                 CycleForOneSecond();
319                 break;
320             case CYCLE_FOR_HALF_SECOND:
321                 CycleForHalfSecond();
322                 break;
323             case CYCLE_FOR_QUARTER_SECOND:
324                 CycleForQuarterSecond();
325                 break;
326             default:
327                 break;
328         }
329 
330         if ((currentMode != GetKeyStatus(CURRENT_MODE)) || (currentType != GetKeyStatus(CURRENT_TYPE))) {
331             break;
332         }
333         hi_sleep(SLEEP_1_MS);
334     }
335 }
336 
337 /* 红色由暗到最亮 */
RedLightDarkToBright(void)338 void RedLightDarkToBright(void)
339 {
340     unsigned char currentType = 0;
341     unsigned char currentMode = 0;
342 
343     currentMode = GetKeyStatus(CURRENT_MODE);
344     currentType = GetKeyStatus(CURRENT_TYPE);
345     AllLightOut();
346     while (1) {
347         for (unsigned int i = 1; i < DELAY_TIMES_100; i++) { /* 计算延时100次 */
348             IoTPwmStart(HI_PWM1, i, PWM_SMALL_DUTY); /* 1 */
349             if ((currentMode != GetKeyStatus(CURRENT_MODE)) || (currentType != GetKeyStatus(CURRENT_TYPE))) {
350                 return NULL;
351             }
352             hi_sleep((SLEEP_6_S - i + 1) / SLEEP_30_MS); /* 1 */
353         }
354     }
355 }
356 
357 /* 绿灯由暗到最亮 */
GreenLightDarkToBright(void)358 void GreenLightDarkToBright(void)
359 {
360     unsigned char currentType = 0;
361     unsigned char currentMode = 0;
362 
363     currentMode = GetKeyStatus(CURRENT_MODE);
364     currentType = GetKeyStatus(CURRENT_TYPE);
365     AllLightOut();
366     while (1) {
367         for (hi_s32 i = 1; i < DELAY_TIMES_100; i++) { /* 计算延时100次 */
368             IoTPwmStart(HI_PWM2, i, PWM_SMALL_DUTY); /* PWM0 */
369             if ((currentMode != GetKeyStatus(CURRENT_MODE)) || (currentType != GetKeyStatus(CURRENT_TYPE))) {
370                 return NULL;
371             }
372             hi_sleep((SLEEP_6_S - i + 1) / SLEEP_30_MS); /* 1 */
373         }
374     }
375 }
376 
377 /* 蓝灯由暗到最亮 */
BlueLightDarkToBright(void)378 void BlueLightDarkToBright(void)
379 {
380     unsigned char currentType = 0;
381     unsigned char currentMode = 0;
382 
383     currentMode = GetKeyStatus(CURRENT_MODE);
384     currentType = GetKeyStatus(CURRENT_TYPE);
385     AllLightOut();
386     while (1) {
387         for (int i = 1; i < DELAY_TIMES_100; i++) { /* 计算延时100次 */
388             if ((currentMode != GetKeyStatus(CURRENT_MODE)) || (currentType != GetKeyStatus(CURRENT_TYPE))) {
389                 return NULL;
390             }
391             IoTPwmStart(HI_PWM3, i, PWM_SMALL_DUTY); /* PWM3 */
392 
393             hi_sleep((SLEEP_6_S - i + 1) / SLEEP_30_MS); /* 1 */
394         }
395     }
396 }
397 
398 /* 紫色灯由暗到最亮 */
PurpleLightDarkToBright(void)399 void PurpleLightDarkToBright(void)
400 {
401     unsigned char currentType = 0;
402     unsigned char currentMode = 0;
403 
404     currentMode = GetKeyStatus(CURRENT_MODE);
405     currentType = GetKeyStatus(CURRENT_TYPE);
406     AllLightOut();
407     while (1) {
408         for (int i = 0; i < DELAY_TIMES_5; i++) { /* 计算延时5次 */
409             IoTPwmStart(HI_PWM1, PWM_FRQ_50 + (i * PWM_FRQ_10), PWM_SMALL_DUTY); /* 1 */
410             IoTPwmStart(HI_PWM2, i, PWM_SMALL_DUTY); /* 2 */
411             IoTPwmStart(HI_PWM3, PWM_FRQ_50 + (i * PWM_FRQ_10), PWM_SMALL_DUTY); /* 3 */
412             if ((currentMode != GetKeyStatus(CURRENT_MODE)) || (currentType != GetKeyStatus(CURRENT_TYPE))) {
413                 return NULL;
414             }
415             hi_sleep(SLEEP_50_MS);
416         }
417     }
418 }
419 
420 /* 白灯由暗到全亮。 */
AllLightDarkToBright(void)421 void AllLightDarkToBright(void)
422 {
423     unsigned char currentType = 0;
424     unsigned char currentMode = 0;
425 
426     currentMode = GetKeyStatus(CURRENT_MODE);
427     currentType = GetKeyStatus(CURRENT_TYPE);
428     AllLightOut();
429     while (1) {
430         for (int i = 1; i < DELAY_TIMES_100; i++) { /* 计算延时100次 */
431             IoTPwmStart(HI_PWM1, i, PWM_SMALL_DUTY); /* 1 */
432             IoTPwmStart(HI_PWM2, i, PWM_SMALL_DUTY); /* 2 */
433             IoTPwmStart(HI_PWM3, i, PWM_SMALL_DUTY); /* 3 */
434             if ((currentMode != GetKeyStatus(CURRENT_MODE)) || (currentType != GetKeyStatus(CURRENT_TYPE))) {
435                 return NULL;
436             }
437             hi_sleep((SLEEP_6_S - i + 1) / SLEEP_30_MS); /* 1 */
438         }
439     }
440 }
441 
442 /*
443  * mode:3.pwm control
444  * type:1.red,2.yellow,3.green,4.purple,5.all
445  * 模式3：PWM无极调光模式，每按一下S2，不同的调光类型
446  * 类型1：红色由暗到最亮
447  * 类型2：黄灯由暗到最亮
448  * 类型3：绿灯由暗到最亮
449  * 类型4：紫色由暗到最亮
450  * 类型5：由暗到全亮。
451  */
452 
PwmControlSample(void)453 void PwmControlSample(void)
454 {
455     unsigned char currentType = 0;
456     unsigned char currentMode = 0;
457 
458     currentMode = GetKeyStatus(CURRENT_MODE);
459     currentType = GetKeyStatus(CURRENT_TYPE);
460     printf("PwmControlSample\n");
461     AllLightOut();
462     while (1) {
463         switch (GetKeyStatus(CURRENT_TYPE)) {
464             case PWM_CONTROL_RED:
465                 RedLightDarkToBright();
466                 break;
467             case PWM_CONTROL_YELLOW:
468                 RedLightDarkToBright();
469                 break;
470             case PWM_CONTROL_GREEN:
471                 RedLightDarkToBright();
472                 break;
473             case PWM_CONTROL_PURPLE:
474                 RedLightDarkToBright();
475                 break;
476             case PWM_CONTROL_ALL:
477                 AllLightDarkToBright();
478                 break;
479             default:
480                 break;
481         }
482 
483         if ((currentMode != GetKeyStatus(CURRENT_MODE)) || (currentType != GetKeyStatus(CURRENT_TYPE))) {
484             break;
485         }
486         hi_sleep(SLEEP_20_MS);
487     }
488 }
489 
490 /* 用按键控制白灯的亮度 */
BrightnessControlSample(void)491 void BrightnessControlSample(void)
492 {
493     unsigned char currentType = 0;
494     unsigned char currentMode = 0;
495 
496     currentMode = GetKeyStatus(CURRENT_MODE);
497     currentType = GetKeyStatus(CURRENT_TYPE);
498     AllLightOut();
499     while (1) {
500         switch (GetKeyStatus(CURRENT_TYPE)) {
501             case BRIGHTNESS_LOW:
502                 IoTPwmStart(HI_PWM1, PWM_FRQ_20, PWM_SMALL_DUTY); /* 1, 20 */
503                 IoTPwmStart(HI_PWM2, PWM_FRQ_20, PWM_SMALL_DUTY); /* 2, 20 */
504                 IoTPwmStart(HI_PWM3, PWM_FRQ_20, PWM_SMALL_DUTY); /* 3, 20 */
505                 break;
506             case BRIGHTNESS_MIDDLE:
507                 IoTPwmStart(HI_PWM1, PWM_FRQ_50, PWM_SMALL_DUTY); /* 1, 20 */
508                 IoTPwmStart(HI_PWM2, PWM_FRQ_50, PWM_SMALL_DUTY); /* 2, 20 */
509                 IoTPwmStart(HI_PWM3, PWM_FRQ_50, PWM_SMALL_DUTY); /* 3, 20 */
510                 break;
511             case BRIGHTNESS_HIGH:
512                 IoTPwmStart(HI_PWM1, PWM_FRQ_100, PWM_SMALL_DUTY); /* 1, 20 */
513                 IoTPwmStart(HI_PWM2, PWM_FRQ_100, PWM_SMALL_DUTY); /* 2, 20 */
514                 IoTPwmStart(HI_PWM3, PWM_FRQ_100, PWM_SMALL_DUTY); /* 3, 20 */
515                 break;
516             default:
517                 break;
518         }
519 
520         if ((currentMode != GetKeyStatus(CURRENT_MODE)) || (currentType != GetKeyStatus(CURRENT_TYPE))) {
521             break;
522         }
523         hi_sleep(SLEEP_10_MS);
524     }
525 }
526 
527 /*
528  * mode:5.Human detect
529  * 模式5：人体红外检测模式（设置一个好看的灯亮度）,有人靠近灯亮，无人在检测区域灯灭
530  */
HumanDetectSample(void)531 void HumanDetectSample(void)
532 {
533     unsigned char currentMode = 0;
534     unsigned char someoneWalking = 0;
535 
536     currentMode = GetKeyStatus(CURRENT_MODE);
537     someoneWalking = GetKeyStatus(SOMEONE_WALKING);
538     printf("HumanDetectSample start\n");
539     IoSetFunc(HI_GPIO_7, 0); // gpio7
540     IoTGpioSetDir(HI_GPIO_7, IOT_GPIO_DIR_IN); // gpio7
541     IotGpioValue gpio_val = IOT_GPIO_VALUE1;
542 
543     while (1) {
544         /* use adc channel_0 */
545         /* use gpio7 */
546         IoTGpioGetInputVal(HI_GPIO_7, &gpio_val); // gpio7
547 
548         if (gpio_val == IOT_GPIO_VALUE1) {
549             someoneWalking = OLED_FLAG_ON;
550         } else {
551             someoneWalking = OLED_FLAG_OFF;
552         }
553         if (someoneWalking == OLED_FLAG_ON) {
554             IoTPwmStart(HI_PWM1, PWM_FRQ_50, PWM_SMALL_DUTY); /* 1,占空比百分之50 */
555             IoTPwmStart(HI_PWM2, PWM_FRQ_50, PWM_SMALL_DUTY); /* 2,占空比百分之50 */
556             IoTPwmStart(HI_PWM3, PWM_FRQ_50, PWM_SMALL_DUTY); /* 3,占空比百分之50 */
557         } else if (someoneWalking == OLED_FLAG_OFF) {
558             IoTPwmStart(HI_PWM1, PWM_LOW_DUTY, PWM_SMALL_DUTY); /* 1,占空比百分之50 */
559             IoTPwmStart(HI_PWM2, PWM_LOW_DUTY, PWM_SMALL_DUTY); /* 2,占空比百分之50 */
560             IoTPwmStart(HI_PWM3, PWM_LOW_DUTY, PWM_SMALL_DUTY); /* 3,占空比百分之50 */
561         }
562         if (currentMode != GetKeyStatus(CURRENT_MODE)) {
563             IoTPwmStart(HI_PWM1, PWM_LOW_DUTY, PWM_SMALL_DUTY); /* 1,占空比百分之50 */
564             IoTPwmStart(HI_PWM2, PWM_LOW_DUTY, PWM_SMALL_DUTY); /* 2,占空比百分之50 */
565             IoTPwmStart(HI_PWM3, PWM_LOW_DUTY, PWM_SMALL_DUTY); /* 3,占空比百分之50 */
566             break;
567         }
568         hi_sleep(SLEEP_1_MS);
569     }
570 }
571 
572 /*
573  * mode:6.Light detect
574  * 模式6：光敏检测模式,无光灯亮，有光灯灭
575  */
LightDetectSample(void)576 void LightDetectSample(void)
577 {
578     unsigned char currentMode = 0;
579     unsigned char withLigh = 0;
580 
581     currentMode = GetKeyStatus(CURRENT_MODE);
582     while (1) {
583         withLigh = GetLightStatus();
584         if (withLigh == OLED_FLAG_ON) {
585             IoTPwmStart(HI_PWM1, PWM_FRQ_50, PWM_SMALL_DUTY); /* 1,占空比百分之50 */
586             IoTPwmStart(HI_PWM2, PWM_FRQ_50, PWM_SMALL_DUTY); /* 2,占空比百分之50 */
587             IoTPwmStart(HI_PWM3, PWM_FRQ_50, PWM_SMALL_DUTY); /* 3,占空比百分之50 */
588         } else if (withLigh == OLED_FLAG_OFF) {
589             IoTPwmStart(HI_PWM1, PWM_LOW_DUTY, PWM_SMALL_DUTY); /* 1,占空比百分之50 */
590             IoTPwmStart(HI_PWM2, PWM_LOW_DUTY, PWM_SMALL_DUTY); /* 2,占空比百分之50 */
591             IoTPwmStart(HI_PWM3, PWM_LOW_DUTY, PWM_SMALL_DUTY); /* 3,占空比百分之50 */
592         }
593         if (currentMode != GetKeyStatus(CURRENT_MODE)) {
594             IoTPwmStart(HI_PWM1, PWM_LOW_DUTY, PWM_SMALL_DUTY); /* 1,占空比百分之50 */
595             IoTPwmStart(HI_PWM2, PWM_LOW_DUTY, PWM_SMALL_DUTY); /* 2,占空比百分之50 */
596             IoTPwmStart(HI_PWM3, PWM_LOW_DUTY, PWM_SMALL_DUTY); /* 3,占空比百分之50 */
597             break;
598         }
599         hi_sleep(SLEEP_1_MS);
600     }
601 }
602 
603 /*
604  * mode:7.Union detect
605  * 模式7：人体红外+光敏联合检测模式。
606  * 无人有光照 => 灯不亮
607  * 无人无光照 => 灯不亮
608  * 有人有光照 => 灯不亮
609  * 有人无光照 => 灯亮
610  * g_withLightFlag = OLED_FLAG_ON：无光照(黑夜)，OLED_FLAG_OFF有光照(白天)
611  * g_someoneWalkingFlag = OLED_FLAG_ON(有人)，OLED_FLAG_OFF(无人)
612  */
UnionDetectSample(void)613 void UnionDetectSample(void)
614 {
615     unsigned char currentMode = 0;
616     unsigned char withLigh = 0;
617     unsigned char someoneWalking = 0;
618 
619     currentMode = GetKeyStatus(CURRENT_MODE);
620     someoneWalking = GetKeyStatus(SOMEONE_WALKING);
621     IoSetFunc(HI_GPIO_7, 0); // gpio7
622     IoTGpioSetDir(HI_GPIO_7, IOT_GPIO_DIR_IN); // gpio7
623     IotGpioValue gpio_val = IOT_GPIO_VALUE1;
624 
625     while (1) {
626         IoTGpioGetInputVal(HI_GPIO_7, &gpio_val); // gpio7
627         if (gpio_val == IOT_GPIO_VALUE1) {
628             someoneWalking =  OLED_FLAG_ON;
629         } else {
630             someoneWalking =  OLED_FLAG_OFF;
631         }
632         withLigh = GetLightStatus();
633         if (((someoneWalking == OLED_FLAG_ON) && (withLigh == OLED_FLAG_OFF)) ||
634             (someoneWalking == OLED_FLAG_OFF)) {
635             IoTPwmStart(HI_PWM1, PWM_LOW_DUTY, PWM_SMALL_DUTY); /* 1,占空比百分之50 */
636             IoTPwmStart(HI_PWM2, PWM_LOW_DUTY, PWM_SMALL_DUTY); /* 2,占空比百分之50 */
637             IoTPwmStart(HI_PWM3, PWM_LOW_DUTY, PWM_SMALL_DUTY); /* 3,占空比百分之50 */
638         } else if ((withLigh == OLED_FLAG_ON) && (someoneWalking == OLED_FLAG_ON)) {
639             IoTPwmStart(HI_PWM1, PWM_FRQ_50, PWM_SMALL_DUTY); /* 1,占空比百分之50 */
640             IoTPwmStart(HI_PWM2, PWM_FRQ_50, PWM_SMALL_DUTY); /* 2,占空比百分之50 */
641             IoTPwmStart(HI_PWM3, PWM_FRQ_50, PWM_SMALL_DUTY); /* 3,占空比百分之50 */
642         }
643         if (currentMode != GetKeyStatus(CURRENT_MODE)) {
644             IoTPwmStart(HI_PWM1, PWM_LOW_DUTY, PWM_SMALL_DUTY);
645             break;
646         }
647         hi_sleep(SLEEP_1_MS);
648     }
649 }
650 
651 /*
652  * mode:8.Return
653  * 模式8：返回主界面
654  */
ReturnMainEnumSample(void)655 void ReturnMainEnumSample(void)
656 {
657     unsigned char currentType = 0;
658     unsigned char currentMode = 0;
659 
660     currentMode = GetKeyStatus(CURRENT_MODE);
661     currentType = GetKeyStatus(CURRENT_TYPE);
662 
663     while (1) {
664         switch (GetKeyStatus(CURRENT_TYPE)) {
665             case KEY_UP:
666                 break;
667             case KEY_DOWN:
668                 return;
669             default:
670                 break;
671         }
672 
673         if (currentMode != GetKeyStatus(CURRENT_MODE)) {
674             break;
675         }
676         task_msleep(SLEEP_1_MS);
677     }
678 }
Gpio9LedLightFunc(void)679 void Gpio9LedLightFunc(void)
680 {
681     globalStaType.g_gpio9Tick++;
682     if (globalStaType.g_gpio9Tick % PAIR_2 == 0) { /* tick 时间 对2 求余， 余数为0则打开LED灯，否则关闭LED灯，即不断闪烁 */
683         printf("led off\r\n");
684         HisparkBoardTest(IOT_GPIO_VALUE1);
685     } else {
686         printf("led on\r\n");
687         HisparkBoardTest(IOT_GPIO_VALUE1);
688     }
689 }
690 
OledShowMenuSelect(void)691 void OledShowMenuSelect(void)
692 {
693     unsigned char currentMode = 0;
694 
695     switch (GetKeyStatus(MENU_SELECT)) {
696         case COLORFUL_LIGHT_MENU:
697             if (GetKeyStatus(CURRENT_MODE) >= MAX_COLORFUL_LIGHT_MODE) {
698                 currentMode = SetKeyStatus(CONTROL_MODE);
699             }
700             break;
701         case TRAFFIC_LIGHT_MENU:
702             if (GetKeyStatus(CURRENT_MODE) >= MAX_TRAFFIC_LIGHT_MODE) {
703                 currentMode = SetKeyStatus(CONTROL_MODE);
704             }
705             break;
706         case ENVIRONMENT_MENU:
707             if (GetKeyStatus(CURRENT_MODE) >= MAX_ENVIRONMENT_MODE) {
708                 currentMode = SetKeyStatus(CONTROL_MODE);
709             }
710             break;
711         case NFC_TEST_MENU:
712             if (GetKeyStatus(CURRENT_MODE) >= MAX_NFC_TAG_MODE) {
713                 currentMode = SetKeyStatus(CONTROL_MODE);
714             }
715             break;
716         default:
717             break;
718     }
719 }
720 
721 /*
722  * 按键7每按下一次，就会产生中断并调用该函数
723  * 用来调整类型
724  */
GpioKey1IsrFuncMode(void)725 void GpioKey1IsrFuncMode(void)
726 {
727     unsigned char currentType = 0;
728     unsigned int currentGpio5Tick = hi_get_tick();
729     unsigned int tickInterval = currentGpio5Tick - globalStaType.g_gpio5Tick;
730     if (tickInterval < KEY_INTERRUPT_PROTECT_TIME) {
731         return HI_NULL;
732     }
733     globalStaType.g_gpio5Tick = currentGpio5Tick;
734     globalStaType.g_keyDownFlag = KEY_GPIO_5;
735     printf("gpio key 1 down\r\n");
736     if (GetKeyStatus(MENU_MODE) == MAIN_FUNCTION_SELECT_MODE) {
737         printf("gpio key 1 menu select\r\n");
738         globalStaType.g_menuSelect++;
739         if (globalStaType.g_menuSelect >= MAX_FUNCTION_DEMO_NUM) {
740             globalStaType.g_menuSelect = COLORFUL_LIGHT_MENU;
741         }
742         return HI_ERR_SUCCESS;
743     }
744 
745     if (GetKeyStatus(MENU_MODE) == SUB_MODE_SELECT_MODE) {
746         printf("gpio key 1 current mode\r\n");
747         globalStaType.g_currentMode++;
748         if (globalStaType.g_currentMode > TRAFFIC_RETURN_MODE) {
749             globalStaType.g_currentMode = 0;
750         }
751         currentType = SetKeyType(CONTROL_MODE);
752         OledShowTrafficLightMenuSelect();
753     }
754 }
755 
OledShowColorfulLightMenuSelect(void)756 void OledShowColorfulLightMenuSelect(void)
757 {
758     unsigned char currentType = 0;
759     switch (GetKeyStatus(CURRENT_MODE)) {
760         case CONTROL_MODE:
761             if (GetKeyStatus(CURRENT_TYPE) > MAX_CONTROL_MODE_TYPE) {
762                 currentType = SetKeyType(RED_ON);
763             }
764             break;
765         case COLORFUL_LIGHT_MODE:
766             if (GetKeyStatus(CURRENT_TYPE) > MAX_COLORFUL_LIGHT_TYPE) {
767                 currentType = SetKeyType(CYCLE_FOR_ONE_SECOND);
768             }
769             break;
770         case PWM_CONTROL_MODE:
771             if (GetKeyStatus(CURRENT_TYPE) > MAX_PWM_CONTROL_TYPE) {
772                 currentType = SetKeyType(PWM_CONTROL_RED);
773             }
774             break;
775         case BRIGHTNESS_MODE:
776             if (GetKeyStatus(CURRENT_TYPE) > MAX_BRIGHTNESS_TYPE) {
777                 currentType = SetKeyType(BRIGHTNESS_LOW);
778             }
779             break;
780         case HUMAN_DETECT_MODE:
781         case LIGHT_DETECT_MODE:
782         case UNION_DETECT_MODE:
783         case RETURN_MODE:
784             if (GetKeyStatus(CURRENT_TYPE) > RETURN_TYPE_MODE) {
785                 currentType = SetKeyType(KEY_UP);
786             }
787             break;
788         default:
789             break;
790     }
791 }
OledShowTrafficLightMenuSelect(void)792 void OledShowTrafficLightMenuSelect(void)
793 {
794     unsigned char currentType = 0;
795     switch (GetKeyStatus(CURRENT_MODE)) {
796         case TRAFFIC_CONTROL_MODE:
797             if (GetKeyStatus(CURRENT_TYPE) >= MAX_TRAFFIC_CONTROL_TYPE) {
798                 currentType = SetKeyType(TRAFFIC_NORMAL_TYPE);
799             }
800             break;
801         case TRAFFIC_AUTO_MODE:
802             if (GetKeyStatus(CURRENT_TYPE) > MAX_TRAFFIC_AUTO_TYPE) {
803                 currentType = SetKeyType(TRAFFIC_NORMAL_TYPE);
804             }
805             break;
806         case TRAFFIC_HUMAN_MODE:
807             if (GetKeyStatus(CURRENT_TYPE) > MAX_TRAFFIC_HUMAN_TYPE) {
808                 currentType = SetKeyType(TRAFFIC_NORMAL_TYPE);
809             }
810             break;
811         case TRAFFIC_RETURN_MODE:
812             if (GetKeyStatus(CURRENT_TYPE) > RETURN_TYPE_MODE) {
813                 currentType = SetKeyType(KEY_UP);
814             }
815             break;
816         default:
817             break;
818     }
819 }
820 /*
821  * 按键7每按下一次，就会产生中断并调用该函数
822  * 用来调整类型
823  */
GpioKey2IsrFuncType(void)824 void GpioKey2IsrFuncType(void)
825 {
826     /* 按键防抖 */
827     unsigned int currentGpio7Tick = hi_get_tick();
828     unsigned int tickInterval = currentGpio7Tick - globalStaType.g_gpio7Tick;
829 
830     if (tickInterval < KEY_INTERRUPT_PROTECT_TIME) {
831         return HI_NULL;
832     }
833     globalStaType.g_gpio7Tick = currentGpio7Tick;
834     globalStaType.g_keyDownFlag = KEY_GPIO_7;
835     printf("gpio key 2 down %d\r\n", globalStaType.g_currentType);
836     globalStaType.g_currentType++;
837     OledShowTrafficLightMenuSelect();
838 }
839 
Gpio8Interrupt(const char *param)840 void Gpio8Interrupt(const char *param)
841 {
842     hi_unref_param(param);
843     unsigned int currentGpio8Tick = hi_get_tick();
844     unsigned int tickInterval = currentGpio8Tick - globalStaType.g_gpio8Tick;
845     printf("gpio8 interrupt \r\n");
846 
847     if (tickInterval < KEY_INTERRUPT_PROTECT_TIME) {
848         printf("gpio8 interrupt return\r\n");
849         return HI_NULL;
850     }
851     globalStaType.g_gpio8CurrentType++;
852     if (globalStaType.g_gpio8CurrentType % PAIR_2 == 0) {  /* tick 时间 对2 求余， 余数为0则打开蜂鸣器响，否则关闭L蜂鸣器 */
853         globalStaType.g_ocBeepStatus = BEEP_OFF;
854     } else {
855         globalStaType.g_ocBeepStatus = BEEP_ON;
856     }
857     if (globalStaType.g_gpio8CurrentType >= TICK_COUNT_MAX) { /* 避免越界，清零 */
858         globalStaType.g_gpio8CurrentType = 0;
859     }
860 }
861 
862 /*
863  * S2(gpio5)是模式按键，S1(gpio7)是类型按键。
864  * 1、三色灯控制模式：每按一下类型S1按键，在绿灯亮、黄灯亮、红灯亮，三个状态之间切换
865  * 2、炫彩模式，每按一下S2，不同的炫彩类型
866  * 3、PWM无极调光模式，每按一下S2，不同的调光类型
867  * 4、人体红外检测模式（设置一个好看的灯亮度）
868  * 5、光敏检测模式
869  * 6、人体红外+光敏联合检测模式。
870  * 7、返回模式
871  * 创建两个按键中断，按键响应后会调用对应的回调函数
872  */
AppMultiSampleDemo(void)873 void AppMultiSampleDemo(void)
874 {
875     unsigned int ret = 0;
876     hi_gpio_init();
877     globalStaType.g_gpio5Tick = hi_get_tick();
878 
879     globalStaType.g_menuSelect = TRAFFIC_LIGHT_MENU;
880     globalStaType.g_menuMode = SUB_MODE_SELECT_MODE;
881 
882     ret = IoTGpioRegisterIsrFunc(HI_GPIO_5, IOT_INT_TYPE_EDGE,
883         IOT_GPIO_EDGE_FALL_LEVEL_LOW, GetGpio5Voltage, NULL); /* 5 */
884     if (ret == IOT_SUCCESS) {
885         printf(" register gpio 5\r\n");
886     }
887     globalStaType.g_gpio8Tick = hi_get_tick();
888     ret = IoTGpioRegisterIsrFunc(HI_GPIO_8, IOT_INT_TYPE_EDGE,
889         IOT_GPIO_EDGE_FALL_LEVEL_LOW, Gpio8Interrupt, NULL); /* 8 */
890     if (ret == IOT_SUCCESS) {
891         printf(" register gpio8\r\n");
892     }
893 }