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

基于树莓派的智能家居项目及代码_树莓派项目

作者：码创造者 | 2024-07-28 08:51:18

赞

踩

树莓派项目

一、功能介绍

基于树莓派的智能家居。智能家居用到的硬件有：树莓派3B+、SU-03语音识别模块、pi 摄像头、继电器组、小灯、火焰传感器、蜂鸣器、电磁锁、超声波测距模块、DHT11温湿度检测模块，433M射频编解码模块或者红外模块，面包板等。
采用了简单工厂模式的一个设计方式。稳定，拓展性更强。通过工厂创建一个通用的接口，集中管理设备和指令。

创建了两个工厂：设备工厂和指令工厂。

设备工厂：用于管理卧室灯，餐厅灯，楼梯灯，浴室灯，火焰传感器，蜂鸣器，电磁锁，超声波，摄像头等设备。初始化的时候，通过链表将各个模块连接起来（头插法）。在要使用某个模块时，只需要使用链表遍历，找到所需模块去调用功能。

指令工厂：管理串口输入输出和socket客户端的指令输入和输出。


具体功能如下：
1、可通过SU-03语音模块的口令模式，口令＋具体控制，通过串口把控制指令传给树莓派，来控制客厅、餐厅、二楼、浴室的灯

2、可通过SU-03语音模块的口令模式，通过串口把控制指令传给树莓派，树莓派再传递给射频模块（或者红外模块）控制窗帘，泳池灯，空调等。
3、可以通过socket客户端来发指令来控制客厅、餐厅、二楼、浴室的灯，可以在socket客户端看到摄像头实时监控画面，并且可以在客户端实时看到温度，湿度，火灾检测等数据。
4、火灾报警，当火焰传感器检测到火焰的时候，蜂鸣器会报警。
5、视频监控采用开源mjpg-Streamer来实现的，设置摄像头开机自启动，监控画面可在http://192.168.1.3:8080/?action=stream去看到
6、人脸识别开锁和监控，人脸识别功能是使用的翔云平台的人脸识别解决方案，需要安装libcurl 和 openSSl库来支持https协议，通过系统调用wget   http://192.168.1.3:8080/?action=snapshot获取；

二、设计框图

三、程序实现

InputCommand.h:指令工厂

  1. #include <stdlib.h>
  2. #include <stdio.h>
  3. #include <unistd.h>
  4. #include <string.h>
  5. #include <wiringPi.h>
  6.  
  7. struct InputCommander
  8. {
  9.   char commandName[128];
  10.   char deviceName[128];//打开的设备名称
  11.   char command[32];//获取指令
  12.   char log[1024];
  13.   int baud;//波特率
  14.   int fd;
  15.   int s_fd;
  16.   char port[12];//端口号
  17.   char ipAddress[32];//ip地址
  18.   char temp[12];
  19.   char hum[12];
  20.   char fireIfOrNot[32];
  21.   int (*Init)(struct InputCommander *pInputCommand);
  22.   int (*getCommand)(struct InputCommander *pInputCommand);
  23.   int (*sendCommand)(struct InputCommander *pInputCommand);
  24.   struct InputCommander *next;
  25. };
  26.  
  27. struct InputCommander * addSocketContrlToInputCommand(struct InputCommander * phead);
  28. struct InputCommander * addVoiceContrlToInputCommand(struct InputCommander * phead);
  29.

