Cubieboard2防火防盗家居设计

Reachy

最近本人用cubiebaord的开发板做了毕业设计，搞了很多东西，

整个设计的硬件：
Cubiebaord2及DVK扩展板  MQ-2 烟雾传感器 HC-SR501人体热释红外传感器
18B20温度传感器 数码管模块 蜂鸣器 led灯

设计系统的整体

各个模块设计
HC-SR501红外模块

功能：感应到人在检测范围内就会报警，usb摄像头也会对现场进行拍照

代码

1. #!/bin/bash
   
2. videodev="/dev/video0"
   
3. redled=4
   
4. sensor=5
   
5. #second(s) between each check
   
6. waitperiod=1
   
7. photorepeattimes=3
   
8. resolution="800x600"
   
9. directory="/tmp"
   
10. init_led ()
    
11. {
    
12.         for i in $redled
    
13.         do
    
14.                 if [ ! -d /sys/class/gpio/gpio4_pd0 ]
    
15.                 then
    
16.                         echo $i > /sys/class/gpio/export
    
17.                 fi
    
18.                         echo "out" > /sys/class/gpio/gpio4_pd0/direction
    
19.                         echo 0 > /sys/class/gpio/gpio4_pd0/value
    
20.         done
    
21. }
    
22. 
    
23. init_sensor ()
    
24. {
    
25.         for i in $sensor
    
26.         do
    
27.                 if [ ! -d /sys/class/gpio/gpio5_pd1 ]
    
28.                 then
    
29.                         echo $i > /sys/class/gpio/export
    
30.                 fi
    
31.                         echo "in" > /sys/class/gpio/gpio5_pd1/direction
    
32.         done
    
33. }
    
34. 
    
35. init_led_sensor ()
    
36. {
    
37.         init_led
    
38.         init_sensor
    
39. }
    
40. 
    
41. cleanup ()
    
42. {
    
43.         init_led_sensor
    
44.         for i in $redled $sensor
    
45.         do
    
46.                 if [ -d /sys/class/gpio/gpio$i ]
    
47.                 then
    
48.                         echo $i > /sys/class/gpio/unexport
    
49.                fi
    
50.         done
    
51.         exit 0
    
52. }
    
53. 
    
54. capture_photo()
    
55. {
    
56.         for (( c=0; c<$photorepeattimes; c++ ))
    
57.         do
    
58.                 filename=$directory/$(date -u +"%d%m%Y_%H%M-%S").jpg
    
59.                 fswebcam -d $videodev --timestamp "%Y-%m-%d %H:%M:%S (%Z)" -r $r
    
60. esolution $filename
    
61.                 sleep 1
    
62.         done
    
63. }
    
64. check_activity ()
    
65. {
    
66.         sensor_status=`cat /sys/class/gpio/gpio5_pd1/value`
    
67.         echo $sensor_status > /sys/class/gpio/gpio4_pd0/value
    
68.         if [ "$sensor_status" -eq 1 ]
    
69.                 then
    
70.                         capture_photo
    
71.                fi
    
72.         }
    
73. init_led_sensor
    
74. trap cleanup INT TERM EXIT
    
75. while :
    
76. do
    
77.         check_activity
    
78.         sleep $waitperiod
    
79. done

复制代码

18b20温度传感器
功能：实时检测当前温度，超过预设的温度就蜂鸣器响来报警
代码：

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <string.h>
   
4. #include <time.h>
   
5. #include <signal.h>
   
6. #include <pthread.h>
   
7. #include "gpio_lib.h"
   
8. 
   
9. #define LSBFIRST 0
   
10. #define MSBFIRST 1
    
11. #define  DISPBUF_LEN 8
    
12. 
    
13. typedef unsigned char byte;
    
14. 
    
15. change it in your case.
    
16. const char* DS18B20_DEVICE="/sys/bus/w1/devices/28-00000626fc86/w1_slave";
    
17. 
    
18. /*
    
19. * 74HC595 relative stuff
    
20. */
    
