21ic电子技术开发论坛 › 单片机与嵌入式系统 › 嵌入式操作系统论坛 › 【RTOS】RT-Thread创新大赛——基于麻雀一号的智能门铃 ...
返回列表 发新帖我要提问

[uCOS/RTOS] 【RTOS】RT-Thread创新大赛——基于麻雀一号的智能门铃（二）

[复制链接]
2800|3
 楼主| WoodData 发表于 2020-6-13 21:47 | 显示全部楼层 |阅读模式
RT-Thread, 大赛, RTOS, 智能门铃, Button
    本次分享项目智能门铃的软件框架流程。通过按键和简单的菜单选择不同功能，菜单主要是四部分：
1、门外视频监控。可以在LCD屏上查看门外视屏图像。如果wifi连接成功，还可以同时登录他局域网IP地址查看。可以直接扫描LCD屏上二维码进入局域网监控，或者主动输入IP地址和端口号连接。

PS：这部分由于内存分配不足，LCD无法解码JPG文件数据并显示，后面再优化看看，如果实在不行只能阉割部分功能了。在这顺便说下在TjpgDec软件包的例程中没有对内存分配结果检查，导致开始调试显示图片的时候经常会死机，只能通过无线烧写器烧录初始固件。后面我才发现这个问题，修改了一下才没有再次死机。再就是增加了可以指定显示图片的初始XY坐标位置。
   
2、查看今日天气。通过webclient和CJSON获取和解析网络天气服务。使用的是心知天气服务，注册心知天气获取一个验证KEY。它的回复数据是JSON数据格式，很方便。


3、开关门记录和访客记录。待完成

4、WIFI声波配网。微信扫描小程序进入声波配网。接收到WIFI路由信息后自动联网并保存参数到SD卡文件中，上电初始化过程会检查是否有wifi配置文件，如果有就自动联网，没有的话直接进入配网界面。如果不想现在配网可以通过按键返回菜单，取消配网。


在声波配网程序那添加保存配网信息。



软件流程：
    先在Main线程创建用户菜单显示操作线程User Thread。
User Thread内容：
1、初始化显示——》创建按键和GPIO扫描线程并创建按键邮箱——》创建WIFI连接事件和临时线程等待WIFI连接成功后需要处理的线程——》检查wifi配置——》有wifi配置时自动连接wifi，连接wifi成功后发送WIFI连接成功事件使临时线程继续，并进入主菜单界面。无WIFI配置时进入wifi配网菜单。——》循环等待按键邮箱，获取按键信息并进行相应处理。

进入视屏监控菜单——》创建局域网监控图片和LCD显示图片的线程，还可以通过长按按键保存照片到指定文件夹，按日期时间组合文件名保存。
进入今日天气——》创建定时器每隔10分钟获取一次天气数据。
进入WIFI声波配网——》显示声波配网小程序码，通过微信扫一扫，进入小程序配网。配网部分使用例程代码，在代码中配网成功后保存WIFI配置，自动联网，并在LCD屏上显示配网信息。

2、临时线程首先等待WIFI连接成功——》执行NTP网络服务进行RTC时间同步——》执行创建MQTT网络云连接服务上传信息——》线程结束退出。

3、按键和GPIO扫描线程。使用的是Multi_button软件包，初始化创建了一个邮箱，专门发送按键信息。线程内循环扫描操作按键IO、开关门IO、门铃按键，并发送邮箱数据。

4、NTP服务时间同步使用例程线程。

5、MQTT使用ONENET_MQTT软件包内例程线程。

部分代码：
主用户菜单线程
复制
  1. ////////////////////////////////////////////////////////////
    

  2. rt_event_t      wificonn_event = RT_NULL;
    

  3. #define     WIFI_CONN_OK        (1<<0)
    


  4. 

  5. //temp Thread
    

  6. static void UserTempApp(void *arg)
    

  7. {
    

  8.     char mqtt_cmd[]={"onenet_mqtt_init"};
    

  9.     char ntp_cmd[]={"ntp_sync"};
    

  10.     //等待WIFI连接
    

  11.     rt_event_recv(wificonn_event, WIFI_CONN_OK, RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR, RT_WAITING_FOREVER, RT_NULL);
    

  12.     
    

  13.     //创建时间同步，天气获取，网络云mqtt连接
    

  14.     msh_exec(mqtt_cmd, strlen(mqtt_cmd));       //exec mqtt
    

  15.     msh_exec(ntp_cmd, strlen(ntp_cmd));         //exec ntp
    

  16.     rt_kprintf("ntp and mqtt running......................\n");
    

  17. }
    


  18. 


  19. 

  20. #define     MENU_ITEM_NUM       5
    

  21. extern uint8_t     g_CurMenuIndex;
    

  22. extern uint8_t     g_CurMenuItem;
    


  23. 


  24. 

  25. extern uint8_t  MainFunInit(void);
    

  26. extern uint8_t  MainFunLoop(void);
    

  27. extern uint8_t  DoorVedioFunInit(void);
    

  28. extern uint8_t  DoorVedioFunLoop(void);
    

  29. extern uint8_t  WeatherFunInit(void);
    

  30. extern uint8_t  WeatherFunLoop(void);
    

  31. extern uint8_t  DoorReportFunInit(void);
    

  32. extern uint8_t  DoorReportFunLoop(void);
    

  33. extern uint8_t  WifiCfgFunInit(void);
    

  34. extern uint8_t  WifiCfgFunLoop(void);
    


  35. 

  36. typedef struct MenuFunCB
    

  37. {
    

  38.     uint8_t  (*MenuItemInit)(void);
    

  39.     uint8_t  (*MenuItemFun)(void);
    

  40. }MenuFunCB;
    


  41. 

  42. MenuFunCB MenuFun[MENU_ITEM_NUM]=
    

  43. {
    

  44.     {MainFunInit,MainFunLoop},
    

  45.     {DoorVedioFunInit,DoorVedioFunLoop},
    

  46.     {WeatherFunInit,WeatherFunLoop},
    

  47.     {DoorReportFunInit,DoorReportFunLoop},
    

  48.     {WifiCfgFunInit,WifiCfgFunLoop},
    


  49. 

  50. };
    


  51. 

  52. static uint8_t  _menu_state;
    

  53. //User Main Thread
    

  54. static void UserApp(void *arg)
    

  55. {
    


  56. 

  57.     lcd_clear(BLUE);
    

  58.     lcd_set_font(&Font_CH24X24);
    

  59.     lcd_set_font_color(RED,BLUE);
    

  60.     lcd_disp_str_at(66,4,"RT-Thread");
    

  61.     lcd_disp_str_at(24,28,"应用创新设计大赛");
    

  62.     lcd_disp_str_at(108,52,"By WoodData");
    

  63.     lcd_set_font(&Font_CH48X48);
    

  64.     lcd_set_font_color(RED,WHITE);
    

  65.     lcd_disp_str_at(24,80,"智能门铃");
    


  66. 

  67.     lcd_set_font(&Font_CH24X24);
    

  68.     lcd_set_font_color(RED,WHITE);
    

  69.     lcd_disp_str_at(12,200,"21IC");
    

  70.     lcd_set_font_color(BLUE,WHITE);
    

  71.     lcd_disp_str_at(60,200,"电子网技术论坛");
    

  72.     lcd_set_font(&Font_ASCII16X8);
    

  73.     lcd_set_font_color(RED,WHITE);
    

  74.     lcd_disp_str_at(40,224,"https://bbs.21ic.com");
    


  75. 

  76.     lcd_show_qrcode(87,130,4,2,"https://bbs.21ic.com",2);
    


  77. 

  78. //////////////////
    

  79.     key_init(); //创建按键扫描线程,及按键信息邮箱
    


  80. 

  81. //////////////////
    

  82.     wificonn_event = rt_event_create("wifi_conn_event", RT_IPC_FLAG_FIFO);
    

  83. extern void user_callback_register(void);
    

  84.     user_callback_register();
    


  85. 

  86. ///////////////////
    

  87.     rt_thread_t tid = RT_NULL;
    

  88.      /* Create background ticks thread */
    

  89.     tid = rt_thread_create("UserTemp", UserTempApp, RT_NULL, 1024, 11, 10);
    

  90.     if(tid != RT_NULL)
    

  91.     {
    

  92.         rt_thread_startup(tid);
    

  93.     }
    


  94. 

  95. //////////////////
    

  96.     char wifistr[] = {"wifi"};
    

  97.     int fd = 0;
    

  98.     //检测WIFI连接是否配置
    

  99.     fd = open(WIFI_SETTING_FN,O_RDONLY);  //WIFI_SETTING_FN = "/sd/wificonnectcfg.json"
    

  100.     if(fd >= 0)
    

  101.     {
    

  102.         close(fd);
    

  103.         msh_exec(wifistr, strlen(wifistr));     //exec wifi link     
    

  104.         rt_kprintf("wifi auto connect.\n");
    

  105.         g_CurMenuItem = 0; 
    

  106.         g_CurMenuIndex = 0;
    

  107.     }else
    

  108.     {
    

  109.         rt_kprintf("Open wificonnectcfg.json failed!!!\n");
    

  110.         g_CurMenuItem = 4;
    

  111.         g_CurMenuIndex = 0;
    

  112.     }
    

  113.     
    

  114.     _menu_state = 0;
    

  115.     rt_kprintf("Key Scan Thread..............................\n");
    

  116.     rt_thread_mdelay(3000);
    


  117. 

  118.     while(1)
    

  119.     {
    

  120.         if(g_CurMenuItem < MENU_ITEM_NUM)
    

  121.         {
    

  122.             if(_menu_state == 0)
    

  123.             {
    

  124.                 if(MenuFun[g_CurMenuItem].MenuItemInit() == 0)
    

  125.                 {
    

  126.                     _menu_state = 1;
    

  127.                 }
    

  128.             }else
    

  129.             {
    

  130.                 if(MenuFun[g_CurMenuItem].MenuItemFun() == 0)
    

  131.                 {
    

  132.                     _menu_state = 0;
    

  133.                 }
    

  134.             }
    

  135.             
    

  136.         }        
    

  137.     }
    

  138. }
