devbox
寸_铁
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

基于树莓派开发的智能家居控制系统_树莓派家居智能控制系统

作者：寸_铁 | 2024-07-28 08:59:04

赞

踩

树莓派家居智能控制系统

 一.功能介绍

1.通过手机端网络调试助手，语音识别，对灯光，风扇，等电器进行远程控制。

 2.通过火焰报警，震动报警，视频监控等功能保证家庭的安全。

3.实时将环境温湿度数据，各种安防信息发送到客户端进行显示。

4.通过红外遥控也能对部分家电进行远程控制。

5.通过翔云平台提供的人脸对比识别服务，实现人脸识别开锁功能。

二.实物展示

   

                 人脸识别按钮和门锁                                                433m红外接收模块

                         摄像头                                                        火焰报警和雨滴传感器

    手机端实时显示环境状态            手机端通过指令控制家电                  网页实时视频监控

 三.程序

 编译运行:

 1.mainPro.c

  1. #include<stdio.h>
  2. #include<string.h>
  3. #include<stdlib.h>
  4. #include<pthread.h>
  5. #include<unistd.h>
  6. #include <sys/types.h>
  7. #include <sys/socket.h>
  8. #include <arpa/inet.h>
  9. #include <netinet/in.h>
  10. #include <stdint.h>
  11. #include <curl/curl.h>
  12.  
  13. #include"InputCommand.h"
  14. #include"contrlDevices.h"
  15. //为了线程里能调到链表头，要把这两个表头设置为全局变量
  16. struct Devices *pdeviceHead = NULL;
  17. struct InputCommander *pCommandHead = NULL;
  18.  
  19. struct InputCommander *socketHandler = NULL;
  20. int c_fd;
  21. //定义互斥量(锁)
  22. pthread_mutex_t mutex;
  23.  
  24. typedef unsigned char uint8;
  25. typedef unsigned int  uint16;
  26. typedef unsigned long uint32;
  27.  
  28. #define HIGH_TIME 32
  29.  
  30. pthread_t writeThread;
  31. pthread_t voiceThread;
  32. pthread_t socketThread;
  33. pthread_t fireThread;
  34. pthread_t DHT11Thread;
  35. pthread_t readThread;
  36. pthread_t shakeThread;
  37. pthread_t windowThread;
  38. pthread_t keyThread;
  39. pthread_t cameraThread;
  40. pthread_t remoteThread;
  41.  
  42.  
  43. int tmp = 0;//设置火灾和振动的标志位
  44. int wintmp1 = 0;
  45. int wintmp2 = 0;
  46. #define key 6 //拍照按键
  47.  
  48. char Message[4][100] = {"未启用！", "未启用！", "未启用！", "未启用！"};
  49. int write_flag = 0; //标记位，标记通知线程是否打开     1：打开   0：关闭
  50. int a = 0;
  51. int b = 0;
  52.  
  53. extern uint32 databuf;
  54.  
  55. struct Devices* findDeviceByName(char *name, struct Devices *phead)
  56. {
  57. 	struct Devices *tmp = phead;
  58. 	if(phead == NULL){
  59. 		return NULL;
  60. 	}else{
  61. 			while(tmp != NULL){
  62. 				if(strcmp(tmp->deviceName, name) == 0){
  63. 					return tmp;
  64. 				}
  65. 				tmp = tmp->next;
  66. 			}
  67. 			return NULL;
  68. 		}
  69. }
  70.  
  71. struct InputCommander* findCommandByName(char *name, struct InputCommander *phead)
  72. {
  73. 	struct InputCommander *tmp = phead;
  74. 	if(phead == NULL){
  75. 		return NULL;
  76. 	}else{
  77. 			while(tmp != NULL){
  78. 				if(strcmp(tmp->commandName, name) == 0){
  79. 					return tmp;
  80. 				}
  81. 				tmp = tmp->next;
  82. 			}
  83. 			return NULL;
  84. 		}
  85. }
  86. void *window_thread(void *datas)
  87. {
  88. 	struct Devices *windowDeviceTmp = NULL;
  89. 	windowDeviceTmp = findDeviceByName("window", pdeviceHead);
  90. 	if(windowDeviceTmp == NULL)
  91. 	{
  92. 		printf("find window error\n");
  93. 		pthread_exit(NULL);
  94. 	}
  95. 	windowDeviceTmp->deviceInit(windowDeviceTmp->pinNum);
  96. 	
  97. 	while(1){
  98. 		if(digitalRead(5) == 0){	//没雨 开窗 5引脚就是检测是否有雨水 
  99. 			sleep(1);
  100. 			b = 1;
  101. 			if(a != 0){
  102. 				windowDeviceTmp->open(windowDeviceTmp->pinNum);//正转 开窗
  103. 				sleep(5);
  104. 				windowDeviceTmp->deviceInit(windowDeviceTmp->pinNum);//停
  105. 		
  106. 				while(digitalRead(5) == 0);
  107. 			}
  108. 		}
  109. 		else if(digitalRead(5) == 1){
  110. 			sleep(1);
  111. 			a = 1;
  112. 			if(b != 0){
  113. 				windowDeviceTmp->close(windowDeviceTmp->pinNum);//反转 关窗
  114. 				sleep(5);
  115. 				windowDeviceTmp->deviceInit(windowDeviceTmp->pinNum);//停
  116. 				
  117. 				while(digitalRead(5) == 1);
  118. 			}
  119. 		}
  120. 	}
  121.  
  122. }
  123.  
  124. void *shake_thread(void *datas) //震动线程
  125. {
  126. 	int tmp1 = 0;
  127. 	
  128. 	struct Devices *shakeDeviceTmp = NULL;
  129. 	struct Devices *shakebuzzerDeviceTmp = NULL;  
  130. 	shakeDeviceTmp = findDeviceByName("shake", pdeviceHead); //在设备工厂找到震动模块和震动蜂鸣器
  131. 	shakebuzzerDeviceTmp = findDeviceByName("shakebuzzer", pdeviceHead);
  132. 	if((shakeDeviceTmp == NULL)&&(shakebuzzerDeviceTmp == NULL))
  133. 	{
  134. 		printf("find shake or shakebuzzer error\n");
  135. 		pthread_exit(NULL);
  136. 	}
  137. 	shakeDeviceTmp->deviceInit(shakeDeviceTmp->pinNum); //震动初始化
  138. 	shakebuzzerDeviceTmp->deviceInit(shakebuzzerDeviceTmp->pinNum);//蜂鸣器初始化
  139. 	while(1)
  140. 	{
  141.  
  142. 			//tmp = 1;
  143. 		if(digitalRead(26) == 1)                                                                                          
  144. 		{
  145. 			
  146. 			shakebuzzerDeviceTmp->open(shakebuzzerDeviceTmp->pinNum);		//开震动蜂鸣器
  147. 			delay(3);
  148. 			shakebuzzerDeviceTmp->close(shakebuzzerDeviceTmp->pinNum);	
  149. 			memset(Message[3], 0, sizeof Message[3]);       //清空数组
  150. 	        sprintf(Message[3], "无震动 ");       //更新震动信息
  151. 	        
  152. 		}
  153.  
  154. 		else
  155. 		{
  156. 			memset(Message[3], 0, sizeof Message[3]);        //清空数组
  157.             sprintf(Message[3], "有震动! ");
  158. 			shakebuzzerDeviceTmp->close(shakebuzzerDeviceTmp->pinNum);		//关震动蜂鸣器
  159. 		
  160. 			
  161. 		}
  162. 	}
  163.  
  164. }
  165.  
  166. void *fire_thread(void *datas) //火灾线程
  167. {
  168. 	struct Devices *fireDeviceTmp = NULL;
  169. 	struct Devices *buzzerDeviceTmp = NULL;
  170. 	fireDeviceTmp = findDeviceByName("fireIfOrNot", pdeviceHead); //在设备工厂找到火焰模块和火焰蜂鸣器
  171. 	buzzerDeviceTmp = findDeviceByName("buzzer", pdeviceHead);
  172. 	
  173. 	if((fireDeviceTmp == NULL)&&(buzzerDeviceTmp == NULL))
  174. 	{
  175. 		printf("find fire or buzzer error\n");
  176. 		pthread_exit(NULL);
  177. 	}
  178. 	fireDeviceTmp->deviceInit(fireDeviceTmp->pinNum); //火灾模块初始化
  179. 	buzzerDeviceTmp->deviceInit(buzzerDeviceTmp->pinNum);//蜂鸣器初始化
  180. 	while(1)
  181. 	{
  182. 		if(digitalRead(25) == 1)
  183. 		{
  184.  
  185. 			buzzerDeviceTmp->open(buzzerDeviceTmp->pinNum);		//开火灾蜂鸣器
  186. 			memset(Message[2], 0, sizeof Message[2]);       //清空数组
  187.             sprintf(Message[2], "无火灾");       //更新火灾信息
  188. 			
  189. 		}
  190. 		else
  191. 		{
  192. 			buzzerDeviceTmp->close(buzzerDeviceTmp->pinNum);	//关火灾蜂鸣器
  193. 			memset(Message[2], 0, sizeof Message[2]);        //清空数组
  194.             sprintf(Message[2], "有火灾! "); 
  195. 			tmp = 0;
  196.             
  197. 		}
  198. 		
  199. 	}
  200. }
  201.  
  202.  
  203. void *voice_thread(void* datas)//语音线程
  204. {
  205. 	struct InputCommander *voiceHandler;
  206. 	struct Devices *deviceTmp = NULL;
  207. 	int nread;
  208. 	
  209. 	voiceHandler = findCommandByName("voice", pCommandHead);//找语音节点
  210. 	if(voiceHandler == NULL)
  211. 	{
  212. 		printf("find voice error\n");
  213. 		pthread_exit(NULL);
  214. 	}
  215. 	else
  216. 	{								//找到了
  217. 		if(voiceHandler->Init(voiceHandler, NULL, NULL) < 0)
  218. 		{	//先初始化
  219. 			printf("voice init error\n");
  220. 			pthread_exit(NULL);//退出线程
  221. 		}
  222. 		else
  223. 		{
  224. 			printf("%s init success\n",voiceHandler->commandName);
  225. 		}
  226. 		pthread_mutex_lock(&mutex); //加锁
  227. 									//语音读取一级指令的时候，为了避免其它线程对于 紧接着读取二级指令的干扰
  228. 		while(1)
  229. 		{						//读数据
  230. 			memset(voiceHandler->command, '\0', sizeof(voiceHandler->command));
  231. 			nread = voiceHandler->getCommand(voiceHandler);//获取语音模块发来的数据
  232. 			printf("get voice command:%s\n", voiceHandler->command);
  233. 			if(nread == 0)
  234. 			{
  235. 				printf("nodata from voice\n");
  236. 			}
  237. 			else if(strstr(voiceHandler->command, "kycd") != NULL)		//1如果收到数据
  238. 			{
  239. 				deviceTmp = findDeviceByName("livingRoomLight",pdeviceHead);//通过名子找到节点
  240. 				deviceTmp->deviceInit(deviceTmp->pinNum);//初始化
  241. 				deviceTmp->open(deviceTmp->pinNum);//开泳池灯
  242. 			}
  243. 			else if(strstr(voiceHandler->command, "gycd") != NULL)		
  244. 			{
  245. 				deviceTmp = findDeviceByName("livingRoomLight",pdeviceHead);//通过名子找到节点
  246. 				deviceTmp->deviceInit(deviceTmp->pinNum);//初始化
  247. 				deviceTmp->close(deviceTmp->pinNum);//关泳池灯
  248. 			}
  249.  
  250. 			else if(strstr(voiceHandler->command, "kwsd") != NULL)		//
  251. 			{
  252. 				deviceTmp = findDeviceByName("upstairLight",pdeviceHead);//通过名子找到节点
  253. 				deviceTmp->deviceInit(deviceTmp->pinNum);//初始化
  254. 				deviceTmp->open(deviceTmp->pinNum);//开卧室灯
  255. 			}
  256. 			else if(strstr(voiceHandler->command, "gwsd") != NULL)		
  257. 			{
  258. 				deviceTmp = findDeviceByName("upstairLight",pdeviceHead);//通过名子找到节点
  259. 				deviceTmp->deviceInit(deviceTmp->pinNum);//初始化
  260. 				deviceTmp->close(deviceTmp->pinNum);//关卧室灯
  261. 			}
  262. 			
  263. 			else if(strstr(voiceHandler->command, "kysd") != NULL)		
  264. 			{
  265. 				deviceTmp = findDeviceByName("bathroomLight",pdeviceHead);
  266. 				deviceTmp->deviceInit(deviceTmp->pinNum);//初始化
  267. 				deviceTmp->open(deviceTmp->pinNum);//开浴室灯
  268. 			}
  269. 			else if(strstr(voiceHandler->command, "gysd") != NULL)		
  270. 			{
  271. 				deviceTmp = findDeviceByName("bathroomLight",pdeviceHead);
  272. 				deviceTmp->deviceInit(deviceTmp->pinNum);//初始化
  273. 				deviceTmp->close(deviceTmp->pinNum);//关浴室灯
  274. 			}
  275.  
  276. 			else if(strstr(voiceHandler->command, "kcfd") != NULL)		
  277. 			{
  278. 				deviceTmp = findDeviceByName("restauranLight",pdeviceHead);
  279. 				deviceTmp->deviceInit(deviceTmp->pinNum);//初始化
  280. 				deviceTmp->open(deviceTmp->pinNum);//开厨房灯
  281. 			}
  282. 			else if(strstr(voiceHandler->command, "gcfd") != NULL)		
  283. 			{
  284. 				deviceTmp = findDeviceByName("restauranLight",pdeviceHead);
  285. 				deviceTmp->deviceInit(deviceTmp->pinNum);//初始化
  286. 				deviceTmp->close(deviceTmp->pinNum);//关厨房灯
  287. 			}
  288.  
  289. 			
  290. 			else if(strstr(voiceHandler->command, "kfs") != NULL)		//开风扇
  291. 			{
  292. 				deviceTmp = findDeviceByName("fan",pdeviceHead);
  293. 				deviceTmp->deviceInit(deviceTmp->pinNum);//初始化
  294. 				deviceTmp->open(deviceTmp->pinNum);
  295. 			}
  296. 			else if(strstr(voiceHandler->command, "gfs") != NULL)		//关风扇
  297. 			{
  298. 				deviceTmp = findDeviceByName("fan",pdeviceHead);
  299. 				deviceTmp->deviceInit(deviceTmp->pinNum);//初始化
  300. 				deviceTmp->close(deviceTmp->pinNum);
  301. 			}
  302.  
  303. 			
  304. 			else if(strstr(voiceHandler->command, "quankai") != NULL)		
  305. 			{
  306. 				deviceTmp = findDeviceByName("livingRoomLight",pdeviceHead);//通过名子找到节点
  307. 				deviceTmp->deviceInit(deviceTmp->pinNum);//初始化
  308. 				deviceTmp->open(deviceTmp->pinNum);//开泳池灯
  309.  
  310. 				deviceTmp = findDeviceByName("upstairLight",pdeviceHead);//通过名子找到节点
  311. 				deviceTmp->deviceInit(deviceTmp->pinNum);//初始化
  312. 				deviceTmp->open(deviceTmp->pinNum);//开卧室灯
  313.  
  314. 				deviceTmp = findDeviceByName("bathroomLight",pdeviceHead);
  315. 				deviceTmp->deviceInit(deviceTmp->pinNum);//初始化
  316. 				deviceTmp->open(deviceTmp->pinNum);//开浴室灯
  317.  
  318. 				deviceTmp = findDeviceByName("restauranLight",pdeviceHead);
  319. 				deviceTmp->deviceInit(deviceTmp->pinNum);//初始化
  320. 				deviceTmp->open(deviceTmp->pinNum);//开厨房灯
  321.  
  322. 				deviceTmp = findDeviceByName("fan",pdeviceHead);
  323. 				deviceTmp->deviceInit(deviceTmp->pinNum);//初始化
  324. 				deviceTmp->open(deviceTmp->pinNum);//开风扇
  325. 			}
  326. 			else if(strstr(voiceHandler->command, "quanguan") != NULL)		//如果收到数据
  327. 			{
  328. 				deviceTmp = findDeviceByName("livingRoomLight",pdeviceHead);//通过名子找到节点
  329. 				deviceTmp->deviceInit(deviceTmp->pinNum);//初始化
  330. 				deviceTmp->close(deviceTmp->pinNum);//关泳池灯
  331.  
  332. 				deviceTmp = findDeviceByName("upstairLight",pdeviceHead);//通过名子找到节点
  333. 				deviceTmp->deviceInit(deviceTmp->pinNum);//初始化
  334. 				deviceTmp->close(deviceTmp->pinNum);//关卧室灯
  335.  
  336. 				deviceTmp = findDeviceByName("bathroomLight",pdeviceHead);
  337. 				deviceTmp->deviceInit(deviceTmp->pinNum);//初始化
  338. 				deviceTmp->close(deviceTmp->pinNum);//关浴室灯
  339.  
  340. 				deviceTmp = findDeviceByName("restauranLight",pdeviceHead);
  341. 				deviceTmp->deviceInit(deviceTmp->pinNum);//初始化
  342. 				deviceTmp->close(deviceTmp->pinNum);//关厨房灯
  343.  
  344. 				deviceTmp = findDeviceByName("fan",pdeviceHead);
  345. 				deviceTmp->deviceInit(deviceTmp->pinNum);//初始化
  346. 				deviceTmp->close(deviceTmp->pinNum);//关风扇
  347. 			}
  348. 		}
  349. 	}
  350.  
  351. }
  352.  
  353. void *read_thread(void *datas)
  354. {
  355.  	int n_read;
  356. 	struct Devices *deviceTmp = NULL;
  357. 	
  358. 	while(1)
  359. 	{
  360. 		memset(socketHandler->command, '\0', sizeof(socketHandler->command));
  361. 		n_read = read(c_fd, socketHandler->command, sizeof(socketHandler->command));//客户端发来的数据存到 socketHandler->command
  362. 		if(n_read == -1){
  363. 			perror("read");
  364. 		}
  365. 		else if(n_read > 0){
  366. 		printf("\nget: %d,%s\n",n_read,socketHandler->command);//打印客户端发来的数据
  367. 		//if (strstr(socketHandler->command, "kwsd") != NULL)
  368. 		if(strstr(socketHandler->command, "kycd") != NULL)		//1如果收到数据
  369. 		{
  370. 			deviceTmp = findDeviceByName("livingRoomLight",pdeviceHead);//通过名子找到节点
  371. 			deviceTmp->deviceInit(deviceTmp->pinNum);//初始化
  372. 			deviceTmp->open(deviceTmp->pinNum);//开泳池灯
  373. 		}
  374. 		else if(strstr(socketHandler->command, "gycd") != NULL)		
  375. 		{
  376. 			deviceTmp = findDeviceByName("livingRoomLight",pdeviceHead);//通过名子找到节点
  377. 			deviceTmp->deviceInit(deviceTmp->pinNum);//初始化
  378. 			deviceTmp->close(deviceTmp->pinNum);//关泳池灯
  379. 		}
  380.  
  381. 		else if(strstr(socketHandler->command, "kwsd") != NULL)		//
  382. 		{
  383. 			deviceTmp = findDeviceByName("upstairLight",pdeviceHead);//通过名子找到节点
  384. 			deviceTmp->deviceInit(deviceTmp->pinNum);//初始化
  385. 			deviceTmp->open(deviceTmp->pinNum);//开卧室灯
  386. 		}
  387. 		else if(strstr(socketHandler->command, "gwsd") != NULL)		
  388. 		{
  389. 			deviceTmp = findDeviceByName("upstairLight",pdeviceHead);//通过名子找到节点
  390. 			deviceTmp->deviceInit(deviceTmp->pinNum);//初始化
  391. 			deviceTmp->close(deviceTmp->pinNum);//关卧室灯
  392. 		}
  393. 		
  394. 		else if(strstr(socketHandler->command, "kysd") != NULL)		
  395. 		{
  396. 			deviceTmp = findDeviceByName("bathroomLight",pdeviceHead);
  397. 			deviceTmp->deviceInit(deviceTmp->pinNum);//初始化
  398. 			deviceTmp->open(deviceTmp->pinNum);//开浴室灯
  399. 		}
  400. 		else if(strstr(socketHandler->command, "gysd") != NULL)		
  401. 		{
  402. 			deviceTmp = findDeviceByName("bathroomLight",pdeviceHead);
  403. 			deviceTmp->deviceInit(deviceTmp->pinNum);//初始化
  404. 			deviceTmp->close(deviceTmp->pinNum);//关浴室灯
  405. 		}
  406.  
  407. 		else if(strstr(socketHandler->command, "kcfd") != NULL)		
  408. 		{
  409. 			deviceTmp = findDeviceByName("restauranLight",pdeviceHead);
  410. 			deviceTmp->deviceInit(deviceTmp->pinNum);//初始化
  411. 			deviceTmp->open(deviceTmp->pinNum);//开厨房灯
  412. 		}
  413. 		else if(strstr(socketHandler->command, "gcfd") != NULL)		
  414. 		{
  415. 			deviceTmp = findDeviceByName("restauranLight",pdeviceHead);
  416. 			deviceTmp->deviceInit(deviceTmp->pinNum);//初始化
  417. 			deviceTmp->close(deviceTmp->pinNum);//关厨房灯
  418. 		}
  419.  
  420. 		
  421. 		else if(strstr(socketHandler->command, "kfs") != NULL)		//开风扇
  422. 		{
  423. 			deviceTmp = findDeviceByName("fan",pdeviceHead);
  424. 			deviceTmp->deviceInit(deviceTmp->pinNum);//初始化
  425. 			deviceTmp->open(deviceTmp->pinNum);
  426. 		}
  427. 		else if(strstr(socketHandler->command, "gfs") != NULL)		//关风扇
  428. 		{
  429. 			deviceTmp = findDeviceByName("fan",pdeviceHead);
  430. 			deviceTmp->deviceInit(deviceTmp->pinNum);//初始化
  431. 			deviceTmp->close(deviceTmp->pinNum);
  432. 		}
  433.  
  434. 		
  435. 		else if(strstr(socketHandler->command, "quankai") != NULL)		
  436. 		{
  437. 			deviceTmp = findDeviceByName("livingRoomLight",pdeviceHead);//通过名子找到节点
  438. 			deviceTmp->deviceInit(deviceTmp->pinNum);//初始化
  439. 			deviceTmp->open(deviceTmp->pinNum);//开泳池灯
  440.  
  441. 			deviceTmp = findDeviceByName("upstairLight",pdeviceHead);//通过名子找到节点
  442. 			deviceTmp->deviceInit(deviceTmp->pinNum);//初始化
  443. 			deviceTmp->open(deviceTmp->pinNum);//开卧室灯
  444.  
  445. 			deviceTmp = findDeviceByName("bathroomLight",pdeviceHead);
  446. 			deviceTmp->deviceInit(deviceTmp->pinNum);//初始化
  447. 			deviceTmp->open(deviceTmp->pinNum);//开浴室灯
  448.  
  449. 			deviceTmp = findDeviceByName("restauranLight",pdeviceHead);
  450. 			deviceTmp->deviceInit(deviceTmp->pinNum);//初始化
  451. 			deviceTmp->open(deviceTmp->pinNum);//开厨房灯
  452.  
  453. 			deviceTmp = findDeviceByName("fan",pdeviceHead);
  454. 			deviceTmp->deviceInit(deviceTmp->pinNum);//初始化
  455. 			deviceTmp->open(deviceTmp->pinNum);//开风扇
  456. 		}
  457. 		else if(strstr(socketHandler->command, "quanguan") != NULL)		//如果收到数据
  458. 		{
  459. 			deviceTmp = findDeviceByName("livingRoomLight",pdeviceHead);//通过名子找到节点
  460. 			deviceTmp->deviceInit(deviceTmp->pinNum);//初始化
  461. 			deviceTmp->close(deviceTmp->pinNum);//关泳池灯
  462.  
  463. 			deviceTmp = findDeviceByName("upstairLight",pdeviceHead);//通过名子找到节点
  464. 			deviceTmp->deviceInit(deviceTmp->pinNum);//初始化
  465. 			deviceTmp->close(deviceTmp->pinNum);//关卧室灯
  466.  
  467. 			deviceTmp = findDeviceByName("bathroomLight",pdeviceHead);
  468. 			deviceTmp->deviceInit(deviceTmp->pinNum);//初始化
  469. 			deviceTmp->close(deviceTmp->pinNum);//关浴室灯
  470.  
  471. 			deviceTmp = findDeviceByName("restauranLight",pdeviceHead);
  472. 			deviceTmp->deviceInit(deviceTmp->pinNum);//初始化
  473. 			deviceTmp->close(deviceTmp->pinNum);//关厨房灯
  474.  
  475. 			deviceTmp = findDeviceByName("fan",pdeviceHead);
  476. 			deviceTmp->deviceInit(deviceTmp->pinNum);//初始化
  477. 			deviceTmp->close(deviceTmp->pinNum);//关风扇
  478. 		}
  479. 	}
  480. 		
  481. 	else{
  482. 		printf("client quit\n");
  483. 		write_flag = 0;		
  484. 		pthread_cancel(writeThread);
  485. 		pthread_exit(NULL);
  486. 	}
  487. 		}
  488. }
  489. void *write_thread(void *datas) //实时向客户端发送消息
  490. {
  491.     while (1)
  492.     {
  493.         delay(1000);
  494.         write(c_fd, Message, 400);
  495.     }
  496. }
  497.  
  498. void *socket_thread(void* datas)
  499. {
  500.  
  501. 	int n_read = 0;
  502. 	
  503. 	
  504. 	struct sockaddr_in c_addr;
  505. 	memset(&c_addr, 0, sizeof(struct sockaddr_in));
  506. 	int clen = sizeof(struct sockaddr_in);
  507. 	
  508. 	socketHandler = findCommandByName("socketServer", pCommandHead);//找socket节点
  509. 	if(socketHandler == NULL){
  510. 		printf("find socketHandler error\n");
  511. 		pthread_exit(NULL);
  512. 	}else{
  513. 		printf("%s init success\n",socketHandler->commandName);
  514. 	} 
  515. 	socketHandler->Init(socketHandler, NULL, NULL);//找到就初始化
  516.  
  517. 	while(1){		//只要有新的客户端接入 就创建新线程去对接
  518. 		c_fd = accept(socketHandler->sfd, (struct sockaddr *)&c_addr, &clen);
  519. 		
  520.  		pthread_create(&readThread, NULL, read_thread, NULL);//读客户端发来的数据
  521.  		
  522.  		if (write_flag == 0){
  523. 			write_flag = 1;
  524. 			pthread_create(&writeThread, NULL, write_thread, NULL);//往客户端发数据 比如温湿度
  525.  		}
  526.  
  527. 		
  528. 	}
  529. }
  530.  
  531.  
  532. void *DHT11_thread(void* datas)
  533. {
  534.  
  535. 	struct Devices *DHT11DeviceTmp = NULL;
  536.  
  537. 	DHT11DeviceTmp = findDeviceByName("DHT11", pdeviceHead); //在设备工厂找到温湿度模块
  538.  
  539. 	DHT11DeviceTmp->deviceInit(DHT11DeviceTmp->pinNum); //温湿度模块初始化
  540.  
  541.  
  542.     while (1) 
  543.     {
  544.         //pinMode(7, OUTPUT); // set mode to output
  545.        // digitalWrite(7, 1); // output a high level 
  546.         delay(3000);
  547.         if (DHT11DeviceTmp->deviceInit(DHT11DeviceTmp->pinNum))
  548.         {
  549.            // printf("Sensor data read ok!\n");
  550. 			memset(Message[0], 0, sizeof Message[0]); //清空数组
  551.             memset(Message[1], 0, sizeof Message[1]);
  552. 		   
  553.             sprintf(Message[0], "湿度:%d.%d ", (databuf >> 24) & 0xff, (databuf >> 16) & 0xff); 
  554.             sprintf(Message[1], "温度:%d.%d ", (databuf >> 8) & 0xff, databuf & 0xff);
  556. 			//printf("shidu = %d.%d\n", (databuf >> 24) & 0xff, (databuf >> 16) & 0xff);
  557. 			//printf("wendu = %d.%d\n", (databuf >> 8) & 0xff, databuf & 0xff);
  558. 			
  559.             databuf = 0;
  560.         }
  561.         else
  562.         {
  563.             printf("Sensor dosent ans!\n");
  564.             databuf = 0;
  565.          }
  566.      }
  567.  
  568.  
  569. }
  570. void *remote_thread(void *datas)//433m线程
  571. {
  572. 	int val0 = 0, val1 = 0, val2 = 0, val3 = 0;
  573.     int temp0 = 0, temp1 = 0,temp2 = 0,temp3 = 0;
  574. 	int count0 = 0, count1 = 0, count2 = 0, count3 = 0;
  575. 	
  576. 	struct Devices *deviceTmp = NULL;
  577. 	wiringPiSetup();
  578.     pinMode(12, INPUT);
  579.     pinMode(13, INPUT);
  580. 	pinMode(14, INPUT);
  581.     pinMode(30, INPUT);
  582. 	
  583.     digitalWrite(12, LOW);
  584.     digitalWrite(13, LOW);
  585. 	digitalWrite(14, LOW);
  586.     digitalWrite(30, LOW);
  587.  
  588. 	while(1)
  589. 	{
  590. 		val0 = digitalRead(12);
  591.     	val1 = digitalRead(13);
  592. 		val2 = digitalRead(14);
  593.     	val3 = digitalRead(30);
  594. 		if (val0 == 1) //电风扇遥控信号 	
  595.         {
  596.         	if(count0 == 0)
  597. 			{
  598. 			 	delay(500);
  599.              	if (temp0 == 0) //打开厨房灯
  600.              	{
  601.  
  602.                  	printf("433M:open restauranLight\n");
  603.                  	temp0 = 1;
  604.                  	deviceTmp = findDeviceByName("restauranLight", pdeviceHead);
  605.                  	deviceTmp->deviceInit(deviceTmp->pinNum);       
  606.                  	deviceTmp->open(deviceTmp->pinNum);             
  607.                  	while(val0 == 0);
  608.             	 }
  609.              	else if (temp0 == 1) //关闭厨房灯
  610.              	{
  611.  
  612.                 	 printf("433M:close restauranLight\n");
  613.                  	temp0 = 0;
  614.                  	deviceTmp = findDeviceByName("restauranLight", pdeviceHead); 
  615.                  	deviceTmp->deviceInit(deviceTmp->pinNum);         
  616.                  	deviceTmp->close(deviceTmp->pinNum);              
  617.                  
  618.             	 }
  619. 				count0 = 1;
  620.         	}
  621. 			
  622.         }
  623. 		else if (val0 == 0)
  624.         {
  625.             count0 = 0;
  626.         }
  627.  
  628.  
  629. 		if (val1 == 1) //泳池灯遥控信号
  630.         {
  631.         	if(count1 == 0)
  632.         	{
  633. 				delay(500);
  634. 	             if (temp1 == 0) //打开泳池灯 
  635. 	             {
  636. 	                 printf("433M:open livingRoomLight\n");
  637. 	                 temp1 = 1;
  638. 	                 deviceTmp = findDeviceByName("livingRoomLight", pdeviceHead);
  639. 	                 deviceTmp->deviceInit(deviceTmp->pinNum);        
  640. 	                 deviceTmp->open(deviceTmp->pinNum);              
  641. 	                 while(val1 == 0);
  642. 	             }
  643. 	             else if (temp1 == 1) //关闭泳池灯
  644. 	             {
  645.                  	printf("433M:close livingRoomLight\n");
  646.                  	temp1 = 0;
  647.                  	deviceTmp = findDeviceByName("livingRoomLight", pdeviceHead);
  648.                  	deviceTmp->deviceInit(deviceTmp->pinNum);      
  649.                  	deviceTmp->close(deviceTmp->pinNum);             
  650. 	             }
  651. 				count1 = 1;
  652.         	}
  653.         }
  654. 		else if (val1 == 0)
  655.         {
  656.             count1 = 0;
  657.         }
  658.  
  659.  
  660. 			
  661. 		if (val2 == 1) //卧室灯遥控信号
  662.         {
  663.         	if(count2 == 0)
  664. 			{
  665. 				delay(500);
  666. 	             if (temp2 == 0)   //打开卧室灯
  667. 	             {
  668.  
  669. 	                 printf("433M:open upstairLight\n");
  670. 	                 temp2 = 1;
  671. 	                 deviceTmp = findDeviceByName("upstairLight", pdeviceHead);
  672. 	                 deviceTmp->deviceInit(deviceTmp->pinNum);     
  673. 	                 deviceTmp->open(deviceTmp->pinNum);             
  674. 	                 while(val2 == 0);
  675. 	             }
  676. 	             else if (temp2 == 1)  //关闭卧室灯
  677. 	             {
  678.  
  679. 	                 printf("433M:close upstairLight\n");
  680. 	                 temp2 = 0;
  681. 	                 deviceTmp = findDeviceByName("upstairLight", pdeviceHead); 
  682. 	                 deviceTmp->deviceInit(deviceTmp->pinNum);        
  683. 	                 deviceTmp->close(deviceTmp->pinNum);             
  684. 	                 
  685. 	             }
  686. 				 count2 = 1;
  687.         	}
  688.         }
  689. 		else if (val2 == 0)
  690.         {
  691.             count2 = 0;
  692.         }
  693.  
  694.  
  695. 		if (val3 == 1) //浴室灯遥控信号
  696.         {
  697.         	if(count3 == 0)
  698. 			{
  699. 				delay(500);
  700. 	             if (temp3 == 0) //打开浴室灯  
  701. 	             {
  702.  
  703. 	                 printf("433M:open bathroomLight\n");
  704. 	                 temp3 = 1;
  705. 	                 deviceTmp = findDeviceByName("bathroomLight", pdeviceHead);
  706. 	                 deviceTmp->deviceInit(deviceTmp->pinNum);     
  707. 	                 deviceTmp->open(deviceTmp->pinNum);              
  708. 	                 while(val3 == 0);
  709. 	             }
  710. 	             else if (temp3 == 1) //关闭浴室灯
  711. 	             {
  712.  
  713. 	                 printf("433M:close bathroomLight\n");
  714. 	                 temp3 = 0;
  715. 	                 deviceTmp = findDeviceByName("bathroomLight", pdeviceHead); 
  716. 	                 deviceTmp->deviceInit(deviceTmp->pinNum);        
  717. 	                 deviceTmp->close(deviceTmp->pinNum);            
  718. 	                 
  719. 	             }
  720. 				 count3 = 1;
  721.         	}
  722.         }
  723. 		else if (val3 == 0)
  724.         {
  725.             count3 = 0;
  726.         }
  727. 	}
  728.  
  729.  
  730. }
  731.  
  732. void *cameraThread_func(void *data) //起线程的函数有格式要求
  733. {
  734.     struct Devices *cameraTemp;
  735.  
  736.     cameraTemp = findDeviceByName("camera", pdeviceHead); //找到摄像头节点
  737.  
  738.     if (cameraTemp == NULL)
  739.     { 
  740.         printf("find camera error\n");
  741.         pthread_exit(NULL); //在线程中不用return
  742.     }
  743.  
  744.     cameraTemp->justDoOnce(); //调用postUrl函数
  745. }
  746.  
  747. void *key_thread()
  748. {
  749.     // pinMode(door_Lock, OUTPUT); //将门锁端口置为输出
  750.     
  751.     int val;
  752.     while (1)
  753.     {
  754.         val = digitalRead(key);
  755.         // printf("key = %d\n", val);
  756.         if (val == 0) //防止重复检测
  757.         {
  758.             delay(500);
  759.             val = digitalRead(key);
  760.             // printf("key = %d\n", val);
  761.             if (val == 1) //按键按下，启动人脸识别线程
  762.             {
  763. 				
  764.                 pthread_create(&cameraThread, NULL, cameraThread_func, NULL);
  765.             }
  766.         }
  767.     }
  768. }
  769.  
  770.  
  771. int main()
  772. {
  773. 	char name[128];
  774. 	struct Devices *tmp = NULL;
  775. 	
  776. 	  
  777. 	if(-1 == wiringPiSetup()){
  778. 		return -1;
  779. 	}
  780.  
  781. 	//1.指令工厂初始化
  782. 	pCommandHead = addvoiceContrlToInputCommandLink(pCommandHead);//语音
  783. 	pCommandHead = addSocketContrlToInputCommandLink(pCommandHead);//socket
  784.  
  785. 	//2.设备控制工厂初始化
  786. 	pdeviceHead = addBathroomLightToDeviceLink(pdeviceHead);
  787. 	pdeviceHead = addUpstairLightToDeviceLink(pdeviceHead);
  788. 	pdeviceHead = addRestauranLightToDeviceLink(pdeviceHead);
  789. 	pdeviceHead = addLivingRoomLightToDeviceLink(pdeviceHead);
  790. 	pdeviceHead = addfireToDeviceLink(pdeviceHead);//火灾模块
  791. 	
  792. 	pdeviceHead = addbuzzerToDeviceLink(pdeviceHead);//火灾蜂鸣器
  793. 	
  794. 	pdeviceHead = addshakebuzzerToDeviceLink(pdeviceHead);//震动蜂鸣器
  795. 	
  796. 	pdeviceHead = addfanToDeviceLink(pdeviceHead);
  797. 	pdeviceHead = addDHT11ToDeviceLink(pdeviceHead);
  798. 	pdeviceHead = addcameraToDeviceLink(pdeviceHead);//摄像头
  799. 	pdeviceHead = addShakeToDeviceLink(pdeviceHead);//震动模块
  800. 	pdeviceHead = addwindowToDeviceLink(pdeviceHead);
  801. 	
  802.  
  803. 	//3.线程池建立
  804. 	//int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)(void*), void *arg)
  805. 		//3.1 语音线程
  806. 	pthread_create(&voiceThread, NULL, voice_thread, NULL);
  807.  
  808. 		//3.2 socket线程
  809. 	pthread_create(&socketThread, NULL, socket_thread, NULL);
  810.  
  811. 		//3.3火灾线程
  812. 	pthread_create(&fireThread, NULL, fire_thread, NULL);     
  813.  
  814. 		//3.4 摄像头线程  这里把摄像头设为了开机自启 
  815.  
  816. 		//3.5 温湿度线程
  817. 	pthread_create(&DHT11Thread, NULL, DHT11_thread, NULL);
  818.  
  819. 		//3.6 震动线程
  820. 	pthread_create(&shakeThread, NULL, shake_thread, NULL);
  821.  
  822. 		//3.7 窗户线程
  823. 	pthread_create(&windowThread, NULL, window_thread, NULL);
  824. 		//3.8 按钮线程
  825. 	pthread_create(&keyThread, NULL, key_thread, NULL);
  826.  
  827. 		//3.9 433m线程
  828. 	pthread_create(&remoteThread, NULL, remote_thread, NULL);	
  829. 	
  830.  
  831.  
  832. 	pthread_join(voiceThread, NULL);
  833. 	pthread_join(socketThread, NULL);
  834. 	pthread_join(fireThread, NULL);
  835. 	pthread_join(DHT11Thread, NULL);
  836. 	pthread_join(writeThread, NULL);
  837. 	pthread_join(shakeThread, NULL);
  838. 	pthread_join(windowThread, NULL);
  839. 	pthread_join(keyThread, NULL);
  840. 	pthread_join(cameraThread, NULL);
  841. 	pthread_join(remoteThread, NULL);
  842. 	return 0;
  843. }