21. 
    
22. unsigned int latchPin = SUNXI_GPB(11);
    
23. 
    
24. unsigned int clockPin = SUNXI_GPB(13);
    
25. 
    
26. unsigned int dataPin = SUNXI_GPH(14);
    
27. 
    
28. unsigned int zzzzPin = SUNXI_GPG(3);
    
29. 
    
30. /*
    
31. * Display relative stuff
    
32. */
    
33. 
    
34. unsigned int digit_tab[] = { 0xc0, 0xf9, 0xa4, 0xb0, 0x99, 0x92,
    
35.                         0x82, 0xf8, 0x80, 0x90};
    
36. 
    
37. unsigned int digitdot_tab[] = { 0xc0&0x7f, 0xf9&0x7f, 0xa4&0x7f,
    
38.                         0xb0&0x7f, 0x99&0x7f, 0x92&0x7f, 0x82&0x7f,
    
39.                         0xf8&0x7f, 0x80&0x7f, 0x90&0x7f};
    
40. unsigned int symbol_tab[]={ 0xff, 0x7f, 0xbf};
    
41. static char dispbuf[DISPBUF_LEN];
    
42. 
    
43. 
    
44. /**
    
45. * Set Cubieboard's GPIO port-D pin I/O mode: INPUT/OUTPUT
    
46. */
    
47. void pinMode(unsigned int pin, unsigned int io_mode)
    
48. {
    
49.     if (SETUP_OK != sunxi_gpio_set_cfgpin(pin, io_mode))
    
50.     {
    
51.         printf("Failed to config GPIO pin\n");
    
52.     }
    
53. }
    
54. 
    
55. /**
    
56. * Set Cubieboard's GPIO port-D pin value(LOW/HIGH)
    
57. */
    
58. void digitalWrite(int pin, int hl)
    
59. {
    
60.     if (sunxi_gpio_output(pin, hl))
    
61.     {
    
62.         printf("Failed to set GPIO pin value\n");
    
63.     }
    
64. }
    
65. 
    
66. void shiftOut(unsigned int dataPin, unsigned int clockPin, int bitOrder, byte val)
    
67. {
    
68.     byte i;
    
69.     for (i = 0; i < 8; i++)
    
70.     {
    
71.         if (bitOrder == LSBFIRST)
    
72.             digitalWrite(dataPin, ! !(val & (1 << i)));
    
73.         else
    
74.             digitalWrite(dataPin, ! !(val & (1 << (7 - i))));
    
75. 
    
76.         digitalWrite(clockPin, HIGH);
    
77.         digitalWrite(clockPin, LOW);
    
78.     }
    
79. }
    
80. 
    
81. /**
    
82. * Initialize the GPIO & relative pins
    
83. */
    
84. void init_gpio()
    
85. {
    
86.     if (SETUP_OK != sunxi_gpio_init())
    
87.     {
    
88.         printf("Failed to initialize GPIO\n");
    
89.     }
    
90.     pinMode(latchPin, OUTPUT);
    
91.     pinMode(clockPin, OUTPUT);
    
92.     pinMode(dataPin, OUTPUT);
    
93.     pinMode(zzzzPin, OUTPUT);
    
94. }
    
95. 
    
96. /**
    
97. * Get current temperature from the w1-thermal device
    
98. */
    
99. void get_temperature(char* tempbuf, int len)
    
100. {
     
101.     FILE* fp=fopen(DS18B20_DEVICE,"r");
     
102.     char* line=NULL;
     
103.     char* temperature_tok=NULL;
     
104.     int temperature=0;
     
105.    
     
106.     int n;
     
107.     if(!fp){
     
108.         fprintf(stderr,"Failed to open device(%s) file!\n", DS18B20_DEVICE);
     
109.         return;
     
110.     }
     
111. 
     
112.     // skip the first line
     
113.     getline(&line, &n, fp);
     
114.     free(line);
     
115.     line=NULL;
     
116. 
     
117.    
     
118.     getline(&line, &n, fp);
     
119.     strtok(line,"=");
     
120.     temperature_tok=strtok(NULL,"\n");
     
121.    
     
122.     strncpy(tempbuf, temperature_tok, len);
     
123. 
     
124.     free(line);
     
125.     fclose(fp);
     
126. }
     