菜单绘制代码
复制

  1. 


  2. 

  3. #include "time.h"
    

  4. #include "rtthread.h"
    

  5. #include <dfs.h>
    

  6. #include <dfs_fs.h>
    


  7. 

  8. #if     1
    


  9. 

  10. #include "tjpgd.h"
    

  11. #include "voice_config.h"
    

  12. #include "lcd_font.h"
    

  13. #include "key.h"
    


  14. 


  15. 


  16. 

  17. uint8_t     g_CurMenuIndex;
    

  18. uint8_t     g_CurMenuItem;
    


  19. 

  20. void WifiCfgDraw(uint16_t index);
    

  21. void MainPageDraw(uint16_t key);
    


  22. 

  23. extern void UserGetCurTime(struct tm *tm_new);
    


  24. 

  25. //////////////////////////////////////////////////////////////////////
    

  26. void MainPageDraw(uint16_t key)
    

  27. {
    

  28.     if(key&0x8000)
    

  29.     {
    

  30.         lcd_fill(0,0,240,48,BLUE);
    

  31.         lcd_fill(0,48,240,240,GBLUE);
    


  32. 

  33.         lcd_set_font(&Font_CH48X48);
    

  34.         lcd_set_font_color(RED,BLUE);
    

  35.         lcd_disp_str_at(24,0,"智能门铃");  
    


  36. 

  37.         lcd_set_color(WHITE,BLACK);
    

  38.         lcd_draw_line(0,47,240,47);
    

  39.     }
    


  40. 

  41.     lcd_set_font(&Font_CH32X32);
    

  42.     if(key&0x0001) 
    

  43.     {
    

  44.         lcd_fill(0,48,240,80,BLUE);
    

  45.         lcd_set_font_color(BRED,BLUE);
    

  46.         lcd_disp_str_at(0,48,"视频监控"); 
    

  47.        
    

  48.     }else
    

  49.     {
    

  50.         lcd_fill(0,48,240,80,GBLUE);
    

  51.         lcd_set_font_color(BRED,GBLUE);
    

  52.         lcd_disp_str_at(0,48,"视频监控");  
    

  53.     }
    


  54. 

  55.     if(key&0x0002)
    

  56.     {
    

  57.         lcd_fill(0,80,240,112,BLUE);
    

  58.         lcd_set_font_color(BRED,BLUE);
    

  59.         lcd_disp_str_at(0,80,"今日天气");         
    

  60.     }else
    

  61.     {
    

  62.         lcd_fill(0,80,240,112,GBLUE);
    

  63.         lcd_set_font_color(BRED,GBLUE);
    

  64.         lcd_disp_str_at(0,80,"今日天气");  
    

  65.     }
    


  66. 

  67.     if(key&0x0004)
    

  68.     {
    

  69.         lcd_fill(0,112,240,144,BLUE);
    

  70.         lcd_set_font_color(BRED,BLUE);
    

  71.         lcd_disp_str_at(0,112,"开关门记录");         
    

  72.     }else
    

  73.     {
    

  74.         lcd_fill(0,112,240,144,GBLUE);
    

  75.         lcd_set_font_color(BRED,GBLUE);
    

  76.         lcd_disp_str_at(0,112,"开关门记录");  
    

  77.     }  
    

  78.  
    

  79.     if(key&0x0008)
    

  80.     {
    

  81.         lcd_fill(0,144,240,176,BLUE);
    

  82.         lcd_set_font_color(BRED,BLUE);
    

  83.         lcd_disp_str_at(0,144,"WIFI声波配网");         
    

  84.     }else
    

  85.     {
    

  86.         lcd_fill(0,144,240,176,GBLUE);
    

  87.         lcd_set_font_color(BRED,GBLUE);
    

  88.         lcd_disp_str_at(0,144,"WIFI声波配网");  
    

  89.     }
    

  90. }
    


  91. 

  92. uint8_t  MainFunInit(void )
    

  93. {
    

  94.     MainPageDraw(0x8001);
    


  95. 

  96.     return 0;
    

  97. }
    


  98. 

  99. uint8_t  MainFunLoop(void )
    

  100. {
    

  101.     uint32_t  keyvalue;
    


  102. 

  103.         if(rt_mb_recv(key_mailbox,&keyvalue,RT_WAITING_FOREVER) == RT_EOK)
    

  104.         {
    

  105.             rt_kprintf("Key mailbox recv %0X.\n",keyvalue);
    

  106.             switch((keyvalue &0xffff0000)>>16)
    

  107.             {
    

  108.                 case    0x0:    //key_m
    

  109.                 switch (keyvalue&0xffff)
    

  110.                 {
    

  111.                 case SINGLE_CLICK: 
    

  112.                     switch(g_CurMenuIndex)
    

  113.                     {
    

  114.                         case    0:
    

  115.                         g_CurMenuIndex = 0;
    

  116.                         g_CurMenuItem  = 1; 
    

  117.                         break;
    

  118.                         case    1:
    

  119.                         g_CurMenuIndex = 0;
    

  120.                         g_CurMenuItem  = 2;
    

  121.                         break;
    

  122.                         case    2:
    

  123.                         g_CurMenuIndex = 0;
    

  124.                         g_CurMenuItem  = 3;
    

  125.                         break;
    

  126.                         case    3:
    

  127.                         g_CurMenuIndex = 0;
    

  128.                         g_CurMenuItem  = 4; 
    

  129.                         break;
    


  130. 

  131.                     }                
    

  132.                     return 0;                
    

  133.                 default:
    

  134.                     break;
    

  135.                 }
    

  136.                 break;
    

  137.                 
    

  138.                 case    0x1:    //key_up
    

  139.                 switch (keyvalue&0xffff)
    

  140.                 {
    

  141.                 case SINGLE_CLICK: 
    

  142.                     if(g_CurMenuIndex )   g_CurMenuIndex --;    
    

  143.                     else    g_CurMenuIndex = 3;                                    
    

  144.                     MainPageDraw(0x0001<<g_CurMenuIndex); 
    

  145.                     rt_kprintf("index %u.\n",g_CurMenuIndex);                              
    

  146.                     break;                
    

  147.                 default:
    

  148.                     break;
    

  149.                 }
    

  150.                 break;
    


  151. 

  152.                 case    0x2:    //key_down
    

  153.                 switch (keyvalue&0xffff)
    

  154.                 {
    

  155.                 case SINGLE_CLICK: 
    

  156.                     g_CurMenuIndex++;  
    

  157.                     if(g_CurMenuIndex == 4)   g_CurMenuIndex = 0;                    
    

  158.                     MainPageDraw(0x0001<<g_CurMenuIndex); 
    

  159.                     rt_kprintf("index %u.\n",g_CurMenuIndex);                           
    

  160.                     break;                
    

  161.                 default:
    

  162.                     break;
    

  163.                 }
    


  164. 

  165.                 break;
    


  166. 


  167. 


  168. 

  169.                 case    0x5:    //门铃键
    

  170.                 switch (keyvalue&0xffff)
    

  171.                 {
    

  172.                 case SINGLE_CLICK:                              
    

  173.                     break;                
    

  174.                 default:
    

  175.                     break;
    

  176.                 }
    

  177.                 break;
    

  178.                 case    0x6:    //开关门
    


  179. 

  180.                 break;
    

  181.             }
    

  182.         }
    


  183. 

  184.     return 1;
    

  185. }
    


  186. 

  187. /////////////////////////////////////////////////////
    

  188. extern void show_photo_test(void);
    

  189. extern void stop_photo(void);
    

  190. extern void save_photo(void);
    

  191. uint8_t  DoorVedioFunInit(void)
    

  192. {
    

  193.     lcd_fill(0,0,240,48,BLUE);
    

  194.     lcd_fill(0,48,240,240,GBLUE);
    


  195. 

  196.     lcd_set_font(&Font_CH48X48);
    

  197.     lcd_set_font_color(RED,BLUE);
    

  198.     lcd_disp_str_at(0,0,"视频监控"); 
    


  199. 

  200.     lcd_set_color(WHITE,BLACK);
    

  201.     lcd_draw_line(0,47,240,47);
    


  202. 

  203.     show_photo_test();  
    

  204.     return 0;
    

  205. }
    


  206. 

  207. uint8_t  DoorVedioFunLoop(void)
    

  208. {
    

  209.     uint32_t  keyvalue;
    


  210. 

  211.         if(rt_mb_recv(key_mailbox,&keyvalue,RT_WAITING_FOREVER) == RT_EOK)
    

  212.         {
    

  213.             rt_kprintf("Key mailbox recv %0X.\n",keyvalue);
    

  214.             switch((keyvalue &0xffff0000)>>16)
    

  215.             {
    

  216.                 case    0x0:    //key_m
    

  217.                 switch (keyvalue&0xffff)
    

  218.                 {
    

  219.                 case SINGLE_CLICK: 
    

  220.                     g_CurMenuIndex = 0;
    

  221.                     g_CurMenuItem  = 0; 
    

  222.                     stop_photo();                  
    

  223.                     return 0; 
    

  224.                 case LONG_RRESS_START:
    

  225.                     save_photo(); //Save jpg file
    

  226.                     break;              
    

  227.                 default:
    

  228.                     break;
    

  229.                 }
    

  230.                 break;
    

  231.                 case    0x1:    //key_up
    

  232.                 switch (keyvalue&0xffff)
    

  233.                 {
    

  234.                 case SINGLE_CLICK:                         
    

  235.                     break;                
    

  236.                 default:
    

  237.                     break;
    

  238.                 }
    


  239. 

  240.                 break;
    

  241.                 case    0x2:    //key_down
    

  242.                 switch (keyvalue&0xffff)
    

  243.                 {
    

  244.                 case SINGLE_CLICK:                            
    

  245.                     break;                
    

  246.                 default:
    

  247.                     break;
    

  248.                 }
    


  249. 

  250.                 break;
    


  251. 


  252. 

  253.                 case    0x5:    //门铃键
    

  254.                 switch (keyvalue&0xffff)
    

  255.                 {
    

  256.                 case SINGLE_CLICK:                              
    

  257.                     break;                
    

  258.                 default:
    

  259.                     break;
    

  260.                 }
    

  261.                 break;
    

  262.                 case    0x6:    //开关门
    


  263. 

  264.                 break;
    

  265.             }
    

  266.         }
    

  267.     return 1;
    

  268. }
    


  269. 

  270. /////////////////////////////////////////////////////
    

  271. static void weather_timer_10min(void * para)
    

  272. {
    

  273.     char argv[] = {"weather guangzhou"};   
    

  274.     msh_exec(argv, strlen(argv));     //exec wifi link 
    

  275. }
    


  276. 

  277. static rt_timer_t   weather_timer;
    


  278. 

  279. uint8_t  WeatherFunInit(void)
    

  280. {
    

  281.     char argv[] = {"weather guangzhou"};
    


  282. 

  283.     lcd_fill(0,0,240,48,BLUE);
    

  284.     lcd_fill(0,48,240,240,GBLUE);
    


  285. 

  286.     lcd_set_font(&Font_CH48X48);
    

  287.     lcd_set_font_color(RED,BLUE);
    

  288.     lcd_disp_str_at(0,0,"今日天气"); 
    


  289. 

  290.     lcd_set_color(WHITE,BLACK);
    

  291.     lcd_draw_line(0,47,240,47);
    


  292. 

  293.     weather_timer  = rt_timer_create("weather timer",weather_timer_10min,RT_NULL, 10*60*RT_TICK_PER_SECOND,
    

  294.                                     RT_TIMER_FLAG_PERIODIC | RT_TIMER_FLAG_SOFT_TIMER );
    

  295.     if(weather_timer != RT_NULL)
    

  296.     {
    

  297.         rt_timer_start(weather_timer);
    

  298.     }else
    

  299.     {
    

  300.         rt_kprintf("weather timer fail!!!\n");
    

  301.     }
    

  302.     
    

  303.     msh_exec(argv, strlen(argv));     //exec wifi link 
    


  304. 

  305.     return 0;
    

  306. }
    


  307. 

  308. uint8_t  WeatherFunLoop(void)
    

  309. {
    

  310.     uint32_t  keyvalue;
    


  311. 

  312.         if(rt_mb_recv(key_mailbox,&keyvalue,RT_WAITING_FOREVER) == RT_EOK)
    

  313.         {
    

  314.             rt_kprintf("Key mailbox recv %0X.\n",keyvalue);
    

  315.             switch((keyvalue &0xffff0000)>>16)
    

  316.             {
    

  317.                 case    0x0:    //key_m
    

  318.                 switch (keyvalue&0xffff)
    

  319.                 {
    

  320.                 case SINGLE_CLICK: 
    

  321.                     g_CurMenuIndex = 0;
    

  322.                     g_CurMenuItem  = 0;   
    

  323.                     if(weather_timer != RT_NULL)
    

  324.                     {
    

  325.                         rt_timer_delete(weather_timer);
    

  326.                     }                       
    

  327.                     return 0;                
    

  328.                 default:
    

  329.                     break;
    

  330.                 }
    

  331.                 break;
    

  332.                 case    0x1:    //key_up
    

  333.                 switch (keyvalue&0xffff)
    

  334.                 {
    

  335.                 case SINGLE_CLICK:                         
    

  336.                     break;                
    

  337.                 default:
    

  338.                     break;
    

  339.                 }
    


  340. 

  341.                 break;
    

  342.                 case    0x2:    //key_down
    

  343.                 switch (keyvalue&0xffff)
    

  344.                 {
    

  345.                 case SINGLE_CLICK:                            
    

  346.                     break;                
    

  347.                 default:
    

  348.                     break;
    

  349.                 }
    


  350. 

  351.                 break;
    


  352. 


  353. 

  354.                 case    0x5:    //门铃键
    

  355.                 switch (keyvalue&0xffff)
    

  356.                 {
    

  357.                 case SINGLE_CLICK:                              
    

  358.                     break;                
    

  359.                 default:
    

  360.                     break;
    

  361.                 }
    

  362.                 break;
    

  363.                 case    0x6:    //开关门
    


  364. 

  365.                 break;
    

  366.             }
    

  367.         }
    

  368.     return 1;
    

  369. }
    


  370. 

  371. /////////////////////////////////////////////////////
    

  372. uint8_t  DoorReportFunInit(void)
    

  373. {
    

  374.     lcd_fill(0,0,240,48,BLUE);
    

  375.     lcd_fill(0,48,240,240,GBLUE);
    


  376. 

  377.     lcd_set_font(&Font_CH48X48);
    

  378.     lcd_set_font_color(RED,BLUE);
    

  379.     lcd_disp_str_at(0,0,"开关门记录"); 
    


  380. 

  381.     lcd_set_color(WHITE,BLACK);
    

  382.     lcd_draw_line(0,47,240,47);
    

  383.     return 0;
    

  384. }
    

  385. uint8_t  DoorReportFunLoop(void)
    

  386. {
    

  387.     uint32_t  keyvalue;
    


  388. 

  389.         if(rt_mb_recv(key_mailbox,&keyvalue,RT_WAITING_FOREVER) == RT_EOK)
    

  390.         {
    

  391.             rt_kprintf("Key mailbox recv %0X.\n",keyvalue);
    

  392.             switch((keyvalue &0xffff0000)>>16)
    

  393.             {
    

  394.                 case    0x0:    //key_m
    

  395.                 switch (keyvalue&0xffff)
    

  396.                 {
    

  397.                 case SINGLE_CLICK: 
    

  398.                     g_CurMenuIndex = 0;
    

  399.                     g_CurMenuItem  = 0;  
    

  400.                        
    

  401.                     return 0;                
    

  402.                 default:
    

  403.                     break;
    

  404.                 }
    

  405.                 break;
    

  406.                 case    0x1:    //key_up
    

  407.                 switch (keyvalue&0xffff)
    

  408.                 {
    

  409.                 case SINGLE_CLICK:                         
    

  410.                     break;                
    

  411.                 default:
    

  412.                     break;
    

  413.                 }
    


  414. 

  415.                 break;
    

  416.                 case    0x2:    //key_down
    

  417.                 switch (keyvalue&0xffff)
    

  418.                 {
    

  419.                 case SINGLE_CLICK:                            
    

  420.                     break;                
    

  421.                 default:
    

  422.                     break;
    

  423.                 }
    


  424. 

  425.                 break;
    


  426. 


  427. 

  428.                 case    0x5:    //门铃键
    

  429.                 switch (keyvalue&0xffff)
    

  430.                 {
    

  431.                 case SINGLE_CLICK:                              
    

  432.                     break;                
    

  433.                 default:
    

  434.                     break;
    

  435.                 }
    

  436.                 break;
    

  437.                 case    0x6:    //开关门
    


  438. 

  439.                 break;
    

  440.             }
    

  441.         }
    

  442.     return 1;
    

  443. }
    


  444. 

  445. ///////////////////////////////////////////////////////
    

  446. void WifiCfgDraw(uint16_t index)
    

  447. {
    

  448.     if(index&0x8000)
    

  449.     {
    

  450.         lcd_fill(0,0,240,48,BLUE);
    

  451.         lcd_fill(0,48,240,240,GBLUE);
    


  452. 

  453.         lcd_set_font(&Font_CH40X40);
    

  454.         lcd_set_font_color(RED,BLUE);
    

  455.         lcd_disp_str_at(0,0,"WIFI声波配网"); 
    


  456. 

  457.         lcd_set_color(WHITE,BLACK);
    

  458.         lcd_draw_line(0,47,240,47); 
    

  459.     }
    


  460. 

  461.     if(index&0x0001) 
    

  462.     {        
    

  463.         lcd_set_font(&Font_CH16X16);
    

  464.         lcd_set_font_color(BRED,GBLUE);
    

  465.         lcd_disp_str_at(((240-16*7)>>1), 50 ,"打开微信扫一扫"); 
    

  466.         Decode_Jpg("/sd/voice_wifi.jpg",48,80);
    

  467.     }   
    


  468. 

  469. }
    


  470. 

  471. uint8_t  WifiCfgFunInit(void)
    

  472. {
    

  473.     WifiCfgDraw(0x8001);
    

  474.     voice_config(0,NULL);
    

  475.     return 0;
    

  476. }
    


  477. 

  478. uint8_t  WifiCfgFunLoop(void)
    

  479. {
    

  480.     uint32_t  keyvalue;
    


  481. 

  482.         if(rt_mb_recv(key_mailbox,&keyvalue,RT_WAITING_FOREVER) == RT_EOK)
    

  483.         {
    

  484.             rt_kprintf("Key mailbox recv %0X.\n",keyvalue);
    

  485.             switch((keyvalue &0xffff0000)>>16)
    

  486.             {
    

  487.                 case    0x0:    //key_m
    

  488.                 switch (keyvalue&0xffff)
    

  489.                 {
    

  490.                 case SINGLE_CLICK: 
    


  491. 

  492.                     g_CurMenuIndex = 0;
    

  493.                     g_CurMenuItem  = 0;  
    

  494.                     voice_config_stop(); 
    

  495.                     rt_thread_mdelay(1000);                        
    

  496.                     return 0;                
    

  497.                 default:
    

  498.                     break;
    

  499.                 }
    

  500.                 break;
    

  501.                 case    0x1:    //key_up
    

  502.                 switch (keyvalue&0xffff)
    

  503.                 {
    

  504.                 case SINGLE_CLICK:                         
    

  505.                     break;                
    

  506.                 default:
    

  507.                     break;
    

  508.                 }
    


  509. 

  510.                 break;
    

  511.                 case    0x2:    //key_down
    

  512.                 switch (keyvalue&0xffff)
    

  513.                 {
    

  514.                 case SINGLE_CLICK:                            
    

  515.                     break;                
    

  516.                 default:
    

  517.                     break;
    

  518.                 }
    


  519. 

  520.                 break;
    


  521. 


  522. 

  523.                 case    0x5:    //门铃键
    

  524.                 switch (keyvalue&0xffff)
    

  525.                 {
    

  526.                 case SINGLE_CLICK:                              
    

  527.                     break;                
    

  528.                 default:
    

  529.                     break;
    

  530.                 }
    

  531.                 break;
    

  532.                 case    0x6:    //开关门
    


  533. 

  534.                 break;
    

  535.             }
    

  536.         }
    

  537.         
    

  538.     return 1;
    

  539. }
    


  540. 

  541. ////////////////////////////////////////////////
    


  542. 


  543. 


  544. 


  545. 


  546. 


  547. 

  548. #endif