contrlDevices.h

  1. #include<stdlib.h>
  2. #include<wiringPi.h>
  3. #include <curl/curl.h>
  4. typedef unsigned int bool;
  5.  
  6. struct Devices
  7. {
  8. 	char deviceName[128];	//
  9. 	int status;		//状态 : 开/关
  10. 	int pinNum;
  11. 	
  12. 	int (*open)(int pinNum);
  13.  
  14. 	
  15. 	int (*close)(int pinNum);
  16.  
  17. 	
  18. 	int (*deviceInit)(int pinNum);
  19. 	
  20. 	int (*readStatus)(int pinNum);
  21. 	int (*changeStatus)(int status);
  22.  
  23.  
  24. 	//摄像头相关的
  25. 	void (*justDoOnce)();
  26. 		char* (*getFace)(); 
  27. 		char* (*getPicFromOCRBase64)(); 
  28. 		size_t (*readData)(); 
  29.  
  30. 	struct Devices *next;
  31. };
  32. struct Devices* addBathroomLightToDeviceLink(struct Devices *phead);
  33. struct Devices* addUpstairLightToDeviceLink(struct Devices *phead);
  34. struct Devices* addRestauranLightToDeviceLink(struct Devices *phead);
  35. struct Devices* addLivingRoomLightToDeviceLink(struct Devices *phead);
  36. struct Devices* addfireToDeviceLink(struct Devices *phead);
  37.  
  38. struct Devices* addfanToDeviceLink(struct Devices *phead);
  39. struct Devices* addDHT11ToDeviceLink(struct Devices *phead);
  40. struct Devices *addShakeToDeviceLink(struct Devices *phead);
  41. struct Devices* addbuzzerToDeviceLink(struct Devices *phead);//火灾蜂鸣器
  42.  
  43. struct Devices* addshakebuzzerToDeviceLink(struct Devices *phead);//震动蜂鸣器
  44.  
  45. struct Devices* addwindowToDeviceLink(struct Devices *phead);
  46.  
  47. struct Devices *addcameraToDeviceLink(struct Devices *phead);//摄像头结点