127. 
     
128. /**
     
129. * Thread of filling the time infomation into display buffer
     
130. */
     
131. void* time_to_dispbuf()
     
132. {
     
133.     time_t timep;
     
134.     struct tm *p;
     
135.     char timebuf[4];
     
136.     int interval=1; // in seconds
     
137. 
     
138.     while(1){
     
139.         // get localtime
     
140.         time(&timep);
     
141.         p = localtime(&timep);
     
142.         sprintf(timebuf, "%02d%02d", p->tm_hour, p->tm_min);
     
143. 
     
144.         dispbuf[0]=digit_tab[timebuf[0] - '0'];
     
145.         dispbuf[1]=digitdot_tab[timebuf[1] - '0'];
     
146.         dispbuf[2]=digit_tab[timebuf[2] - '0'];
     
147.         dispbuf[3]=digit_tab[timebuf[3] - '0'];
     
148.         dispbuf[4]=symbol_tab[2]; // '-'
     
149. 
     
150.         sleep(interval);
     
151.     }
     
152. }
     
153. 
     
154. /**
     
155. * Thread of filling the temperature into display buffer
     
156. */
     
157. void* temp_to_dispbuf()
     
158. {
     
159.     char tempbuf[3];
     
160.     int interval=5;
     
161.     float tmp = 0;
     
162.    
     
163.     while(1){
     
164.         get_temperature(tempbuf, sizeof tempbuf);
     
165. 
     
166.         dispbuf[5]=digit_tab[tempbuf[0]-'0'];
     
167.         dispbuf[6]=digitdot_tab[tempbuf[1]-'0'];
     
168.         dispbuf[7]=digit_tab[tempbuf[2]-'0'];
     
169.         tmp = (tempbuf[0]-'0')*10 + (tempbuf[1]-'0');
     
170. 
     
171.             printf("temperature = %f -------------\n", tmp);
     
172.         if (tmp > 28)
     
173.             {
     
174.                 printf("-----FIRE----FIRE----FIRE----\n");
     
175.                 digitalWrite(zzzzPin, LOW);
     
176.            }
     
177.         else
     
178.         {
     
179.                 digitalWrite(zzzzPin, HIGH);
     
180.         }
     
181. 
     
182.         sleep(interval);
     
183.     }
     
184.    
     
185. }
     
186. 
     
187. int main(int argc, char **argv)
     
188. {
     
189.     pthread_t get_time_thread, get_temp_thread;
     
190.     void * thread_ret;
     
191. 
     
192.     init_gpio();
     
193. 
     
194.     pthread_create( &get_time_thread, NULL, time_to_dispbuf, NULL);
     
195.     pthread_create( &get_temp_thread, NULL, temp_to_dispbuf, NULL);
     
196.   
     
197.     while (1)
     
198.     {
     
199. 
     
200.         int i;
     
201.         for(i=0;i<DISPBUF_LEN;i++){
     
202.             digitalWrite(latchPin, 0);
     
203.             shiftOut(dataPin, clockPin, MSBFIRST, 1<<i);
     
204.             shiftOut(dataPin, clockPin, MSBFIRST, dispbuf[i]);
     
205.             digitalWrite(latchPin, 1);
     
206.             usleep(2000);
     
207.         }
     
208.         
     
209.     }
     
210. 
     
211.     pthread_join(get_time_thread,&thread_ret);
     
212.     pthread_join(get_temp_thread,&thread_ret);
     
213.     return 0;
     
214. }

复制代码

Reachy

继续下面内容
MQ-2模块

功能：
检测到煤气，天然气，甲烷等气体超过预设的警报值就进行声报警
代码

