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