按键扫描
复制

  1. 

  2. #include <rtthread.h>
    

  3. #include <stdint.h>
    

  4. #include <rtdevice.h>
    


  5. 


  6. 

  7. #if     1
    


  8. 

  9. #include "key.h"
    


  10. 


  11. 

  12. #define KEY_MID         (13)
    

  13. #define KEY_UP          (28)
    

  14. #define KEY_DOWN        (19)
    

  15. #define KEY_LEFT        (12)
    

  16. #define KEY_RIGHT       (25)
    


  17. 

  18. rt_mailbox_t  key_mailbox = RT_NULL;
    


  19. 

  20. typedef enum
    

  21. {
    

  22.     KEY_M = 0,      //Middle
    

  23.     KEY_U,          //Up
    

  24.     KEY_D,          //Down
    

  25.     KEY_L,          //Left
    

  26.     KEY_R,          //Right
    

  27.     KEY_NUM         //key count
    

  28. } user_button_t;
    


  29. 

  30. static struct button user_button[KEY_NUM];
    


  31. 

  32. uint32_t    KeyValue;
    


  33. 

  34. static void btn_0_cb(void *btn)
    

  35. {
    

  36.     rt_kprintf("btn_0_cb\n");
    

  37.     KeyValue = get_button_event((struct button *)btn); 
    


  38. 

  39.     switch(KeyValue)
    

  40.     {
    

  41.     case PRESS_DOWN:
    

  42.         rt_kprintf("button press down\n"); 
    

  43.     break; 
    


  44. 

  45.     case PRESS_UP: 
    

  46.         rt_kprintf("button press up\n");
    

  47.     break; 
    


  48. 

  49.     case PRESS_REPEAT: 
    

  50.         rt_kprintf("button press repeat\n");
    

  51.     break; 
    


  52. 

  53.     case SINGLE_CLICK: 
    

  54.         rt_kprintf("button single click\n");
    

  55.     break; 
    


  56. 

  57.     case DOUBLE_CLICK: 
    

  58.         rt_kprintf("button double click\n");
    

  59.     break; 
    


  60. 

  61.     case LONG_RRESS_START: 
    

  62.         rt_kprintf("button long press start\n");
    

  63.     break; 
    


  64. 

  65.     case LONG_PRESS_HOLD: 
    

  66.         rt_kprintf("button long press hold\n");
    

  67.     break; 
    

  68.     }
    

  69.     rt_mb_send(key_mailbox,KeyValue);
    

  70. }
    


  71. 

  72. static void btn_1_cb(void *btn)
    

  73. {
    

  74.     rt_kprintf("btn_1_cb\n");
    

  75.     KeyValue = get_button_event((struct button *)btn); 
    

  76.     KeyValue |= 0x010000;
    

  77.     rt_mb_send(key_mailbox,KeyValue);
    

  78. }
    


  79. 

  80. static void btn_2_cb(void *btn)
    

  81. {
    

  82.     rt_kprintf("btn_2_cb\n");
    

  83.     KeyValue = get_button_event((struct button *)btn); 
    

  84.     KeyValue |= 0x020000;
    

  85.     rt_mb_send(key_mailbox,KeyValue);
    

  86. }
    


  87. 

  88. static void btn_3_cb(void *btn)
    

  89. {
    

  90.     rt_kprintf("btn_3_cb\n");
    

  91.     KeyValue = get_button_event((struct button *)btn); 
    

  92.     KeyValue |= 0x030000;
    

  93.     rt_mb_send(key_mailbox,KeyValue);
    

  94. }
    


  95. 

  96. static void btn_4_cb(void *btn)
    

  97. {
    

  98.     rt_kprintf("btn_4_cb\n");
    

  99.     KeyValue = get_button_event((struct button *)btn); 
    

  100.     KeyValue |= 0x040000;
    

  101.     rt_mb_send(key_mailbox,KeyValue);
    

  102. }
    


  103. 

  104. ////////////////////////////////////////////////////
    

  105. //Key Read Value
    

  106. static uint8_t key_mid_read(void)
    

  107. {
    

  108.     return rt_pin_read(KEY_MID);
    

  109. }
    


  110. 

  111. static uint8_t key_up_read(void)
    

  112. {
    

  113.     return rt_pin_read(KEY_UP);
    

  114. }
    


  115. 

  116. static uint8_t key_down_read(void)
    

  117. {
    

  118.     return rt_pin_read(KEY_DOWN);
    

  119. }
    


  120. 

  121. static uint8_t key_left_read(void)
    

  122. {
    

  123.     return rt_pin_read(KEY_LEFT);
    

  124. }
    


  125. 

  126. static uint8_t key_right_read(void)
    

  127. {
    

  128.     return rt_pin_read(KEY_RIGHT);
    

  129. }
    


  130. 

  131. //Key Scan Thread
    

  132. static void button_scan(void *arg)
    

  133. {
    

  134.     while(1)
    

  135.     {
    

  136.         /* 5ms */
    

  137.         rt_thread_delay(RT_TICK_PER_SECOND/200); 
    

  138.         button_ticks(); 
    

  139.     }
    

  140. }
    


  141. 


  142. 

  143. int key_init(void)
    

  144. {
    

  145.     int i; 
    

  146.     rt_thread_t tid = RT_NULL;
    


  147. 

  148.     rt_pin_mode(KEY_MID, PIN_MODE_INPUT_PULLUP); /* set KEY pin mode to input */
    

  149.     rt_pin_mode(KEY_UP, PIN_MODE_INPUT_PULLUP); /* set KEY pin mode to input */
    

  150.     rt_pin_mode(KEY_DOWN, PIN_MODE_INPUT_PULLUP); /* set KEY pin mode to input */
    

  151.     rt_pin_mode(KEY_LEFT, PIN_MODE_INPUT_PULLUP); /* set KEY pin mode to input */
    

  152.     rt_pin_mode(KEY_RIGHT, PIN_MODE_INPUT_PULLUP); /* set KEY pin mode to input */
    


  153. 


  154. 

  155.     //创建按键信息邮箱
    

  156.     key_mailbox = rt_mb_create("KeyMail",16*4,RT_IPC_FLAG_FIFO);
    


  157. 

  158.     /* Create background ticks thread */
    

  159.     tid = rt_thread_create("KeyScan", button_scan, RT_NULL, 512, 15, 10);
    

  160.     if(tid != RT_NULL)
    

  161.     {
    

  162.         rt_thread_startup(tid);
    

  163.     }
    


  164. 

  165.     /* low level drive */
    

  166.     button_init  (&user_button[KEY_M], key_mid_read, PIN_LOW);
    

  167.     button_attach(&user_button[KEY_M], PRESS_DOWN,       btn_0_cb);
    

  168.     button_attach(&user_button[KEY_M], PRESS_UP,         btn_0_cb);
    

  169.     button_attach(&user_button[KEY_M], PRESS_REPEAT,     btn_0_cb);
    

  170.     button_attach(&user_button[KEY_M], SINGLE_CLICK,     btn_0_cb);
    

  171.     button_attach(&user_button[KEY_M], DOUBLE_CLICK,     btn_0_cb);
    

  172.     button_attach(&user_button[KEY_M], LONG_RRESS_START, btn_0_cb);
    

  173.     button_attach(&user_button[KEY_M], LONG_PRESS_HOLD,  btn_0_cb);
    

  174.     button_start (&user_button[KEY_M]);
    


  175. 


  176. 

  177.     button_init  (&user_button[KEY_U], key_up_read, PIN_LOW);
    

  178.     button_attach(&user_button[KEY_U], PRESS_DOWN,       btn_1_cb);
    

  179.     button_attach(&user_button[KEY_U], PRESS_UP,         btn_1_cb);
    

  180.     button_attach(&user_button[KEY_U], PRESS_REPEAT,     btn_1_cb);
    

  181.     button_attach(&user_button[KEY_U], SINGLE_CLICK,     btn_1_cb);
    

  182.     button_attach(&user_button[KEY_U], DOUBLE_CLICK,     btn_1_cb);
    

  183.     button_attach(&user_button[KEY_U], LONG_RRESS_START, btn_1_cb);
    

  184.     button_attach(&user_button[KEY_U], LONG_PRESS_HOLD,  btn_1_cb);
    

  185.     button_start (&user_button[KEY_U]);
    


  186. 

  187.     button_init  (&user_button[KEY_D], key_down_read, PIN_LOW);
    

  188.     button_attach(&user_button[KEY_D], PRESS_DOWN,       btn_2_cb);
    

  189.     button_attach(&user_button[KEY_D], PRESS_UP,         btn_2_cb);
    

  190.     button_attach(&user_button[KEY_D], PRESS_REPEAT,     btn_2_cb);
    

  191.     button_attach(&user_button[KEY_D], SINGLE_CLICK,     btn_2_cb);
    

  192.     button_attach(&user_button[KEY_D], DOUBLE_CLICK,     btn_2_cb);
    

  193.     button_attach(&user_button[KEY_D], LONG_RRESS_START, btn_2_cb);
    

  194.     button_attach(&user_button[KEY_D], LONG_PRESS_HOLD,  btn_2_cb);
    

  195.     button_start (&user_button[KEY_D]);
    


  196. 

  197.     button_init  (&user_button[KEY_L], key_left_read, PIN_LOW);
    

  198.     button_attach(&user_button[KEY_L], PRESS_DOWN,       btn_3_cb);
    

  199.     button_attach(&user_button[KEY_L], PRESS_UP,         btn_3_cb);
    

  200.     button_attach(&user_button[KEY_L], PRESS_REPEAT,     btn_3_cb);
    

  201.     button_attach(&user_button[KEY_L], SINGLE_CLICK,     btn_3_cb);
    

  202.     button_attach(&user_button[KEY_L], DOUBLE_CLICK,     btn_3_cb);
    

  203.     button_attach(&user_button[KEY_L], LONG_RRESS_START, btn_3_cb);
    

  204.     button_attach(&user_button[KEY_L], LONG_PRESS_HOLD,  btn_3_cb);
    

  205.     button_start (&user_button[KEY_L]);
    


  206. 

  207.     button_init  (&user_button[KEY_R], key_right_read, PIN_LOW);
    

  208.     button_attach(&user_button[KEY_R], PRESS_DOWN,       btn_4_cb);
    

  209.     button_attach(&user_button[KEY_R], PRESS_UP,         btn_4_cb);
    

  210.     button_attach(&user_button[KEY_R], PRESS_REPEAT,     btn_4_cb);
    

  211.     button_attach(&user_button[KEY_R], SINGLE_CLICK,     btn_4_cb);
    

  212.     button_attach(&user_button[KEY_R], DOUBLE_CLICK,     btn_4_cb);
    

  213.     button_attach(&user_button[KEY_R], LONG_RRESS_START, btn_4_cb);
    

  214.     button_attach(&user_button[KEY_R], LONG_PRESS_HOLD,  btn_4_cb);
    

  215.     button_start (&user_button[KEY_R]);
    


  216. 

  217.     return 0;
    

  218. }
    


  219. 

  220. #endif