1. #include <stdio.h>
   
2.     #include <stdlib.h>
   
3.     #include <unistd.h>
   
4.     #include <sys/types.h>
   
5.     #include <sys/stat.h>
   
6.     #include <fcntl.h>
   
7.     #include <termios.h>
   
8.     #include <errno.h>
   
9.     #include <sys/time.h>
   
10.     #include <string.h>
    
11.     #define TRUE 1
    
12.     #define FALSE -1
    
13.     #define FREZZ_ON "echo 0 > /sys/class/gpio/gpio10_pd17/value"
    
14.     #define FREZZ_OFF "echo 1 > /sys/class/gpio/gpio10_pd17/value"
    
15.     int speed_arr[] = {B115200, B38400, B19200, B9600, B4800, B2400, B1200, B300,
    
16.     B38400, B19200, B9600, B4800, B2400, B1200, B300, };
    
17.     int name_arr[] = {115200, 38400, 19200, 9600, 4800, 2400, 1200, 300,
    
18.     38400, 19200, 9600, 4800, 2400, 1200, 300, };
    
19.     void set_speed(int fd, int speed)
    
20.     {
    
21.     int i;
    
22.     int status;
    
23.     struct termios Opt;
    
24.     tcgetattr(fd,&Opt);
    
25.     for (i= 0;i<sizeof(speed_arr)/sizeof(int);i++)
    
26.     { if(speed == name_arr[i])
    
27.     {
    
28.     tcflush(fd, TCIOFLUSH);
    
29.     cfsetispeed(&Opt, speed_arr[i]);
    
30.     cfsetospeed(&Opt, speed_arr[i]);
    
31.     status = tcsetattr(fd, TCSANOW, &Opt);
    
32.     if(status != 0)
    
33.     perror("tcsetattr fd1");
    
34.     return;
    
35.     } tcflush(fd,TCIOFLUSH);
    
36.     }
    
37.     }
    
38.     int set_Parity(int fd,int databits,int stopbits,int parity)
    
39.     {
    
40.     struct termios options;
    
41.     if( tcgetattr( fd,&options)!= 0)
    
42.     {
    
43.     perror("SetupSerial 1");
    
44.     return(FALSE);
    
45.     }
    
46.     options.c_cflag &= ~CSIZE;
    
47.     switch(databits)
    
48.     {
    
49.     case 7:
    
50.     options.c_cflag |= CS7;
    
51.     break;
    
52.     case 8:
    
53.     options.c_cflag |= CS8;
    
54.     break;
    
55.     default:
    
56.     fprintf(stderr,"Unsupported data size\n");
    
57.     return (FALSE);
    
58.     }
    
59.     switch(parity)
    
60.     {
    
61.     case 'n':
    
62.     case 'N':
    
63.     options.c_cflag &= ~PARENB; /* Clear parity enable */
    
64.     options.c_iflag &= ~INPCK; /* Enable parity checking */
    
65.     options.c_iflag &= ~(ICRNL|IGNCR);
    
66.     options.c_lflag &= ~(ICANON );
    
67.     break;
    
68.     case 'o':
    
69.     case 'O':
    
70.     options.c_cflag |= (PARODD | PARENB);
    
71.     options.c_iflag |= INPCK; /* Disnable parity checking */
    
72.     break;
    
73.     case 'e':
    
74.     case 'E':
    
75.     options.c_cflag |= PARENB; /* Enable parity */
    
76.     options.c_cflag &= ~PARODD;
    
77.     options.c_iflag |= INPCK; /* Disnable parity checking */
    
78.     break;
    
79.     case 'S':
    
80.     case 's': /*as no parity*/
    
81.     options.c_cflag &= ~PARENB;
    
82.     options.c_cflag &= ~CSTOPB;
    
83.     break;
    
84.     default:
    
85.     fprintf(stderr,"Unsupported parity\n");
    
86.     return (FALSE);
    
87.     }
    
88.     switch(stopbits)
    
89.     {
    
90.     case 1:
    
91.     options.c_cflag &= ~CSTOPB;
    
92.     break;
    
93.     case 2:
    
94.     options.c_cflag |= CSTOPB;
    
95.     break;
    
96.     default:
    
97.     fprintf(stderr,"Unsupported stop bits\n");
    
98.     return (FALSE);
    
99.     }
    
100.     /* Set input parity option */
     
101.     if(parity != 'n')
     
102.     options.c_iflag |= INPCK;
     
103.     options.c_cc[VTIME] = 150; // 15 seconds
     
104.     options.c_cc[VMIN] = 0;
     
105.     tcflush(fd,TCIFLUSH); /* Update the options and do it NOW */
     
106.     if(tcsetattr(fd,TCSANOW,&options) != 0)
     
107.     {
     
108.     perror("SetupSerial 3");
     
109.     return (FALSE);
     
110.     }
     
111.     return (TRUE);
     
112.     }
     