InputCommand.h

  1. #include<stdlib.h>
  2. #include<wiringPi.h>
  3.  
  4.  
  5. struct InputCommander		//
  6. {
  7. 	char commandName[128];//名字
  8. 	char deviceName[128];//设备名
  9. 	char command[32];		//指令
  10. 	int (*Init)(struct InputCommander *voicer, char *ipAdress, char *port);//操作函数 : 串口号 ip 端口号 
  11. 	int (*getCommand)(struct InputCommander *voicer);//
  12. 	char log[1024];		//日志
  13. 	int fd;
  14. 	char port[12];//端口号
  15. 	char ipAddress[32];//ip地址
  16. 	int sfd;
  17. 	struct InputCommander *next; 
  18. };
  19.  
  20. struct InputCommander* addvoiceContrlToInputCommandLink(struct InputCommander *phead);
  21. struct InputCommander* addSocketContrlToInputCommandLink(struct InputCommander *phead);

bathroomLight.c（四个房间小灯,风扇代码基本相似，这里只展示其中一个）

  1. #include"contrlDevices.h"
  2. #include<stdlib.h>
  3. #include<fcntl.h>
  4.  
  5. int bathroomLightOpen(int pinNum)
  6. {
  7. 	digitalWrite(pinNum,LOW);
  8.  
  9. }
  10. int bathroomLightClose(int pinNum)
  11. {
  12. 	digitalWrite(pinNum,HIGH);
  13.  
  14. }
  15.  
  16. int bathroomLightCloseInit(int pinNum)
  17. {
  18. 	pinMode(pinNum,OUTPUT);
  19. 	digitalWrite(pinNum,HIGH);
  20.  
  21. }
  22.  
  23. int bathroomLightCloseStatus(int status)
  24. {
  25.  
  26. }
  27.  
  28. struct Devices bathroomLight = {		//这里是在定义的同时赋值
  29. 	.deviceName = "bathroomLight",
  30. 	.pinNum = 22,
  31. 	.open = bathroomLightOpen,
  32. 	.close = bathroomLightClose,
  33. 	.deviceInit = bathroomLightCloseInit,
  34. 	.changeStatus = bathroomLightCloseStatus
  35. };
  36.  
  37. struct Devices* addBathroomLightToDeviceLink(struct Devices *phead)
  38. {
  39. 	if(phead == NULL){
  40. 		return &bathroomLight;
  41. 	}
  42. 	else{
  43. 		bathroomLight.next = phead;
  44. 		phead = &bathroomLight;
  45. 		return phead;
  46. 	}
  47. }

 window.c

  1. #include"contrlDevices.h"
  2. #include<stdlib.h>
  3. #include<fcntl.h>
  4.  
  5. int windowOpen(int pinNum)
  6. {
  7. 	digitalWrite(2,LOW);
  8. 	digitalWrite(3,HIGH);
  9.  
  10. }
  11. int windowClose(int pinNum)
  12. {
  13. 	digitalWrite(2,HIGH);
  14. 	digitalWrite(3,LOW);
  15. }
  16.  
  17. int windowCloseInit(int pinNum)//用的L9110电机实现正反转，所以要初始化两个引脚
  18. {
  19. 	pinMode(2,OUTPUT);
  20. 	pinMode(3,OUTPUT);
  21. 	digitalWrite(2,LOW);
  22. 	digitalWrite(3,LOW);//2和3都配置为低电平 默认不转
  23.  
  24. 	pinMode(4,OUTPUT);
  25. 	digitalWrite(4,HIGH);
  26. 	
  27. 	pinMode(0,OUTPUT);			//门锁初始化	
  28. 	digitalWrite(0,HIGH);
  29. }
  30.  
  31. int windowCloseStatus(int status)
  32. {
  33. 	
  34. }
  35.  
  36. struct Devices window = {	
  37. 	.deviceName = "window",
  38. 	.pinNum = 2,
  39. 	.open = windowOpen,
  40. 	.close = windowClose,
  41. 	.deviceInit = windowCloseInit,
  42. 	.changeStatus = windowCloseStatus
  43. };
  44.  
  45. struct Devices* addwindowToDeviceLink(struct Devices *phead)
  46. {
  47. 	if(phead == NULL){
  48. 		return &window;
  49. 	}
  50. 	else{
  51. 		window.next = phead;
  52. 		phead = &window;
  53. 		return phead;
  54. 	}
  55. }