天气获取代码
复制
  1. /*
    

  2.  * File      : httpclient.c
    

  3.  *
    

  4.  * Copyright (c) 2006-2018, RT-Thread Development Team
    

  5.  *
    

  6.  * SPDX-License-Identifier: Apache-2.0
    

  7.  *
    

  8.  * Change Logs:
    

  9.  * Date             Author      Notes
    

  10.  * 2018-07-20     flybreak     first version
    

  11.  * 2018-09-05     flybreak     Upgrade API to webclient latest version
    

  12.  */
    


  13. 

  14. #include <rtthread.h>
    

  15. #include <rtdevice.h>
    

  16. #include <board.h>
    

  17. #include <dfs.h>
    

  18. #include <dfs_fs.h>
    


  19. 

  20. #include <webclient.h>  /* 浣跨敤 HTTP 鍗忚涓庢湇鍔″櫒閫氫俊闇€瑕佸寘鍚澶存枃锟?? */
    

  21. #include <sys/socket.h> /* 浣跨敤BSD socket锛岄渶瑕佸寘鍚玸ocket.h澶存枃锟?? */
    

  22. #include <netdb.h>
    

  23. #include <cJSON.h>
    

  24. #include "shell.h"
    

  25. #include <finsh.h>
    


  26. 


  27. 


  28. 

  29. #if     1
    

  30. #include "lcd_font.h"
    

  31. #include "tjpgd.h"
    


  32. 

  33. #define GET_HEADER_BUFSZ        1024        //澶撮儴澶у皬
    

  34. #define GET_RESP_BUFSZ          1024        //鍝嶅簲缂撳啿鍖哄ぇ
    

  35. #define GET_URL_LEN_MAX         256         //缃戝潃鏈€澶ч暱
    

  36. #define GET_URI                 "http://api.seniverse.com/v3/weather/now.json?key=%s&location=%s&language=en&unit=c" //蹇冪煡澶╂皵 API
    

  37. #define AREA_NAME               "guangzhou" //骞垮窞 ID
    

  38. #define XINZHI_API_KEY          "SaFaa9knM7IHfV5kl"     //蹇冪煡澶╂皵璁よ瘉 pravite key
    


  39. 

  40. /* 澶╂皵鏁版嵁瑙ｆ瀽 */
    

  41. void weather_data_parse(rt_uint8_t *data)
    

  42. {
    

  43.     cJSON *root = RT_NULL, *object = RT_NULL, *item = RT_NULL;
    

  44.     cJSON *arrayItem = RT_NULL,*subobject = RT_NULL;
    

  45.     char str[32];
    


  46. 

  47.     /* set the background color and foreground color */
    

  48.     lcd_fill(0,48,240,240,GBLUE);    
    

  49.     lcd_set_font_color(RED, GBLUE);
    

  50.     
    


  51. 

  52.     root = cJSON_Parse((const char *)data);
    

  53.     if (!root)
    

  54.     {
    

  55.         rt_kprintf("\nNo memory for cJSON root!\n");
    

  56.         return;
    

  57.     }
    

  58.     if((arrayItem =  cJSON_GetObjectItem(root, "results")) != RT_NULL)
    

  59.     {
    

  60.         //int size = cJSON_GetArraySize(arrayItem);     //鑾峰彇鏁扮粍涓璞′釜 3
    

  61.         if((object = cJSON_GetArrayItem(arrayItem,0)) != RT_NULL)//鑾峰彇鐖跺璞″唴
    

  62.                 {
    

  63.             /* 鍖归厤瀛愬1 */
    

  64.                         if((subobject = cJSON_GetObjectItem(object,"location")) != RT_NULL)
    

  65.                         {
    

  66.                 item = cJSON_GetObjectItem(subobject, "name");
    

  67.                 rt_kprintf("\ncityName:%s \n", item->valuestring);
    


  68. 

  69.                 lcd_set_font(&Font_CH40X40);
    

  70.                 lcd_disp_str_at(20, 48, "广州");
    


  71. 

  72.             }
    

  73.             /* 鍖归厤瀛愬2 */
    

  74.             if((subobject = cJSON_GetObjectItem(object,"now")) != RT_NULL)
    

  75.                         {
    

  76.                 lcd_set_font(&Font_CH32X32);
    

  77.                 item = cJSON_GetObjectItem(subobject, "text");
    

  78.                 rt_kprintf("weather:%s \n", item->valuestring);
    

  79.                 lcd_disp_str_at(0, 168, item->valuestring);
    


  80. 

  81.                 item = cJSON_GetObjectItem(subobject, "code");
    

  82.                 rt_kprintf("code:%s \n", item->valuestring);
    

  83.                 rt_snprintf(str,32,"/sd/weather120/%s.jpg",item->valuestring);
    

  84.                 Decode_Jpg(str,120,48);
    


  85. 

  86.                 lcd_set_font(&Font_CH40X40);
    

  87.                 item = cJSON_GetObjectItem(subobject, "temperature");
    

  88.                 rt_kprintf("temperature:%s \n", item->valuestring);
    

  89.                 rt_snprintf(str,32,"%s℃",item->valuestring);
    

  90.                 lcd_disp_str_at(20, 128, str);
    


  91. 

  92.             }
    

  93.             /* 鍖归厤瀛愬3 */
    

  94.             if((subobject = cJSON_GetObjectItem(object,"last_update")) != RT_NULL)
    

  95.                         {
    

  96.                 lcd_set_font(&Font_CH16X16);
    

  97.                 lcd_disp_str_at(0, 200, "更新时间:"); 
    


  98. 

  99.                 rt_kprintf("time:%s \n", subobject->valuestring);
    

  100.                 rt_memcpy(str,subobject->valuestring,19);
    

  101.                 str[10] = 0x20;
    

  102.                 str[19] = 0;
    

  103.                 lcd_set_font(&Font_CH24X24);
    

  104.                 lcd_disp_str_at(0, 216, str);
    

  105.             }
    

  106.         }
    

  107.     }
    


  108. 

  109.     if (root != RT_NULL)
    

  110.         cJSON_Delete(root);
    

  111. }
    


  112. 

  113. void weather(int argc, char **argv)
    

  114. {
    

  115.     rt_uint8_t *buffer = RT_NULL;
    

  116.     int resp_status;
    

  117.     struct webclient_session *session = RT_NULL;
    

  118.     char *weather_url = RT_NULL;
    

  119.     int content_length = -1, bytes_read = 0;
    

  120.     int content_pos = 0;
    


  121. 

  122.     /*  weather_url 鍒嗛厤绌洪棿 */
    

  123.     weather_url = rt_calloc(1, GET_URL_LEN_MAX);
    

  124.     if (weather_url == RT_NULL)
    

  125.     {
    

  126.         rt_kprintf("No memory for weather_url!\n");
    

  127.         goto __exit;
    

  128.     }
    


  129. 

  130.     /* 鎷兼帴 GET 缃戝潃 */    
    

  131.     if(argc > 1)
    

  132.     {
    

  133.         rt_snprintf(weather_url, GET_URL_LEN_MAX, GET_URI,XINZHI_API_KEY, argv[1]);   
    

  134.     }else
    

  135.     {
    

  136.         rt_snprintf(weather_url, GET_URL_LEN_MAX, GET_URI,XINZHI_API_KEY, AREA_NAME);        
    

  137.     }
    

  138.     rt_kprintf(weather_url);
    


  139. 

  140.     /* 鍒涘缓浼氳瘽骞朵笖璁剧疆鍝嶅簲鐨勫ぇ */
    

  141.     session = webclient_session_create(GET_HEADER_BUFSZ);
    

  142.     if (session == RT_NULL)
    

  143.     {
    

  144.         rt_kprintf("No memory for get header!\n");
    

  145.         goto __exit;
    

  146.     }
    


  147. 

  148.     /* 锟?? GET 璇锋眰浣跨敤榛樿鐨勫ご */
    

  149.     if ((resp_status = webclient_get(session, weather_url)) != 200)
    

  150.     {
    

  151.         rt_kprintf("webclient GET request failed, response(%d) error.\n", resp_status);
    


  152. 

  153.         lcd_set_font_color(RED, GBLUE);
    

  154.         lcd_set_font(&Font_CH40X40);
    

  155.         lcd_disp_str_at(0, 100, " WIFI未连接 ");
    

  156.         lcd_disp_str_at(0, 140, "请先连接WIFI");
    

  157.         goto __exit;
    

  158.     }
    


  159. 

  160.     /* 鍒嗛厤鐢ㄤ簬瀛樻斁鎺ユ敹鏁版嵁鐨勭紦 */
    

  161.     buffer = rt_calloc(1, GET_RESP_BUFSZ);
    

  162.     if (buffer == RT_NULL)
    

  163.     {
    

  164.         rt_kprintf("No memory for data receive buffer!\n");
    

  165.         goto __exit;
    

  166.     }
    


  167. 

  168.     content_length = webclient_content_length_get(session);
    

  169.     if (content_length < 0)
    

  170.     {
    

  171.         /* 杩斿洖鐨勬暟鎹槸鍒嗗潡浼犺緭. */
    

  172.         do
    

  173.         {
    

  174.             bytes_read = webclient_read(session, buffer, GET_RESP_BUFSZ);
    

  175.             if (bytes_read <= 0)
    

  176.             {
    

  177.                 break;
    

  178.             }
    

  179.         }while (1);
    

  180.     }
    

  181.     else
    

  182.     {
    

  183.         do
    

  184.         {
    

  185.             bytes_read = webclient_read(session, buffer,
    

  186.                                         content_length - content_pos > GET_RESP_BUFSZ ?
    

  187.                                         GET_RESP_BUFSZ : content_length - content_pos);
    

  188.             if (bytes_read <= 0)
    

  189.             {
    

  190.                 break;
    

  191.             }
    

  192.             content_pos += bytes_read;
    

  193.         }while (content_pos < content_length);
    

  194.     }
    


  195. 

  196.     /* 澶╂皵鏁版嵁瑙ｆ瀽 */
    

  197.     weather_data_parse(buffer);
    


  198. 

  199. __exit:
    

  200.     /* 閲婃斁缃戝潃绌洪棿 */
    

  201.     if (weather_url != RT_NULL)
    

  202.         rt_free(weather_url);
    

  203.     /* 鍏抽棴浼氳瘽 */
    

  204.     if (session != RT_NULL)
    

  205.         webclient_close(session);
    

  206.     /* 閲婃斁缂撳啿鍖虹┖ */
    

  207.     if (buffer != RT_NULL)
    

  208.         rt_free(buffer);
    

  209. }
    


  210. 

  211. MSH_CMD_EXPORT(weather, Get weather by webclient);
    


  212. 

  213. #endif
    


  214.