113.     int main(int argc, char **argv)
     
114.     {
     
115.     int fd;
     
116.     int nread; int nwrite;
     
117.     int n=0; int i=0;
     
118.     int buffer[200];
     
119. 
     
120.     char devname_head[10] = "/dev/";
     
121.     char dev_name[20];
     
122.     #if 1
     
123.     if(argc < 2)
     
124.     { printf("Please input './test_uart ttySx'\n");
     
125.     exit(1);
     
126.     }
     
127.     else
     
128.     {
     
129.     strcpy(dev_name, devname_head); strcat(dev_name, argv[1]
     
130.     ); }
     
131.     fd = open(dev_name, O_RDWR);
     
132.     if(fd < 0)
     
133.     {
     
134.     perror("error to open /dev/ttySx\n");
     
135.     exit(1);
     
136.     }
     
137.     #endif
     
138.     if (fd > 0)
     
139.     {
     
140.     set_speed(fd,9600);
     
141.     }
     
142.     else
     
143.     {
     
144.     printf("Can't Open Serial Port!\n");
     
145.     exit(0);
     
146.     }
     
147.     if (set_Parity(fd,8,1,'N') == FALSE)
     
148.     {
     
149.     printf("Set Parity Error\n");
     
150.     exit(1);
     
151.     }
     
152.     printf("\nWelcome to gps_test\n\n");
     
153.     system(FREZZ_OFF);
     
154.     memset(buffer,0,sizeof(buffer));
     
155.     while(1)
     
156.     {
     
157.     nread = read(fd,&buffer,200);
     
158. 
     
159.     if(nread < 0)
     
160.     {
     
161.     printf("read error\n");
     
162.     }
     
163.     int a=atoi(buffer);
     
164.     printf("%d\n",a);
     
165.     if(a > 47)
     
166.     {
     
167.     system(FREZZ_ON);
     
168. 
     
169.     }
     
170.     else{
     
171.     system(FREZZ_OFF);
     
172.     }
     
173. 
     
174.     memset(buffer,0,sizeof(buffer));
     
175. 
     
176.     }
     
177.     }

复制代码

Reachy

18b20温度传感器是w1总线的传感器，需要在底层驱动开启编译成模块然后加载到开发板就可以用了

1. make  ARCH=arm  menuconfig

复制代码

选好之后退出，进入1-wire slaves ---> 将Thermal family implementation选上

最后保存退出

然后在Ubuntu终端执行下面指令

1. $ make ARCH=arm CROSS_COMPILE=arm-linux-gnueabi- -j4 uImage

复制代码

若编译内核没有报错则进入需要编译的驱动目录

1. cd /driver/spi

复制代码

编译没有出错则就在/lib/modules/3.13.0-32-genric/kernel/drivers下有模块生成 W1

在w1下就有驱动模块了

Reachy

摄像头除了拍照，如果搭建了局部网络还可以通过手机进行网络访问usb摄像头，了解现场的情况

bill

不错不错