DHT11.c

  1. #include"contrlDevices.h"
  2. #include<stdlib.h>
  3. #include<fcntl.h>
  4. #include <stdio.h>
  5. #include <string.h>
  6. #include <unistd.h>
  7. #include <stdint.h>
  8.  
  9. typedef unsigned char uint8;
  10. typedef unsigned int  uint16;
  11. typedef unsigned long uint32;
  12.  
  13. #define HIGH_TIME 32
  14.  
  15. int pinNumber = 7;
  16. uint32 databuf;
  17.  
  18.  
  19. int DHT11CloseInit(int pinNum)
  20. {
  21. 	uint8 crc; 
  22.     uint8 i;
  23.   
  24.     pinMode(pinNumber, OUTPUT); // set mode to output
  25.     digitalWrite(pinNumber, 0); // output a high level 
  26.     delay(25);
  27.     digitalWrite(pinNumber, 1); // output a low level 
  28.     pinMode(pinNumber, INPUT); // set mode to input
  29.     pullUpDnControl(pinNumber, PUD_UP);
  30.  
  31.     delayMicroseconds(27);
  32.     if (digitalRead(pinNumber) == 0) //SENSOR ANS
  33.     {
  34.         while (!digitalRead(pinNumber))
  35.             ; //wait to high
  36.  
  37.         for (i = 0; i < 32; i++)
  38.         {
  39.             while (digitalRead(pinNumber))
  40.                 ; //data clock start
  41.             while (!digitalRead(pinNumber))
  42.                 ; //data start
  43.             delayMicroseconds(HIGH_TIME);
  44.             databuf *= 2;
  45.             if (digitalRead(pinNumber) == 1) //1
  46.             {
  47.                 databuf++;
  48.             }
  49.         }
  50.  
  51.         for (i = 0; i < 8; i++)
  52.         {
  53.             while (digitalRead(pinNumber))
  54.                 ; //data clock start
  55.             while (!digitalRead(pinNumber))
  56.                 ; //data start
  57.             delayMicroseconds(HIGH_TIME);
  58.             crc *= 2;  
  59.             if (digitalRead(pinNumber) == 1) //1
  60.             {
  61.                 crc++;
  62.             }
  63.         }
  64.         return 1;
  65.     }
  66.     else
  67.     {
  68.         return 0;
  69.     }
  70. }
  71.  
  72. int DHT11Open(int pinNum)
  73. {
  74.  
  75. }
  76. int DHT11Close(int pinNum)
  77. {
  78.  
  79. }
  80.  
  81. int DHT11CloseStatus(int status)
  82. {
  83. 	
  84. }
  85. struct Devices DHT11 = {		//这里是在定义的同时赋值
  86. 	.deviceName = "DHT11",
  87. 	.pinNum = 7,
  88. 	.open = DHT11Open,
  89. 	.close = DHT11Close,
  90. 	.deviceInit = DHT11CloseInit,
  91. 	.changeStatus = DHT11CloseStatus
  92. };
  93.  
  94. struct Devices* addDHT11ToDeviceLink(struct Devices *phead)
  95. {
  96. 	if(phead == NULL){
  97. 		return &DHT11;
  98. 	}
  99. 	else{
  100. 		DHT11.next = phead;
  101. 		phead = &DHT11;
  102. 		return phead;
  103. 	}
  104. }