视屏监控
复制
  1. /*
    

  2. 本例程实现摄像头拍摄图片解码后显示到 LCD 屏上
    

  3. */
    

  4. #include <time.h>
    

  5. #include <string.h>
    

  6. #include "rtthread.h"
    

  7. #include "include.h"
    


  8. 

  9. #include "app_demo_softap.h"
    

  10. #include "video_transfer.h"
    


  11. 

  12. #include <sys/socket.h>
    

  13. #include "netdb.h"
    

  14. #include "lwip/netif.h"
    


  15. 

  16. //添加图片解码的头文件
    

  17. #include "lcd_font.h"
    

  18. #include "tjpgd.h"
    


  19. 

  20. //添加文件操作使用需要的头文�?
    

  21. #include <dfs_posix.h>
    


  22. 

  23. static char* boundary_data = RT_NULL;
    

  24. static   rt_thread_t  photo_tid1 = RT_NULL;
    

  25. static const char resp_header[] = 
    

  26. "HTTP/1.1 200 OK\r\n"
    

  27. "Content-Type: multipart/x-mixed-replace; boundary=------Boundary-------\r\n\r\n";
    


  28. 


  29. 

  30. void UserGetCurTime(struct tm *tm_new)
    

  31. {
    

  32.     time_t now;
    

  33.     struct tm *p_tm;
    

  34.     /* get current time */
    

  35.     now = time(RT_NULL);
    

  36.     /* lock scheduler. */
    

  37.     rt_enter_critical();
    

  38.     /* converts calendar time time into local time. */
    

  39.     p_tm = localtime(&now);
    

  40.     /* copy the statically located variable */
    

  41.      memcpy(tm_new, p_tm, sizeof(struct tm));
    

  42.     /* unlock scheduler. */
    

  43.     rt_exit_critical();
    

  44. }
    


  45. 

  46. #if 0
    

  47. static void hexdump(const rt_uint8_t *p, rt_size_t len)
    

  48. {
    

  49.     unsigned char *buf = (unsigned char*)p;
    

  50.     int i, j;
    

  51.     
    

  52.     rt_kprintf("Dump 0x%.8x %dBytes\n", (int)p, len); 
    

  53.     rt_kprintf("Offset    0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F\n"); 
    


  54. 

  55.     for (i=0; i<len; i+=16)
    

  56.     {
    

  57.         rt_kprintf("%08X: ", i+(int)p);
    


  58. 

  59.         for (j=0; j<16; j++)
    

  60.         {
    

  61.             if (i+j < len)
    

  62.             {
    

  63.                 rt_kprintf("%02X ", buf[i+j]);
    

  64.             }
    

  65.             else
    

  66.             {
    

  67.                 rt_kprintf("   ");
    

  68.             }
    

  69.         } 
    

  70.         rt_kprintf(" ");
    


  71. 

  72.         for (j=0; j<16; j++)
    

  73.         {
    

  74.             if (i+j < len)
    

  75.             {
    

  76.                 rt_kprintf("%c", ((unsigned int)((buf[i+j]) - ' ') < 127u - ' ') ? buf[i+j] : '.');
    

  77.             }
    

  78.         }
    

  79.         rt_kprintf("\n");
    

  80.     }
    

  81. }
    

  82. #endif
    


  83. 


  84. 

  85. // 创建 mjpeg 会话的结构体
    

  86. static struct mjpeg_session
    

  87. {
    

  88.     int sock;
    

  89.     int connected;
    

  90.     char* buf;
    

  91.     int total_len;
    

  92.     int last_frame_id;
    

  93.     int recv_frame_flag;
    

  94.     rt_tick_t old_tick;
    

  95.     rt_event_t event;
    

  96.     TVIDEO_SETUP_DESC_ST setup;
    

  97. };
    

  98. //初始�? 
    

  99. static struct mjpeg_session session = {0};
    


  100. 

  101. static void camera_start(void);
    


  102. 


  103. 

  104. //定义一帧图片的大小
    

  105. #define SEND_FRAME_EVENT             (1 << 0)
    

  106. #define SEND_FRAME_COMPLETE         (1 << 1)
    

  107. #define CLIENT_CONNECT          (1 << 2)
    

  108. #define PORT                    (5000)
    


  109. 

  110. static void get_ip(char* buf)
    

  111. {
    

  112.     rt_ubase_t index;
    

  113.     struct netif * netif;
    


  114. 

  115.     rt_enter_critical();
    

  116.     netif = netif_list;
    


  117. 

  118.     while(netif != RT_NULL)
    

  119.     {
    

  120.         if(netif->flags & NETIF_FLAG_LINK_UP)
    

  121.         {
    

  122.             rt_kprintf("ip address: %s\n", ipaddr_ntoa(&(netif->ip_addr)));
    

  123.             memcpy(buf, ipaddr_ntoa(&(netif->ip_addr)), 16);
    

  124.         }
    

  125.         netif = netif->next;
    

  126.     }
    

  127.     rt_exit_critical();
    

  128. }
    


  129. 

  130. static void tcpserv(void *parameter)
    

  131. {
    

  132.     char *recv_data;                    
    

  133.     socklen_t sin_size;
    

  134.     struct sockaddr_in server_addr, client_addr;
    

  135.     int ret;
    

  136.     char ip[20] = {0};
    


  137. 

  138.     if((session.sock = socket(AF_INET, SOCK_STREAM, 0)) == -1)
    

  139.     {
    

  140.         rt_kprintf("socket error\n");
    

  141.         goto __exit;
    

  142.     }
    


  143. 

  144.     server_addr.sin_family = AF_INET;
    

  145.     server_addr.sin_port = htons(PORT); 
    

  146.     server_addr.sin_addr.s_addr = INADDR_ANY;
    

  147.     rt_memset(&(server_addr.sin_zero), 0, sizeof(server_addr.sin_zero));
    


  148. 

  149.     if(bind(session.sock, (struct sockaddr *)&server_addr, sizeof(struct sockaddr)) == -1)
    

  150.     {
    

  151.         rt_kprintf("unable to bind\n");
    

  152.         goto __exit;
    

  153.     }
    


  154. 

  155.     if(listen(session.sock, 5) == -1)
    

  156.     {
    

  157.         rt_kprintf("listen error\n");
    

  158.         goto __exit;
    

  159.     }
    


  160. 

  161.     get_ip(ip);
    

  162.     rt_kprintf("\nTCPServer Waiting for client on %s:%d...\n", ip, PORT);
    

  163.     session.connected = -1;
    


  164. 

  165.     while(1)
    

  166.     {
    

  167.         sin_size = sizeof(struct sockaddr_in);
    

  168.         session.connected = accept(session.sock, (struct sockaddr *)&client_addr, &sin_size);
    


  169. 

  170.         if(session.connected < 0)
    

  171.         {
    

  172.             rt_kprintf("accept connection failed! errno = %d\n", errno);
    

  173.             goto __exit;
    

  174.         }
    


  175. 

  176.         rt_kprintf("I got a connection from (%s , %d)\n", inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));
    


  177. 

  178.         send(session.connected, resp_header, strlen(resp_header), 0);
    


  179. 

  180.                 rt_event_send(session.event, CLIENT_CONNECT);
    

  181.     }
    


  182. 

  183. __exit:
    

  184.     if(session.sock >= 0)
    

  185.     {
    

  186.         closesocket(session.sock);
    

  187.         session.sock = -1;
    

  188.     }
    

  189.         rt_kprintf("exit tcp server thread\n");
    

  190.     return ;
    

  191. }
    


  192. 


  193. 


  194. 

  195. static void start_cb(void)
    

  196. {
    

  197.     rt_kprintf("start cb\n");
    

  198. }
    


  199. 

  200. static void stop_cb(void)
    

  201. {
    

  202.     rt_kprintf("stop cb\n");
    

  203. }
    


  204. 

  205. static void pkt_header_cb(TV_HDR_PARAM_PTR param)
    

  206. {
    

  207.     HDR_PTR elem_tvhdr = (HDR_PTR)param->ptk_ptr;
    


  208. 

  209.     elem_tvhdr->id = (UINT8)param->frame_id;
    

  210.     elem_tvhdr->is_eof = param->is_eof;
    

  211.     elem_tvhdr->pkt_cnt = param->frame_len;
    

  212.     elem_tvhdr->size = 0;
    

  213. }
    


  214. 

  215. static int tvideo_capture_cb(UINT8 *data, UINT32 pos, UINT32 len, UINT8 is_stop)
    

  216. {
    

  217.     rt_err_t ret = 0;
    

  218.         int temp = 0;
    


  219. 

  220.     session.total_len = 0;
    

  221.     session.buf = data;
    

  222.     session.total_len += len;
    


  223. 

  224.     rt_event_send(session.event, SEND_FRAME_EVENT);
    

  225.     return len;
    

  226. }
    


  227. 

  228. static rt_uint8_t is_start = 0;
    

  229. static void camera_start(void)
    

  230. {
    

  231.     if(is_start == 1) 
    

  232.     {
    

  233.         rt_kprintf("camera is already start\n");
    

  234.         return;
    

  235.     }
    


  236. 

  237.     session.setup.send_type = TVIDEO_SND_INTF;
    

  238.     session.setup.send_func = tvideo_capture_cb;
    

  239.     session.setup.start_cb = NULL;
    

  240.     session.setup.end_cb = NULL;
    


  241. 

  242.     session.setup.pkt_header_size = sizeof(HDR_ST);
    

  243.     session.setup.add_pkt_header = pkt_header_cb;
    


  244. 

  245.     video_transfer_init(&session.setup);
    


  246. 

  247.     is_start = 1;
    

  248. }
    


  249. 

  250. static int start_flag = false;
    

  251. static int save_file_flag = false;
    


  252. 

  253. static void showphoto_thread(void* param)
    

  254. {
    

  255.     rt_thread_t tid1;
    

  256.     rt_err_t   err;
    

  257.     uint32_t   evt;
    

  258.     int ret;
    

  259.     uint8_t  connect_ok = 0;
    


  260. 

  261.     boundary_data = rt_malloc(1024);
    

  262.         if(boundary_data == RT_NULL)
    

  263.         {
    

  264.                 rt_kprintf("malloc boundary_data failed\n");
    

  265.                 goto __exit;
    

  266.         }
    


  267. 

  268.     session.event = rt_event_create("vt_event", RT_IPC_FLAG_FIFO);
    


  269. 

  270.     tid1 = rt_thread_create("tcpsrv", tcpserv, RT_NULL, 1024*4, 10, 10);
    

  271.     if(tid1 != RT_NULL)
    

  272.     { 
    

  273.         rt_thread_startup(tid1);
    

  274.     }    
    

  275.     camera_start();
    


  276. 

  277.     while(1)
    

  278.     {
    

  279.         tvideo_capture(1);
    

  280.         rt_event_recv(session.event, SEND_FRAME_EVENT, RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR, RT_WAITING_FOREVER, &evt);
    

  281.         
    

  282.         if(connect_ok == 0)
    

  283.         {
    

  284.             err =   rt_event_recv(session.event, CLIENT_CONNECT, RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR, RT_WAITING_NO, &evt);
    

  285.             if(err == RT_EOK)
    

  286.             {
    

  287.                 connect_ok = 1;
    

  288.             }
    

  289.         }
    

  290.         if((connect_ok) &&(session.connected >= 0))
    

  291.         {            
    

  292.             // rt_kprintf("send data\n");
    

  293.             rt_memset(boundary_data, 0x0, 1024);
    

  294.             ret = rt_sprintf(boundary_data, "------Boundary-------\r\nContent-Type: image/jpeg\r\nContent-Length: %d\r\n\r\n", session.total_len);
    

  295.             // rt_kprintf("pic len : %d\n", session.total_len);
    

  296.             ret = send(session.connected, boundary_data, ret, 0);
    

  297.             // hexdump(session.buf, 16);
    

  298.             ret = send(session.connected, session.buf, session.total_len, 0);
    

  299.             if(ret <= 0) 
    

  300.             {
    

  301.                 if(session.connected >= 0) closesocket(session.connected);
    

  302.                 session.connected = -1;
    

  303.             }
    

  304.             session.old_tick = rt_tick_get();
    

  305.             session.total_len = 0;
    

  306.         }
    


  307. 

  308.         if(start_flag)
    

  309.         {
    

  310.             ret = mjpeg_decoder_jpeg(session.buf,40,120);
    

  311.             rt_kprintf("mjpeg_dec res = %d\n", ret); 
    

  312.         }
    


  313. 

  314.         if(save_file_flag)
    

  315.         {
    

  316.             //save *.jpg file
    

  317.             char file_name[128] = {0};        
    

  318.             char timestr[64]={0};    
    

  319.             int fd, res;
    

  320.             struct tm tm_new;
    


  321. 

  322.             UserGetCurTime(&tm_new);
    

  323.             rt_sprintf(timestr, "%d_%d_%d-%d_%d_%d",tm_new.tm_year+1900,
    

  324.                                                         tm_new.tm_mon+1,
    

  325.                                                         tm_new.tm_mday,
    

  326.                                                         tm_new.tm_hour,
    

  327.                                                         tm_new.tm_min,
    

  328.                                                         tm_new.tm_sec);
    

  329.             rt_sprintf(file_name, "/sd/video/%s.jpg",timestr);
    

  330.             rt_kprintf("filename = %s \n", file_name);
    

  331.             fd = open(file_name, O_WRONLY | O_CREAT);
    

  332.             if (fd >= 0)
    

  333.             {
    

  334.                 write(fd, session.buf, session.total_len);
    

  335.                 close(fd);
    

  336.                 rt_kprintf("save %s ok!!!\n", file_name);
    

  337.                 lcd_set_font(&Font_CH16X16);
    

  338.                 lcd_set_font_color(BRED,GBLUE);
    

  339.                 lcd_disp_str_at(0,64,"Save OK  ");
    

  340.             }
    

  341.             else
    

  342.             {
    

  343.                 rt_kprintf("save pic failed!!!\n");
    

  344.                 lcd_set_font(&Font_CH16X16);
    

  345.                 lcd_set_font_color(BRED,GBLUE);
    

  346.                 lcd_disp_str_at(0,64,"Save Fail");
    

  347.             } 
    

  348.             save_file_flag = false;
    

  349.         }
    

  350.         tvideo_capture(0);
    


  351. 

  352.         //if(session.connected < 0)    break;
    

  353.     }  
    

  354.     rt_kprintf("showphoto_thread exit out!\n");  
    

  355.     //video_transfer_deinit();
    


  356. 

  357. __exit:
    

  358.         if(session.buf != RT_NULL) rt_free(session.buf);
    

  359.         if(boundary_data != RT_NULL) rt_free(boundary_data);
    

  360.     is_start = 0;
    

  361.     photo_tid1 = RT_NULL;
    

  362.     return;   
    


  363. 

  364. }
    

  365. void start_photo(void)
    

  366. {
    

  367.     char str[64] = {0};
    

  368.     char ip[20] = {0};
    


  369. 

  370.     start_flag = true;
    

  371.     get_ip(ip);
    

  372.     rt_snprintf(str,64,"http://%s:%d",ip,PORT);
    


  373. 

  374.     lcd_set_font(&Font_CH16X16);
    

  375.     lcd_set_font_color(BRED,GBLUE);
    

  376.     lcd_disp_str_at(0,48,&str[7]);
    


  377. 

  378.     lcd_show_qrcode(168,48,4,2,str,2);  //qr
    


  379. 

  380. }
    

  381. void stop_photo(void)
    

  382. {
    

  383.     start_flag = false;
    

  384. }
    

  385. void save_photo(void)
    

  386. {
    

  387.     save_file_flag = true;
    

  388. }
    

  389. MSH_CMD_EXPORT(start_photo,start_photo);
    

  390. MSH_CMD_EXPORT(stop_photo, stop_photo);
    

  391. MSH_CMD_EXPORT(save_photo, save_photo);
    


  392. 


  393. 

  394. void show_photo_test(void)
    

  395. {
    

  396.     if(photo_tid1 == RT_NULL)
    

  397.     {
    

  398.         photo_tid1 = rt_thread_create("showphoto_thread", showphoto_thread, RT_NULL, 1024*4, 10, 10);
    

  399.         if(photo_tid1 != RT_NULL)
    

  400.             rt_thread_startup(photo_tid1);        
    

  401.     }
    

  402.     start_photo();
    

  403. }
    


  404. 

  405. MSH_CMD_EXPORT(show_photo_test,show camera photo);








本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？注册

×
回复

收藏 举报

相关帖子
 楼主| WoodData 发表于 2020-6-14 15:02 | 显示全部楼层


终于搞定了LCD和网页同时显示了。

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？注册

×
回复

收藏 举报

ly87802541 发表于 2020-6-17 13:24 | 显示全部楼层
很牛X，可视门铃鸭
回复

收藏 举报

hu9jj 发表于 2020-6-18 19:15 | 显示全部楼层
好思路，学习了。
回复

收藏 举报

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

本版积分规则

WoodData

127

主题

4784

帖子

28

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