contrlDevices.h(设备工厂）：

  1. #include <wiringPi.h>
  2.  
  3. struct Devices
  4. {
  5.   char deviceName[128];
  6.   int status;
  7.   int pinNum;
  8.  
  9.   int (*open)(int pinNum);
  10.   int (*close)(int pinNum);
  11.   int (*deviceInit)(int pinNum);
  12.  
  13.   int (*readStatus)(int pinNum);
  14.   int (*changeStatus)(int pinNum);
  15.  
  16.   struct Devices *next;
  17. };
  18.  
  19. struct Devices * addBathroomLightToDeviceLink(struct Devices *phead);
  20. struct Devices * addLivingroomLightToDeviceLink(struct Devices *phead);
  21. struct Devices * addUpstairLightToDeviceLink(struct Devices *phead);
  22. struct Devices * addRestaurantLightToDeviceLink(struct Devices *phead);
  23. struct Devices * addFireIfOrNotToDeviceLink(struct Devices *phead);
  24. struct Devices * addAlertToDeviceLink(struct Devices *phead);
  25. struct Devices * addLockToDeviceLink(struct Devices *phead);
  26. struct Devices * addCameraToDeviceLink(struct Devices *phead);
  27. struct Devices * addCsbToDeviceLink(struct Devices *phead);
  28. struct Devices * addDht11ToDeviceLink(struct Devices *phead);

socketContrl.c

  1. #include "InputCommand.h"
  2. #include <wiringSerial.h>
  3. #include <stdio.h>
  4. #include <sys/types.h>      
  5. #include <sys/socket.h>
  6. #include <netinet/in.h>
  7. #include <arpa/inet.h>
  8. #include <stdlib.h>
  9. #include <string.h>
  10.  
  11. int socketInit(struct InputCommander *socketMes)
  12. {
  13.   int s_fd;
  14.   struct sockaddr_in s_addr;
  15.   memset(&s_addr,0,sizeof(struct sockaddr_in));
  16.   //1. socket
  17.   s_fd = socket(AF_INET, SOCK_STREAM, 0);
  18. 	if(s_fd == -1){
  19. 		perror("socket");
  20. 		exit(-1);
  21. 	}
  22.   s_addr.sin_family = AF_INET;
  23. 	s_addr.sin_port = htons(atoi(socketMes->port));
  24. 	inet_aton(socketMes->ipAddress,&s_addr.sin_addr);
  25. 	//2. bind
  26. 	bind(s_fd,(struct sockaddr *)&s_addr,sizeof(struct sockaddr_in));
  27.   //3. listen
  28. 	listen(s_fd,20);
  29.   printf("socket server listening...\n");
  30.   socketMes->s_fd = s_fd;
  31. 	return s_fd;
  32. }
  33.  
  34.  
  35. struct InputCommander socketContrl={
  36.   .commandName = "socketServer",
  37.   .command={'\0'},
  38.   .port="8888",
  39.   .ipAddress="192.168.1.3",
  40.   .log={'\0',},
  41.   .Init =socketInit,
  42.   .temp={'\0'},
  43.   .hum={'\0'},
  44.   .fireIfOrNot={'\0'}
  45.  
  46. };
  47.  
  48. struct InputCommander * addSocketContrlToInputCommand(struct InputCommander * phead)
  49. {
  50.   if(phead ==NULL){
  51.     return &socketContrl;
  52.   }else{
  53.     socketContrl.next = phead;
  54.     return &socketContrl;
  55.   }
  56. }

voiceContrl.c

  1. #include "InputCommand.h"
  2. #include <wiringSerial.h>
  3. #include <unistd.h>
  4. #include <string.h>
  5. #include <stdlib.h>
  6. #include <stdio.h>
  7. #define SIZE 7
  8.  
  9. char Light_ON[7]={0xFD,0x03,0x55,0x55,0xC0,0x73,0xDF};
  10. char Light_OFF[7]={0xFD,0x03,0x55,0x55,0x30,0x73,0xDF};
  11. char CUR_ON[7]={0xFD,0x03,0x55,0x55,0x0C,0x73,0xDF};
  12. char CUR_OFF[7]={0xFD,0x03,0x55,0x55,0x03,0x73,0xDF};
  13.  
  14. int voiceGetCommand(struct InputCommander *voicer)
  15. {
  16.     int nread=0;
  17.     memset(voicer->command,'\0',sizeof(voicer->command));
  18.     nread=read(voicer->fd,voicer->command,sizeof(voicer->command));
  19.     return nread;
  20. }
  21. int voiceInit(struct InputCommander *voicer)
  22. {
  23.   int fd;
  24.   if((fd =serialOpen(voicer->deviceName,voicer->baud))==-1){
  25.     perror("serial open error\n");
  26.     exit(-1);
  27.   }
  28.   voicer->fd = fd;
  29.   return fd;
  30. }
  31. int voiceSendCommand(struct InputCommander *voicer)
  32. {
  33.   int n_write=0;
  34.   if(!strcmp(voicer->command,"s o")){
  35.      n_write=write(voicer->fd,Light_ON,7);
  36.      
  37.   }else if(!strcmp(voicer->command,"s c")){
  38.      n_write=write(voicer->fd,Light_OFF,7);
  39.    
  40.   }else if(!strcmp(voicer->command,"c o")){  
  41.      n_write=write(voicer->fd,CUR_ON,7);
  42.  
  43.   }else if(!strcmp(voicer->command,"c c")){
  44.      n_write=write(voicer->fd,CUR_OFF,7);
  45.       
  46.   }
  47.   return n_write;
  48. }
  49.  
  50. struct InputCommander voiceContrl={
  51.   .commandName = "voice",
  52.   .deviceName="/dev/ttyAMA0",
  53.   .baud=9600,
  54.   .command={'\0'},//指令清零
  55.   .log={'\0'},
  56.   .Init =voiceInit,
  57.   .getCommand = voiceGetCommand,
  58.   .sendCommand= voiceSendCommand,
  59.   .next =NULL
  60. };
  61.  
  62. struct InputCommander * addVoiceContrlToInputCommand(struct InputCommander * phead)
  63. {
  64.   if(phead ==NULL){
  65.     return &voiceContrl;
  66.   }else{
  67.     voiceContrl.next = phead;
  68.     return &voiceContrl;
  69.   }
  70. }

bathroomLight.c: livingroomLight.c,restaurantLight.c,upstairLight.c同

  1. #include "contrlDevices.h"
  2. #include <stdlib.h>
  3.  
  4. int bathroomLightOpen(int pinNum)
  5. {
  6.   digitalWrite(pinNum,LOW);
  7. }
  8. int bathroomLightClose(int pinNum)
  9. {
  10.   digitalWrite(pinNum,HIGH);
  11. }
  12.  int bathroomLightInitCloseInit(int pinNum)
  13.  {
  14.     pinMode(pinNum,OUTPUT);
  15.     digitalWrite(pinNum,HIGH);
  16.  }
  17.  
  18. struct Devices bathroomLight=
  19. {
  20.   .deviceName="bathroomLight",
  21.   .pinNum=21,
  22.   .open = bathroomLightOpen,
  23.   .close =bathroomLightClose,
  24.   .deviceInit=bathroomLightInitCloseInit,
  25. };
  26.  
  27. struct Devices * addBathroomLightToDeviceLink(struct Devices *phead)
  28. {
  29.   if(phead == NULL){
  30.     return &bathroomLight;
  31.   }else{
  32.     bathroomLight.next=phead;
  33.     return &bathroomLight;
  34.   }
  35. }

lock.c

  1. #include "contrlDevices.h"
  2. #include <stdlib.h>
  3.  
  4. int lockOpen(int pinNum)
  5. {
  6.   pinMode(pinNum,OUTPUT);
  7.   //通电开锁，断电关锁；
  8.   digitalWrite(pinNum,HIGH);
  9.   digitalWrite(pinNum,LOW);
  10. }
  11. int lockClose(int pinNum)
  12. {
  13.   pinMode(pinNum,OUTPUT);
  14.   digitalWrite(pinNum,LOW);
  15. }
  16.  int lockInit(int pinNum)
  17.  {
  18.     pinMode(pinNum,OUTPUT);
  19.     digitalWrite(pinNum,LOW);
  20.  }
  21. int lockReadStatus(int pinNum)
  22. {
  23.     //高电平开，低电平为关
  24.   return digitalRead(pinNum);
  25. }
  26. struct Devices lock=
  27. {
  28.   .deviceName="lock",
  29.   .pinNum=29,
  30.   .open = lockOpen,
  31.   .close =lockClose,
  32.   .deviceInit=lockInit,
  33.   .readStatus=lockReadStatus
  34. };
  35.  
  36. struct Devices * addLockToDeviceLink(struct Devices *phead)
  37. {
  38.   if(phead == NULL){
  39.     return &lock;
  40.   }else{
  41.     lock.next=phead;
  42.     return &lock;
  43.   }
  44. }

fire.c

  1. #include "contrlDevices.h"
  2. #include <stdlib.h>
  3. #include <unistd.h>
  4.  
  5.  int fireIfOrNotInit(int pinNum)
  6.  {
  7.     pinMode(pinNum,INPUT);
  8.     digitalWrite(pinNum,HIGH);
  9.  }
  10. int fireStatusRead(int pinNum)
  11. {
  12.   return digitalRead(pinNum);
  13.   //低电平为有火灾，高电平为无火灾
  14. }
  15.  
  16. struct Devices fireIfOrNot=
  17. {
  18.   .deviceName="fireIfOrNot",
  19.   .pinNum=25,
  20.   .deviceInit=fireIfOrNotInit,
  21.   .readStatus=fireStatusRead,
  22. };
  23.  
  24. struct Devices * addFireIfOrNotToDeviceLink(struct Devices *phead)
  25. {
  26.   if(phead == NULL){
  27.     return &fireIfOrNot;
  28.   }else{
  29.     fireIfOrNot.next=phead;
  30.     return &fireIfOrNot;
  31.   }
  32. }

csb.c

  1. #include "contrlDevices.h"
  2. #include <stdlib.h>
  3. #include <stdio.h>
  4. #include <sys/time.h>
  5.  
  6. #define Trig 27
  7. #define Echo 28
  8.  
  9.  int csbInit(int pinNum)
  10.  {
  11.     pinMode(Trig,OUTPUT);
  12.     pinMode(Echo,INPUT);
  13.  }
  14. int getDistance(int pinNum)
  15. {
  16.   //测量距离：2-400cm;
  17.    struct timeval tv1;  //timeval是time.h中的预定义结构体 其中包含两个一个是秒，一个是微秒
  18.  
  19.     struct timeval tv2;
  20.     long start, stop;
  21.     float dis;
  22.  
  23.         digitalWrite(Trig, LOW);
  24.         delayMicroseconds(2);
  25.  
  26.         digitalWrite(Trig, HIGH);
  27.         delayMicroseconds(10);      //发出超声波脉冲
  28.         digitalWrite(Trig, LOW);
  29.  
  30.         while(digitalRead(Echo) != 1);
  31.  
  32.         gettimeofday(&tv1, NULL);           //获取当前时间 开始接收到返回信号的时候
  33.  
  34.         while(digitalRead(Echo) != 0);
  35.         gettimeofday(&tv2, NULL);           //获取当前时间  最后接收到返回信号的时候
  36.  
  37.         start = tv1.tv_sec * 1000000 + tv1.tv_usec;   //微秒级的时间
  38.         stop  = tv2.tv_sec * 1000000 + tv2.tv_usec;
  39.  
  40.         dis = (float)(stop - start) / 1000000 * 34000 / 2;  //计算时间差求出距离
  41.         printf("dis=%.2f cm\n",dis);
  42.         if(dis>100){
  43.           return 1;
  44.         }else{
  45.           return 0;
  46.         }
  47.  
  48. }
  49. struct Devices csb=
  50. {
  51.   .deviceName="csb",
  52.   .deviceInit=csbInit,
  53.   .readStatus=getDistance//大于1米,返回1，小于1米 返回0;
  54. };
  55.  
  56. struct Devices * addCsbToDeviceLink(struct Devices *phead)
  57. {
  58.   if(phead == NULL){
  59.     return &csb;
  60.   }else{
  61.     csb.next=phead;
  62.     return &csb;
  63.   }
  64. }

dht11.c

  1. #include "contrlDevices.h"
  2. #include <stdlib.h>
  3. #include <stdio.h>
  4. #include <unistd.h>
  5.  
  6. unsigned long int databuf;
  7.  
  8. int DHT11_start(int pinNum)
  9. {	
  10.   pinMode(pinNum, OUTPUT); // set mode to output
  11. 	digitalWrite(pinNum, HIGH); // output a high level
  12. 	
  13.      sleep(1);
  14. 	pinMode(pinNum, OUTPUT);
  15. 	digitalWrite(pinNum, LOW);
  16. 	
  17. 	delay(25);
  18. 	
  19. 	digitalWrite(pinNum, HIGH);
  20. 	pinMode(pinNum, INPUT);
  21. 	pullUpDnControl(pinNum, PUD_UP);	//当引脚被配置为输入(INPUT)模式，使用函数pullUpDnControl来激活其内部的上拉电阻或下拉电阻
  22. 	
  23. 	delayMicroseconds(27);
  24. 	
  25. 	return 1;
  26. }
  27.  
  28. /*
  29. //主机接受数据
  30. 	1.主机接受到从机回复的响应信号
  31. 	2.格式0——54us的低电平+23到27us的高电平
  32. 	  格式1——54us的低电平+68到74us的高电平
  33. 	3.思路：从识别到低电平开始，然后去除掉掉前面54秒的低电平还有
  34. */
  35. int DHT11_read(int pinNum)
  36. {
  37. 	int crc, i;
  38. 	
  39. 	if (0 == digitalRead(pinNum))			//主机接收到从机发送的响应信号（低电平）
  40. 	{
  41. 		while(!digitalRead(pinNum));		//主机接收到从机发送的响应信号（高电平）
  42. 		
  43. 		for (i = 0; i < 32; i++)
  44. 		{
  45. 			while(digitalRead(pinNum));	//数据位开始的54us低电平
  46. 			while(!digitalRead(pinNum));	//数据位开始的高电平就开始
  47. 			
  48. 			delayMicroseconds(32);			//跳过位数据，32us已经是数据0和数据1的差距点
  49. 			
  50. 			databuf *= 2;
  51. 			
  52. 			if (digitalRead(pinNum) == 1)
  53. 			{
  54. 				databuf++;
  55. 			}
  56. 		}
  57. 		
  58. 		for (i = 0; i < 8; i++)
  59.         {
  60.             while (digitalRead(pinNum));
  61.             while (!digitalRead(pinNum));
  62. 			
  63.             delayMicroseconds(32);
  64. 			
  65.             crc *= 2;  
  66.             if (digitalRead(pinNum) == 1)
  67.             {
  68.                 crc++;
  69.             }
  70.         }
  71. 		return 1;
  72. 	}
  73. 	else
  74. 	{
  75. 		return 0;
  76. 	}
  77. }
  78.  
  79. struct Devices dht11=
  80. {
  81.   .deviceName="dht11",
  82.   .pinNum=0,
  83.   .deviceInit=DHT11_start,
  84.   .readStatus=DHT11_read
  85. };
  86.  
  87. struct Devices * addDht11ToDeviceLink(struct Devices *phead)
  88. {
  89.   if(phead == NULL){
  90.     return &dht11;
  91.   }else{
  92.     dht11.next=phead;
  93.     return &dht11;
  94.   }
  95. }

camera.c

  1. #include "contrlDevices.h"
  2. #include <stdlib.h>
  3. #include <unistd.h>
  4. #include <stdio.h>
  5. #include <curl/curl.h>
  6. #include <string.h>
  7. #include <stdlib.h>
  8. #include <unistd.h>
  9. #include <sys/types.h>
  10. #include <sys/stat.h>
  11. #include <fcntl.h>
  12.  
  13.  
  14. char buf[10240]={'\0'};
  15.  
  16. size_t readData( void *ptr, size_t size, size_t nmemb, void *stream)
  17. {
  18.  
  19.     strncpy(buf,ptr,1024);
  20. }
  21.  
  22. char * base64Img(char *filename)
  23. {
  24.     char cmd[128];
  25.     char *bufPic;
  26.     sprintf(cmd,"base64 %s >tmpFile",filename);
  27.     system(cmd);
  28.  
  29.     int fd = open("./tmpFile",O_RDWR);
  30.     int filesize = lseek(fd,0,SEEK_END);
  31.     lseek(fd,0,SEEK_SET);
  32.     bufPic=(char *)malloc(sizeof(char)*filesize+2);
  33.     memset(bufPic,'\0',filesize+2);
  34.  
  35.     read(fd,bufPic,filesize);
  36.     close(fd);
  37.     system("rm -f tmpFile");
  38.     return bufPic;
  39.  
  40. }
  41. int postUrl(int pinNum)
  42. {
  43.     CURL *curl;
  44.     CURLcode res;
  45.     int status;
  46.     char *postString;
  47.     char *key="PkRgwW5TLdU2kqLDpncZvz";
  48.     char *secret="2977c55e431f487194e5eea44a804328";
  49.     int typeId = 21;
  50.     char *format="xml";
  51.  
  52.     char *img1=base64Img("./person1.jpg");
  53.     char *img2 = base64Img("./person2.jpg");
  54.     int len = strlen(key)+strlen(secret)+strlen(img1)+strlen(img2)+strlen(format);
  55.     postString =(char *)malloc(sizeof(char)*(len+124));
  56.     memset(postString,'\0',len+124);
  57.  
  58.     sprintf(postString,"&img1=%s&img2=%s&key=%s&secret=%s&typeId=%d&format=%s",img1,img2,key,secret,typeId,format);
  59.    
  60.     curl = curl_easy_init();
  61.     
  62. if (curl)
  63.     {
  64.         curl_easy_setopt(curl, CURLOPT_COOKIEFILE, "/tmp/cookie.txt"); // 指>定cookie文件
  65.         curl_easy_setopt(curl, CURLOPT_POSTFIELDS, postString);    // 指定post内容
  66.         curl_easy_setopt(curl, CURLOPT_URL, "https://netocr.com/api/faceliu.do");   // 指定url
  67.         curl_easy_setopt(curl,CURLOPT_WRITEFUNCTION,readData);
  68.         res = curl_easy_perform(curl);
  69.         
  70.         if(strstr(buf,"是")!=NULL){
  71.              printf("camera:same person\n");
  72.             status=1;
  73.         }else{ 
  74.             printf("camera:diff person\n");
  75.             status =0;
  76.         }
  77.         curl_easy_cleanup(curl);
  78.     }
  79.     return status;
  80. }
  81.  
  82. int camera_readStatus(int pinNum)
  83. {
  84.     int status;
  85.     system(" wget -O ./person1.jpg  http://192.168.1.3:8080/?action=snapshot");
  86.     printf("take ptoto success\n");
  87.     status = postUrl(pinNum);
  88.     return status;
  89. }
  90.  
  91.  
  92. struct Devices camera=
  93. {
  94.   .deviceName="camera",
  95.   .readStatus=camera_readStatus//1是同一个人，开锁，0不是同一个人，关锁；
  96. };
  97.  
  98. struct Devices * addCameraToDeviceLink(struct Devices *phead)
  99. {
  100.   if(phead == NULL){
  101.     return &camera;
  102.   }else{
  103.     camera.next=phead;
  104.     return &camera;
  105.   }
  106. }

主程序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 "contrlDevices.h"
  10. #include "InputCommand.h"
  11. #include <wiringSerial.h>
  12.  
  13.  
  14. extern unsigned long int databuf;
  15.  
  16. struct Devices *pdeviceHead = NULL;
  17. struct InputCommander *pCommandHead=NULL;
  18. struct InputCommander *socketHandler;
  19. struct InputCommander *voiceHandler;
  20. struct Devices  *fireHandler;
  21. int c_fd;
  22.  
  23. struct Devices * findDevicesByName(char *str,struct Devices * phead)
  24. {
  25.   struct Devices *tmp = phead;
  26.   if(tmp == NULL){
  27.     printf("find devices error\n");
  28.     return NULL;
  29.   }else{
  30.     while(tmp!=NULL){
  31.       if(!strcmp(tmp->deviceName,str)){
  32.         return tmp;
  33.       }
  34.       tmp=tmp->next;
  35.     }
  36.   }
  37. }
  38. struct InputCommander * findInputCommanderByName(char *str,struct InputCommander * phead)
  39. {
  40.   struct InputCommander *tmp = phead;
  41.   if(tmp == NULL){
  42.     printf("find InputCommander error\n");
  43.     return NULL;
  44.   }else{
  45.     while(tmp!=NULL){
  46.       if(!strcmp(tmp->commandName,str)){
  47.         return tmp;
  48.       }
  49.       tmp=tmp->next;
  50.     }
  51.   }
  52. }
  53.  
  54. void openDevices(char *deviceName)
  55. {
  56.   struct Devices *deviceHandler;
  57.   deviceHandler=findDevicesByName(deviceName,pdeviceHead);
  58.   deviceHandler->deviceInit(deviceHandler->pinNum);
  59.   deviceHandler->open(deviceHandler->pinNum);
  60. }
  61. void closeDevices(char *deviceName)
  62. {
  63.   struct Devices *deviceHandler;
  64.   deviceHandler=findDevicesByName(deviceName,pdeviceHead);
  65.   deviceHandler->deviceInit(deviceHandler->pinNum);
  66.   deviceHandler->close(deviceHandler->pinNum);
  67. }
  68. void cmdContrlLight(char cmd[12])
  69. {
  70.   if(!strcmp(cmd,"b o")){
  71.         openDevices("bathroomLight");
  72.       }else if(!strcmp(cmd,"b c")){
  73.        closeDevices("bathroomLight");
  74.       }else if(!strcmp(cmd,"l o")){
  75.           openDevices("livingroomLight");
  76.       }else if(!strcmp(cmd,"l c")){
  77.           closeDevices("livingroomLight");
  78.       }else if(!strcmp(cmd,"r o")){
  79.           openDevices("restaurantLight");
  80.       }else if(!strcmp(cmd,"r c")){
  81.           closeDevices("restaurantLight");
  82.       }else if(!strcmp(cmd,"u o")){
  83.           openDevices("upstairLight");
  84.       }else if(!strcmp(cmd,"u c")){
  85.           closeDevices("upstairLight");
  86.       }
  87. }
  88.  
  89. void *read_thread(void *datas)
  90. {
  91.   int n_read;
  92.   while(1){
  93.     memset(socketHandler->command,0,sizeof(socketHandler->command));
  94.     n_read = read(c_fd,socketHandler->command, sizeof(socketHandler->command));
  95.  
  96.   if(n_read == -1){
  97. 			perror("read");
  98. 	}else if(n_read>0){
  99. 			printf("socket get cmd: %s\n",socketHandler->command);
  100.               cmdContrlLight(socketHandler->command);
  101. 	  }else{
  102.       printf("client quit\n");
  103.       break;
  104.     }
  105.   } 
  106. }
  107. void *write_thread(void *datas)
  108. {
  109.   struct Devices *dht11Handler;
  110.   int n_write;
  111.   char message[128]={'\0'};
  112.   dht11Handler = findDevicesByName("dht11",pdeviceHead);
  113.    
  114.   while(1){
  115.      
  116.      dht11Handler->deviceInit(dht11Handler->pinNum);
  117.       dht11Handler->readStatus(dht11Handler->pinNum);
  118.       
  119.       memset(socketHandler->hum,'\0',12);
  120.       memset(socketHandler->temp,'\0',12);
  121.       memset(socketHandler->fireIfOrNot,'\0',32);
  122.     //低电平为有火灾，高电平为无火灾
  123.      if(fireHandler->readStatus(fireHandler->pinNum)){
  124.       strcpy(socketHandler->fireIfOrNot,"fire watching...");
  125.      }else{
  126.       strcpy(socketHandler->fireIfOrNot,"fire warning!!!Attention!");
  127.      }
  128.  
  129.      sprintf(socketHandler->temp,"%d.%d°C", (databuf >> 8) & 0xff, databuf & 0xff);
  130.      sprintf(socketHandler->hum,"%d.%d%rh",(databuf >> 24) & 0xff, (databuf >> 16) & 0xff);
  131.      
  132.      sprintf(message,"%s,%s,%s",socketHandler->temp,socketHandler->hum,socketHandler->fireIfOrNot);
  133.      printf("message:%s\n",message);
  134.      write(c_fd,message,strlen(message));
  135.      sleep(10);
  136.   }
  137. }
  138.  
  139. void *socket_thread(void *datas)
  140. {
  141.   pthread_t readThread;
  142.   pthread_t writeThread;
  143.  
  144.   struct sockaddr_in c_addr;
  145.  
  146.   int n_read = 0;
  147.   int clen = sizeof(struct sockaddr_in);
  148.   memset(&c_addr,0,clen);
  149.   socketHandler=findInputCommanderByName("socketServer",pCommandHead);
  150.   if(socketHandler==NULL){
  151.     printf("find socketHandler error\n");
  152.     pthread_exit(NULL);
  153.   }else{
  154.     socketHandler->Init(socketHandler);
  155.     printf("%s init success\n",socketHandler->commandName);
  156.     while(1){
  157.       //不断接收新的客户端的接入，接入新的客户端后创建新的读线程和写线程：
  158.       c_fd = accept(socketHandler->s_fd,(struct sockaddr *)&c_addr,&clen);
  159.       if(c_fd == -1){
  160. 			perror("accept");
  161. 		}
  162.       pthread_create(&readThread,NULL,read_thread,NULL);
  163.       pthread_create(&writeThread,NULL,write_thread,NULL);
  164.     }
  165.   }
  166.     
  167. }
  168.  
  169. void *voice_thread(void *datas)
  170. {
  171.   
  172.   int nread;
  173.   voiceHandler=findInputCommanderByName("voice",pCommandHead);
  174.   if(voiceHandler==NULL){
  175.     printf("find voiceHandler error\n");
  176.     pthread_exit(NULL);
  177.   }else{
  178.     if(voiceHandler->Init(voiceHandler)<0){
  179.       printf("voice init error\n");
  180.       pthread_exit(NULL);
  181.     }else{
  182.       printf("%s init success\n",voiceHandler->commandName);
  183.     }
  184.     while(1){
  185.          nread=voiceHandler->getCommand(voiceHandler);
  186.       if(nread==0){
  187.          //printf("no data from voice\n");
  188.       }else{
  189.         printf("voice get cmd: %s\n",voiceHandler->command);
  190.         voiceHandler->sendCommand(voiceHandler);
  191.          cmdContrlLight(voiceHandler->command);
  192.       }
  193.     }
  194.      
  195.     }
  196. } 
  197. void *fire_thread(void *datas)
  198. {
  199.   
  200.   struct Devices  *alertHandler;
  201.  
  202.   fireHandler=findDevicesByName("fireIfOrNot",pdeviceHead);
  203.   alertHandler=findDevicesByName("alert", pdeviceHead);
  204.   fireHandler->deviceInit(fireHandler->pinNum);
  205.   alertHandler->deviceInit(alertHandler->pinNum);
  206.  
  207.   while(1)
  208.   {
  209.     int status;
  210.     status = fireHandler->readStatus(fireHandler->pinNum);
  211.     if(!status){
  212.         //有火灾，打开报警器:
  213.         alertHandler->open(alertHandler->pinNum);
  214.     }else{
  215.       //无火灾：关闭报警器：
  216.         alertHandler->close(alertHandler->pinNum);
  217.     }
  218.   }
  219. }
  220. void *camera_thread(void * datas)
  221. {
  222.     
  223.     struct Devices *cameraHandler;
  224.     struct Devices *lockHandler;
  225.     struct Devices *csbHandler;
  226.  
  227.     cameraHandler=findDevicesByName("camera",pdeviceHead );
  228.     lockHandler=findDevicesByName("lock",pdeviceHead);
  229.     csbHandler=findDevicesByName("csb",pdeviceHead);
  230.  
  231.     lockHandler->deviceInit(lockHandler->pinNum);
  232.     csbHandler->deviceInit(csbHandler->pinNum);
  233.      
  234.     
  235.     while(1){
  236.         //距离大于1米，返回1；
  237.         while(! csbHandler->readStatus( csbHandler->pinNum)){
  238.           
  239.           printf("dis<1m,taking photo...\n");
  240.           lockHandler->status=lockHandler->readStatus(lockHandler->pinNum);//检测锁的状态
  241.           cameraHandler->status=cameraHandler->readStatus(cameraHandler->pinNum);//对比人脸；
  242.  
  243.           //1：是同一个人，开 锁，0：不是同一个人，关锁；
  244.           //1：锁是开状态，0：锁是关闭状态；
  245.           if( cameraHandler->status && !lockHandler->status){
  246.                  lockHandler->open(lockHandler->pinNum);
  247.                    printf("open lock\n");
  248.           }
  249.          
  250.         }
  251.         sleep(10);//每10秒检测一次距离，距离小于1米就拍照对比
  252.     }
  253.     
  254. }
  255.  
  256. int main()
  257. {
  258.   pthread_t voiceThread;
  259.   pthread_t socketThread;
  260.   pthread_t fireIfOrNotThread;
  261.   pthread_t cameraThread;
  262.   
  263.  
  264.   if(wiringPiSetup()==-1){
  265.     printf("wiringPi init error\n");
  266.     exit(-1);
  267.   }
  268.   //1.指令工厂初始化
  269.   pCommandHead= addSocketContrlToInputCommand(pCommandHead);
  270.   pCommandHead=addVoiceContrlToInputCommand(pCommandHead);
  271.   
  272.    //2.设备控制工厂初始化
  273.   pdeviceHead=addBathroomLightToDeviceLink(pdeviceHead);
  274.   pdeviceHead=addLivingroomLightToDeviceLink(pdeviceHead);
  275.   pdeviceHead=addUpstairLightToDeviceLink(pdeviceHead);
  276.   pdeviceHead=addRestaurantLightToDeviceLink(pdeviceHead);
  277.   pdeviceHead=addFireIfOrNotToDeviceLink(pdeviceHead);
  278.   pdeviceHead=addAlertToDeviceLink(pdeviceHead);
  279.   pdeviceHead=addLockToDeviceLink(pdeviceHead);
  280.   pdeviceHead=addCameraToDeviceLink(pdeviceHead);
  281.   pdeviceHead=addCsbToDeviceLink(pdeviceHead);
  282.   pdeviceHead=addDht11ToDeviceLink(pdeviceHead);
  283.  
  284.   //3.线程池建立
  285.   //3.1语音线程
  286.   pthread_create(&voiceThread,NULL, voice_thread,NULL);
  287.   //3.2socket 线程
  288.   pthread_create(&socketThread,NULL, socket_thread,NULL);
  289.   //3.3摄像头线程
  290.   pthread_create(&cameraThread,NULL,camera_thread,NULL);
  291.   //3.4火灾线程
  292.   pthread_create(&fireIfOrNotThread,NULL,fire_thread,NULL);
  293.   
  294.   //等待线程退出：
  295.   pthread_join(voiceThread,NULL);
  296.   pthread_join(socketThread,NULL);
  297.   pthread_join(fireIfOrNotThread,NULL);
  298.   pthread_join(cameraThread,NULL);
  299.  
  300.   return 0;
  301. }

四、客户端

(37条消息) 智能家居Android设计_lelebanaba的博客-CSDN博客w

五、项目演示

智能家居

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/码创造者/article/detail/893484
推荐阅读
相关标签

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

  

闽ICP备14008679号