voiceContrl.c

  1. #include<unistd.h>
  2. #include<wiringPi.h>
  3. #include<stdlib.h>
  4. #include<stdio.h>
  5. #include<string.h>
  6.  
  7. #include<wiringSerial.h>
  8. #include"InputCommand.h"
  9.  
  10. int voiceGetCommand(struct InputCommander *voicer)
  11. {
  12. 	int nread = 0;
  13. 	memset(voicer->command, '\0', sizeof(voicer->command));
  14. 	nread = read(voicer->fd, voicer->command, sizeof(voicer->command));
  15. 	if(nread == 0){
  16. 		printf("voice no datas\n");
  17. 	}else{
  18. 		return nread;
  19. 	}
  20. 	
  21. }
  22.  
  23. int voiceInit(struct InputCommander *voicer, char *ipAdress, char *port)
  24. {
  25. 	int fd;
  26. 	if((fd = serialOpen("/dev/ttyAMA0",9600))==-1)//初始化串口，波特率9600
  27. 	{
  28. 		printf("voice init error\n");
  29. 		exit(-1);
  30. 	}
  31. 	voicer->fd = fd;
  32. 	return fd;
  33.  
  34. }
  35.  
  36. struct InputCommander voiceContrl = {
  37. 	.commandName = "voice",
  38. 	.deviceName = "/dev/ttyAMA0",//设备名
  39. 	.command = {'\0'},			//指令
  40. 	.Init = voiceInit,//串口初始化
  41. 	.getCommand = voiceGetCommand,
  42. 	.log = {'\0'},
  43. 	.next = NULL
  44.  
  45. };
  46.  
  47. struct InputCommander* addvoiceContrlToInputCommandLink(struct InputCommander *phead)
  48. {
  49. 	if(phead == NULL){
  50. 	return &voiceContrl;
  51. 	}
  52. 	else{
  53. 		voiceContrl.next = phead;
  54. 		phead = &voiceContrl;
  55. 		return phead;
  56. 	}
  57. }

