返回发烧友论坛
发 帖  

[文章]HarmonyOS HiSpark Wi-Fi IoT 套件试用连载】8.光敏电阻和人体红外

hehung
2020-12-22 21:46:40
阅读量0
光敏电阻人体HiSpark
0
0
`查看红外板子和光敏电阻板子的电路，发现光敏电阻的电路被设计成了数字端口，三局管只能控制通断。
同理，人体红外也是数字端口。
原理图如下：
人体红外连接的是GPIO7，光敏电阻连接的是GPIO9.

1.png
2.png



我设计的程序是：
光敏电阻的优先级最高，遮住光敏电阻的话，没有充足的光线，RGB LED亮蓝光，如果没有遮住光敏电阻，人体红外检测到了人体，三色RGB LED都会亮。否则灭掉。

  1. /*this is my first application*/
  2. /*2020/11/08*/

  4. #include <stdio.h>
  5. #include "ohos_init.h"
  6. #include "ohos_types.h"
  7. #include <stdio.h>

  9. #include <unistd.h>

  11. #include "ohos_init.h"
  12. #include "cmsis_os2.h"
  13. #include "wifiiot_gpio.h"
  14. #include "wifiiot_gpio_ex.h"
  15. #include "wifiiot_adc.h"

  17. #include <hi_types_base.h>
  18. #include <hi_i2c.h>
  19. #include <hi_early_debug.h>
  20. #include <hi_stdlib.h>

  22. #include <hi_adc.h>



  26. #define LED_INTERVAL_TIME_US 500000    /*500ms*/
  27. #define LED_TASK_STACK_SIZE 512
  28. #define LED_TASK_PRIO 25

  30. #define KEY_INTERVAL_TIME_US 10000    /*10ms*/
  31. #define KEY_TASK_STACK_SIZE 1024
  32. #define KEY_TASK_PRIO 24

  34. #define RGB_INTERVAL_TIME_US 10000    /*10ms*/
  35. #define RGB_TASK_STACK_SIZE 1024
  36. #define RGB_TASK_PRIO 23

  38. //static void *LedTask(const char *arg);
  39. static void *KeyTask(const char *arg);
  40. static void *RGBTask(const char *arg);

  42. /*LED Control*/
  43. // enum LedState {
  44. //     LED_ON = 0,
  45. //     LED_OFF,
  46. //     LED_SPARK,
  47. // };

  49. uint8_t RGB_ctrl = 0;


  52. // static void *LedTask(const char *arg)
  53. // {
  54. //     (void)arg;
  55. //     enum LedState g_ledState = LED_SPARK;
  56. //     g_ledState = LED_SPARK;
  57.    
  58. //     while (1) {
  59. //         switch (g_ledState) {
  60. //             case LED_ON:
  61. //                 GpioSetOutputVal(WIFI_IOT_IO_NAME_GPIO_9, 1);
  62. //                 usleep(LED_INTERVAL_TIME_US);
  63. //                 break;
  64. //             case LED_OFF:
  65. //                 GpioSetOutputVal(WIFI_IOT_IO_NAME_GPIO_9, 0);
  66. //                 usleep(LED_INTERVAL_TIME_US);
  67. //                 break;
  68. //             case LED_SPARK:
  69. //                 GpioSetOutputVal(WIFI_IOT_IO_NAME_GPIO_9, 0);
  70. //                 usleep(LED_INTERVAL_TIME_US);
  71. //                 GpioSetOutputVal(WIFI_IOT_IO_NAME_GPIO_9, 1);
  72. //                 usleep(LED_INTERVAL_TIME_US);
  73. //                 break;
  74. //             default:
  75. //                 usleep(LED_INTERVAL_TIME_US);
  76. //                 break;
  77. //         }
  78. //     }

  80. //     return NULL;
  81. // }

  83. // static void Led0Entry(void)
  84. // {
  85. //     osThreadAttr_t attr;

  87. //     GpioInit();
  88. //     IoSetFunc(WIFI_IOT_IO_NAME_GPIO_9, WIFI_IOT_IO_FUNC_GPIO_9_GPIO);
  89. //     GpioSetDir(WIFI_IOT_IO_NAME_GPIO_9, WIFI_IOT_GPIO_DIR_OUT);

  91. //     attr.name = "LedTask";
  92. //     attr.attr_bits = 0U;
  93. //     attr.cb_mem = NULL;
  94. //     attr.cb_size = 0U;
  95. //     attr.stack_mem = NULL;
  96. //     attr.stack_size = LED_TASK_STACK_SIZE;
  97. //     attr.priority = LED_TASK_PRIO;

  99. //     if (osThreadNew((osThreadFunc_t)LedTask, NULL, &attr) == NULL) {
  100. //         printf("[Led0Task] Falied to create LedTask!
  101. ");
  102. //     }
  103. // }
  104. // SYS_RUN(Led0Entry);

  106. /*OLED board KEY Control - vased on ADC input*/
  107. static void *KeyTask(const char *arg)
  108. {
  109.     (void)arg;

  111.     WifiIotGpioValue Key_Status = WIFI_IOT_GPIO_VALUE1;
  112.     WifiIotGpioValue Last_key_Status = WIFI_IOT_GPIO_VALUE1;
  113.     // hi_u16 Key_adc_value = 0u;
  114.     // hi_u32 ret = 0;

  116.     while (1) {
  117.         GpioGetInputVal(WIFI_IOT_IO_NAME_GPIO_5, &Key_Status);
  118. //        printf("%d
  119. ", Key_Status);

  121.         if((Key_Status == WIFI_IOT_GPIO_VALUE0) && (Last_key_Status != Key_Status))
  122.         {
  123.             RGB_ctrl ++;
  124.             printf("Key pressed, RGB_ctrl = %d
  125. ", RGB_ctrl);
  126.         }
  127.         else
  128.         {

  130.         }

  132. //         ret = hi_adc_read((hi_adc_channel_index)HI_ADC_CHANNEL_2, &Key_adc_value,
  133. //                     HI_ADC_EQU_MODEL_1, HI_ADC_CUR_BAIS_DEFAULT, 0);
  134. //         if (ret != HI_ERR_SUCCESS) {
  135. //             printf("ADC Read Fail
  136. ");
  137. //         }
  138. //         else
  139. //         {
  140. // //            printf("ADC value = %d", Key_adc_value);
  141. //         }
  142. //         /*User 按键ADC值读出来大概为116*/
  143. //         /*S1 按键ADC读出来大概为320*/
  144. //         /*S2 按键ADC读出来大概为548*/
  145. //         if(Key_adc_value <= 200)
  146. //         {
  147. //             printf("User key pressed
  148. ");
  149. //         }
  150. //         else if(Key_adc_value <= 400)
  151. //         {
  152. //             printf("User S1 pressed
  153. ");
  154. //         }   
  155. //         else if(Key_adc_value <= 600)
  156. //         {
  157. //             printf("User S2 pressed
  158. ");
  159. //         }
  160. //         else
  161. //         {

  163. //         }

  165.         Last_key_Status = Key_Status;
  166.         usleep(KEY_INTERVAL_TIME_US);
  167.     }

  169.     return NULL;
  170. }

  172. static void KeyEntry(void)
  173. {
  174.     osThreadAttr_t attr;

  176.     GpioInit();
  177.     IoSetFunc(WIFI_IOT_IO_NAME_GPIO_5, WIFI_IOT_IO_FUNC_GPIO_5_GPIO);
  178.     GpioSetDir(WIFI_IOT_IO_NAME_GPIO_5, WIFI_IOT_GPIO_DIR_IN);
  179. //    AdcRead();

  181.     attr.name = "KeyTask";
  182.     attr.attr_bits = 0U;
  183.     attr.cb_mem = NULL;
  184.     attr.cb_size = 0U;
  185.     attr.stack_mem = NULL;
  186.     attr.stack_size = KEY_TASK_STACK_SIZE;
  187.     attr.priority = KEY_TASK_PRIO;

  189.     if (osThreadNew((osThreadFunc_t)KeyTask, NULL, &attr) == NULL) {
  190.         printf("[KeyTask] Falied to create KeyTask!
  191. ");
  192.     }
  193. }
  194. SYS_RUN(KeyEntry);


  197. static void *RGBTask(const char *arg)
  198. {
  199.     (void)arg;

  201.     WifiIotGpioValue pho_in = 0u;
  202.     WifiIotGpioValue rel_in = 0u;
  203.     uint32_t ret = 0u;

  205.     while (1) {
  206.         /*光敏电阻*/
  207.         ret = GpioGetInputVal(WIFI_IOT_IO_NAME_GPIO_9, &pho_in);
  208.         if (ret != HI_ERR_SUCCESS) {
  209.             printf("Photoresistor Read Fail
  210. ");
  211.         }
  212.         else
  213.         {
  214.             printf("Photoresistor value = %d
  215. ", pho_in);
  216.         }
  217.         /*人体红外*/
  218.         ret = GpioGetInputVal(WIFI_IOT_IO_NAME_GPIO_7, &rel_in);
  219.         if (ret != HI_ERR_SUCCESS) {
  220.             printf("Photoresistor Read Fail
  221. ");         
  222.         }
  223.         else
  224.         {
  225.             printf("Human body infrared value = %d
  226. ", rel_in);
  227.         }

  229.         if(WIFI_IOT_GPIO_VALUE1 == pho_in)
  230.         {
  231.             GpioSetOutputVal(WIFI_IOT_IO_NAME_GPIO_12, 1);
  232.             GpioSetOutputVal(WIFI_IOT_IO_NAME_GPIO_11, 0);
  233.             GpioSetOutputVal(WIFI_IOT_IO_NAME_GPIO_10, 0);
  234.         }
  235.         else if(WIFI_IOT_GPIO_VALUE1 == rel_in)
  236.         {
  237.             GpioSetOutputVal(WIFI_IOT_IO_NAME_GPIO_12, 1);
  238.             GpioSetOutputVal(WIFI_IOT_IO_NAME_GPIO_11, 1);
  239.             GpioSetOutputVal(WIFI_IOT_IO_NAME_GPIO_10, 1);
  240.         }
  241.         else
  242.         {
  243.             GpioSetOutputVal(WIFI_IOT_IO_NAME_GPIO_12, 0);
  244.             GpioSetOutputVal(WIFI_IOT_IO_NAME_GPIO_11, 0);
  245.             GpioSetOutputVal(WIFI_IOT_IO_NAME_GPIO_10, 0);            
  246.         }
  247.     }

  249.     return NULL;
  250. }

  252. static void RGBEntry(void)
  253. {
  254.     osThreadAttr_t attr;

  256.     GpioInit();
  257.     IoSetFunc(WIFI_IOT_IO_NAME_GPIO_12, WIFI_IOT_IO_FUNC_GPIO_12_GPIO);
  258.     GpioSetDir(WIFI_IOT_IO_NAME_GPIO_12, WIFI_IOT_GPIO_DIR_OUT);

  260.     IoSetFunc(WIFI_IOT_IO_NAME_GPIO_11, WIFI_IOT_IO_FUNC_GPIO_11_GPIO);
  261.     GpioSetDir(WIFI_IOT_IO_NAME_GPIO_11, WIFI_IOT_GPIO_DIR_OUT);

  263.     IoSetFunc(WIFI_IOT_IO_NAME_GPIO_10, WIFI_IOT_IO_FUNC_GPIO_10_GPIO);
  264.     GpioSetDir(WIFI_IOT_IO_NAME_GPIO_10, WIFI_IOT_GPIO_DIR_OUT);

  266.     IoSetFunc(WIFI_IOT_IO_NAME_GPIO_10, WIFI_IOT_IO_FUNC_GPIO_10_GPIO);
  267.     GpioSetDir(WIFI_IOT_IO_NAME_GPIO_10, WIFI_IOT_GPIO_DIR_OUT);

  269.     IoSetFunc(WIFI_IOT_IO_NAME_GPIO_9, WIFI_IOT_IO_FUNC_GPIO_9_GPIO);
  270.     GpioSetDir(WIFI_IOT_IO_NAME_GPIO_9, WIFI_IOT_GPIO_DIR_IN);

  272.     IoSetFunc(WIFI_IOT_IO_NAME_GPIO_7, WIFI_IOT_IO_FUNC_GPIO_7_GPIO);
  273.     GpioSetDir(WIFI_IOT_IO_NAME_GPIO_7, WIFI_IOT_GPIO_DIR_IN);


  276.     attr.name = "RGBTask";
  277.     attr.attr_bits = 0U;
  278.     attr.cb_mem = NULL;
  279.     attr.cb_size = 0U;
  280.     attr.stack_mem = NULL;
  281.     attr.stack_size = RGB_TASK_STACK_SIZE;
  282.     attr.priority = RGB_TASK_PRIO;

  284.     if (osThreadNew((osThreadFunc_t)RGBTask, NULL, &attr) == NULL) {
  285.         printf("[KeyTask] Falied to create KeyTask!
  286. ");
  287.     }
  288. }
  289. SYS_RUN(RGBEntry);
复制代码


人体红外没有检测到人体：
3.png


人体红外检测到人体，同时光线充足
4.png


光敏电阻没有检测到足够的光线

`
6.png
举报

回帖

声明：本文内容及配图由入驻作者撰写或者入驻合作网站授权转载。文章观点仅代表作者本人，不代表电子发烧友网立场。文章及其配图仅供工程师学习之用，如有内容图片侵权或者其他问题，请联系本站作侵删。 侵权投诉
链接复制成功，分享给好友