socketContrl.c

  1. #include<unistd.h>
  2. #include<wiringPi.h>
  3. #include<stdlib.h>
  4. #include<stdio.h>
  5. #include<wiringSerial.h>
  6. #include <sys/types.h>
  7. #include <sys/socket.h>
  8. #include <arpa/inet.h>
  9. #include <netinet/in.h>
  10. #include <string.h>
  11.  
  12. #include"InputCommand.h"
  13.  
  14. int socketGetCommand(struct InputCommander *socketMes)
  15. {
  16. 	int c_fd;
  17. 	int n_read = 0;
  18. 	struct sockaddr_in c_addr;
  19. 	memset(&c_addr, 0, sizeof(struct sockaddr_in));
  20. 	int clen = sizeof(struct sockaddr_in);
  21. 	//4. accept
  22. 	c_fd = accept(socketMes->sfd, (struct sockaddr *)&c_addr, &clen);
  23. 	
  24. 	n_read = read(c_fd, socketMes->command, sizeof(socketMes->command));
  25. 	 
  26. 	if(n_read == -1){
  27. 		perror("read");
  28. 	}else if(n_read > 0){
  29. 		printf("\nget: %d\n",n_read);
  30. 	}else{
  31. 		printf("client quit\n");
  32. 	}
  33. 	return n_read;
  34. 	
  35. }
  36.  
  37. int socketInit(struct InputCommander *socketMes, char *ipAdress, char *port)
  38. {
  39. 	int s_fd;
  40. 	
  41.     struct sockaddr_in s_addr;
  42.  
  43.     memset(&s_addr, 0, sizeof(struct sockaddr_in));
  44. 	
  45. 	//1.socket
  46.     s_fd = socket(AF_INET, SOCK_STREAM, 0);
  47.     if (s_fd == -1)
  48.     {
  49.         perror("socket");
  50.         exit(-1);
  51.     }
  52. 	
  53. 	 s_addr.sin_family = AF_INET;
  54. 	 s_addr.sin_port = htons(atoi(socketMes->port)); //atoi()把ascii转成整形数
  55. 	                                         //htons()返回网络字节序的值(大段字节序)
  56. 	 inet_aton(socketMes->ipAddress, &(s_addr.sin_addr)); //aton()把字符串形式的IP转换成网络能识别的格式  
  57.  
  58. 	//解决服务器程序结束后端口被占用的情况
  59. 	int opt = 1;
  60. 	setsockopt(s_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
  61. 	 
  62. 	//2.bind
  63. 	bind(s_fd, (struct sockaddr *)&s_addr, sizeof(struct sockaddr_in));
  64.  
  65. 	//3.listen
  66. 	listen(s_fd, 10);
  67. 	printf("socket server listening...\n");
  68. 	socketMes->sfd = s_fd;
  69. 	return s_fd;
  70. 	
  71. 	
  72. }
  73.  
  74. struct InputCommander socketContrl = {
  75. 	.commandName = "socketServer",
  76. 	.command = {'\0'},			//指令
  77. 	.port = "8083",
  78. 	.ipAddress = "192.168.101.223",
  79. 	.Init = socketInit,//初始化
  80. 	.getCommand = socketGetCommand,
  81. 	.log = {'\0'},
  82. 	.next = NULL
  83.  
  84. };
  85.  
  86. struct InputCommander* addSocketContrlToInputCommandLink(struct InputCommander *phead)
  87. {
  88. 	if(phead == NULL){
  89. 	return &socketContrl;
  90. 	}
  91. 	else{
  92. 		socketContrl.next = phead;
  93. 		phead = &socketContrl;
  94. 		return phead;
  95. 	}
  96.  
  97. }

Camera.c

  1. #include "contrlDevices.h"
  2. #include <stdio.h>
  3. #include <unistd.h>
  4. #include <string.h>
  5. #include <stdlib.h>
  6. #include <curl/curl.h>
  7. #include <sys/types.h>
  8. #include <sys/stat.h>
  9. #include <fcntl.h>
  10. #include <sys/types.h>
  11. #include <unistd.h>
  12.  
  13. #define door_lock 0 //门锁
  14.  
  15. void postUrl();
  16. size_t readData1(void *ptr, size_t size, size_t nmemb, void *stream);
  17. char* getFace1();
  18. char* getPicFromOCRBase641(char *Filepath);
  19. struct Devices* addcameraToDeviceLink(struct Devices *phead);
  20. int cameraInit(int pinNum);
  21.  
  22.  
  23. char ocrRetBuf[1024] = {'\0'};
  24.  
  25. size_t readData1(void *ptr, size_t size, size_t nmemb, void *stream)
  26. //回调函数，把从后台的数据拷贝给ocrRetBuf
  27. {
  28.         strncpy(ocrRetBuf,ptr,1024);//ocrRetBuf接收从OCR后台返回的数据,并打印
  29. 		 printf("%s\n",ocrRetBuf);
  30. }
  31.  
  32. char* getFace1()
  33. {
  34. 	printf("pai zhao zhong\n");
  35. 	//system("raspistill -q 5 -t 1 -o image.jpg");
  36. 	system("wget  http://192.168.101.223:8080/?action=snapshot -O ./image.jpg ");
  37. 	while(access("./image.jpg",F_OK) != 0); //判断是否拍照完毕
  38. 	
  39. 	printf("paizhao wanbi\n");
  40. 	
  41. 	char* base64BufFaceRec = getPicFromOCRBase641("./image.jpg");
  42. 	//system("rm image.jpg");
  43. 	
  44. 	return base64BufFaceRec;   //返回刚才拍照的base64
  45. }
  46.  
  47. char *getPicFromOCRBase641(char *Filepath)
  48. {
  49.         int fd;
  50.         int filelen;
  51.         char cmd[128]={'\0'};
  52.  
  53.         sprintf(cmd,"base64 %s > tmpFile",Filepath);
  54.         system(cmd);
  55.  
  56.         fd=open("./tmpFile",O_RDWR);
  57.         filelen=lseek(fd,0,SEEK_END);//计算文件大小
  58.         lseek(fd,0,SEEK_SET);        //移动光标到头
  59.  
  60.         char *bufpic=(char *)malloc(filelen+2);
  61.         memset(bufpic,'\0',filelen+2);
  62.         read(fd,bufpic,filelen+128);    //把内容读到bufpic内
  63.  
  64.         system("rm -rf tmpFile");//删除这个临时文件
  65.         close(fd);
  66.  
  67.  
  68.         return bufpic; //返回bufpic这个地址
  69.  
  70. }
  71.  
  72. void postUrl()
  73. {
  74.         CURL *curl;
  75.         CURLcode res;
  76.  
  77.         char* key    = "5xxxsWxxxGfP2pmxxxchSJ";	//翔云平台购买人脸识别后的key
  78.         char* secret = "396xxxd33xxx487exxxf139axxx6d789";	//翔云平台购买人脸识别后的secret
  79.         int   typeId = 21;	
  80.         char* format = "xml";
  81.  
  82.         char* base64BufPic1 = getFace1();
  83.  
  84.         char* base64BufPic2 = getPicFromOCRBase641("lit1.jpg");
  85.  
  86.         int len = strlen(key)+strlen(secret)+strlen(base64BufPic1)+strlen(base64BufPic2)+128;
  87.         char* postString = (char* )malloc(len);
  88.         memset(postString,'\0',len);
  89.         sprintf(postString,"img1=%s&img2=%s&key=%s&secret=%s&typeId=%d&format=%s",base64BufPic1,base64BufPic2,key,secret,typeId,format);//根据平台的传参格式编写
  90.  
  91.         curl = curl_easy_init();
  92.  
  93.         if(curl){
  94.                 curl_easy_setopt(curl, CURLOPT_POSTFIELDS, postString);  //指定post内容，传入参数  
  95.                 curl_easy_setopt(curl, CURLOPT_URL, "https://netocr.com/api/faceliu.do");// 指定url
  96.                 curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION,readData1);  //回调函数readDate读取返回值
  97.                 res = curl_easy_perform(curl);          
  98.                 printf("OK:%d\n",res);
  99.  
  100.                 if(strstr(ocrRetBuf,"是") != NULL){    //判断翔云后台返回的字符串中有没有“是”
  101.                         printf("the same person\n");
  102. 						digitalWrite(door_lock, LOW);  //打开门锁
  103.             			delay(3000);                   //等待3s
  104.             			digitalWrite(door_lock, HIGH); //关闭门锁
  105.                 }
  106.                 else{
  107.                         printf("different person\n");
  108.                 }
  109.                 curl_easy_cleanup(curl);
  110.         }
  111.  
  112. }
  113.  
  114. int cameraInit(int pinNum)//该函数无用
  115. {
  116. 	pinMode(0,OUTPUT);				
  117. 	digitalWrite(0,HIGH);
  118. }
  119.  
  120. struct Devices camera = {
  121.  
  122. 	.deviceName = "camera",
  123. 	.deviceInit = cameraInit,
  124. 	.pinNum = 0,             //此引脚号无用
  125. 	.justDoOnce = postUrl,
  126. 	.getFace = getFace1,
  127. 	.getPicFromOCRBase64 = getPicFromOCRBase641,
  128. 	.readData = readData1
  129.  
  130. };
  131.  
  132. struct Devices* addcameraToDeviceLink(struct Devices *phead)
  133. {
  134. 	if(phead == NULL){
  135. 		return &camera;
  136. 	}
  137. 	else{
  138. 		camera.next = phead;
  139. 		phead = &camera;
  140. 	}
  141. }

其余代码和上面展示的有些很类似，就不放出了。

四.项目总结

        1.做完后感觉不是很难，主要是要明白这个项目代码的设计结构和里面的一些逻辑。

        2.人脸识别功能的整合是这个项目相对复杂的地方，这里我也参考了其他博客。

        3.前面学到的编写树莓派驱动代码，各种库的使用是重点，以后也会复习。

        4.火焰和震动传感器可以同时只使用一个蜂鸣器，风扇有时会出现一些小bug,代码还有优化的地方。

声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号