• 使用香橙派并基于Linux实现最终版智能垃圾桶项目 --- 上

    最终完成效果视频：

    使用香橙派并基于Linux实现智能垃圾桶项目 — 上_哔哩哔哩_bilibiliicon-default.png?t=N7T8https://www.bilibili.com/video/BV1fw411B7Uy/?spm_id_from=333.999.0.0

    硬件接线 & 最终实现图

     

    目录

    项目需求

    需求1，2，3 --- 蜂鸣器，舵机，测距传感器的配合使用

    实现思路：

    代码展示：

    v1.c：

    需求4 --- socket服务器实现远程通讯控制的实现

    代码展示：

    v2_server.c：

    v2_client.c：

    实现效果：

    需求5 --- 语音识别模块的配置，烧录和编程

    1. 创建产品

    2. 设置PIN脚为串口模式：

    3.  设置唤醒词：

    4. 设置指令语句：

    5. 设置控制详情：

     6. 其他配置，如声音，开机播报，主动退出等，都是按喜好设置

    7. 下载SDK并烧写进入SU-03T

    代码展示（client的代码不需要更新）

    v3_server.c：

    实现效果

    需求6 --- 使用文件编程实现开关盖的历史记录

     Linux显示当前的时间：date指令

    代码展示（client的代码不需要更新）

    v4_server：

    实现效果

    需求7 --- 使用嵌入式数据库实现开关盖的历史记录

    代码展示（client的代码不需要更新）

    v5_server.c：

    实现效果

    项目需求

    1. 靠近时，垃圾桶开启2秒，2秒后关闭
    2. 垃圾桶开启带滴滴声
    3. 垃圾桶开启超过10秒，滴滴声警报
    4. 实现Sockect客户端发送指令远程打开/关闭垃圾桶，并显示垃圾桶状态
    5. 语音控制垃圾桶开关盖
    6. 记录一段时间内垃圾桶开关盖动作及开关盖指令来源并记录在文件中
    7. 统计一段时间内垃圾桶开关盖次数及开关盖指令来源并记录在数据库中
    8. 图像识别垃圾分类功能

    按照需求先逐个实现，然后最终整合：实际上除了需求8，其他知识点在之前都应该学习过了，这个项目的目的是对嵌入式Linux系统做一个知识点的阶段性整合复习，加深对于这些重要概念的理解。

    创建一个“smart_bin”文件夹，将相关代码放在其中：

    需求1，2，3 --- 蜂鸣器，舵机，测距传感器的配合使用

    实现思路：

    • 超声波测距模块不断检测距离：一旦小于30cm就驱动蜂鸣器和舵机，舵机2秒后回原
    • 如果2s内再次距离小于30cm就重新计时
    • 进行开盖时间的计算，超过10s报警

    参考：

    香橙派使用外设驱动库wiringOP来驱动蜂鸣器_mjmmm的博客-CSDN博客

    香橙派使用外设驱动库wiringOP 配合时间函数来驱动测距模块-CSDN博客

    香橙派使用外设驱动库wiringOP 配合定时器来驱动舵机_mjmmm的博客-CSDN博客

    注意，在线程中如果想要使用printf打印调试信息可能会出现：无法与同步打印的问题；

    解决方法是在printf之后紧跟着一句“ fflush(stdout)” 

    详见：

    linux多线程拷贝信号量运用于线程之间通讯遇到的printf问题_linux printf卡住 导致所有进程printf卡住_爱出名的狗腿子的博客-CSDN博客

    代码展示：

    v1.c：
    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8.  
    9.  
    10. #define PWM 5
    11. #define BEEP 2
    12. #define Trig 9
    13. #define Echo 10
    14.  
    15. int angle;
    16. double dist;
    17. static int i;
    18.  
    19. void startHC() //先要给Trig一个至少10us/ms的高电平方波
    20. {
    21. 	digitalWrite (Trig, LOW) ;
    22. 	delay(5); //5ms
    23. 	digitalWrite (Trig, HIGH) ;
    24. 	delay(5);
    25. 	delay(5);
    26. 	digitalWrite (Trig, LOW) ;
    27. }
    28.  
    29.  
    30. void signal_handler(int signum)
    31. {
    32. 	if(i <= angle){
    33. 		digitalWrite(PWM, HIGH);
    34. 	}else{
    35. 		digitalWrite(PWM, LOW);
    36. 	}
    37. 	if(i == 40){ //40*500 = 20000us = 20ms
    38. 		i = 0;
    39. 	}
    40. 	i++;
    41.  
    42. }
    43.  
    44. void *thread1(void *arg)
    45. {
    46. 	struct timeval startTime;
    47. 	struct timeval stopTime;
    48. 	double diffTime;
    49. 	//double dist
    50.  
    51. 	while(1){
    52.         delay(300); //让HC-SR04稳定一下
    53. 		startHC();
    54. 		while(digitalRead(Echo) == 0); //程序会卡在这里直到Echo变高的一瞬间
    55. 		gettimeofday(&startTime,NULL);
    56. 		while(digitalRead(Echo) == 1); //程序会卡在这里直到Echo变低的一瞬间
    57. 		gettimeofday(&stopTime,NULL);
    58.  
    59. 		diffTime = 1000000*(stopTime.tv_sec - startTime.tv_sec) + (stopTime.tv_usec - startTime.tv_usec);
    60. 		dist = 0.034 * diffTime * 0.5;
    61. 		
    62. 		//printf("dist = %f---",dist);
    63.         //fflush(stdout);
    64.  
    65. 		if(dist < 30 && angle == 1){//当距离小于30且盖子未开
    66. 			angle = 3; //开盖
    67.  
    68. 			digitalWrite (BEEP, LOW) ;  //蜂鸣器响
    69. 			delay (100) ;      
    70. 			digitalWrite (BEEP, HIGH) ; //蜂鸣器不响
    71. 			delay (100) ;
    72. 			digitalWrite (BEEP, LOW) ;  //蜂鸣器响
    73. 			delay (100) ;      
    74. 			digitalWrite (BEEP, HIGH) ; //蜂鸣器不响
    75.  
    76. 			//sleep(2); //睡眠2秒，此处如果是sleep则运行到此处时其他线程会抢占，如果是delay则不会
    77. 			delay(2000);
    78. 		}else if(dist > 30 && angle == 3){//当距离大于30且盖子打开
    79. 			angle = 1; //关盖
    80. 		}
    81.  
    82. 	}
    83.  
    84. 	pthread_exit(NULL);
    85. }
    86.  
    87. void *thread2(void *arg)
    88. {
    89. 	struct timeval startTime;
    90. 	struct timeval stopTime;
    91. 	double diffTime;
    92.  
    93. 	while(1){
    94. 		while(angle == 1);//程序会卡在这里直到盖子打开
    95. 		gettimeofday(&startTime,NULL);
    96. 		while(angle == 3){
    97. 			gettimeofday(&stopTime,NULL);
    98. 			diffTime = (stopTime.tv_sec - startTime.tv_sec) + 1/1000000 *(stopTime.tv_usec - startTime.tv_usec);
    99. 			if(diffTime > 10){ //盖子打开超过10秒
    100. 				digitalWrite (BEEP, LOW) ;  //蜂鸣器响
    101. 				delay (1000) ; //一秒长鸣警报
    102. 				digitalWrite (BEEP, HIGH) ; //蜂鸣器不响
    103. 				break;
    104. 			}
    105. 		}
    106.  
    107. 	}
    108.  
    109. 	pthread_exit(NULL);
    110. }
    111.  
    112.  
    113.  
    114.  
    115. int main()
    116. {
    117. 	struct itimerval itv;
    118. 	int ret;
    119. 	//int param = 100;
    120. 	pthread_t t1_id;
    121. 	pthread_t t2_id;
    122.  
    123. 	wiringPiSetup () ;
    124. 	pinMode (PWM, OUTPUT);
    125. 	pinMode (Trig, OUTPUT);
    126. 	pinMode (Echo, INPUT);
    127. 	pinMode (BEEP, OUTPUT);
    128.  
    129. 	digitalWrite (Trig, LOW) ;
    130. 	digitalWrite (Echo, LOW) ;
    131. 	digitalWrite (BEEP, HIGH) ;
    132.  
    133. 	//设定定时时间
    134. 	itv.it_interval.tv_sec = 0;
    135. 	itv.it_interval.tv_usec = 500;
    136. 	//设定开始生效，启动定时器的时间
    137. 	itv.it_value.tv_sec = 1;
    138. 	itv.it_value.tv_usec = 0;
    139.  
    140. 	//设定定时方式
    141. 	if( -1 == setitimer(ITIMER_REAL, &itv, NULL)){
    142. 		perror("error");
    143. 		exit(-1);
    144. 	}
    145.  
    146. 	//信号处理
    147. 	signal(SIGALRM,signal_handler);
    148.  
    149. 	angle = 1;//初始化角度为关盖
    150.  
    151.  
    152. 	ret = pthread_create(&t1_id,NULL,thread1,NULL);
    153. 	if(ret != 0){
    154. 		printf("thread1 create error\n");
    155. 	}
    156. 	ret = pthread_create(&t2_id,NULL,thread2,NULL);
    157. 	if(ret != 0){
    158. 		printf("thread2 create error\n");
    159. 	}
    160.  
    161.  
    162. 	pthread_join(t1_id,NULL);
    163. 	pthread_join(t2_id,NULL);
    164.  
    165.  
    166. 	return 0;
    167. }

    需求4 --- socket服务器实现远程通讯控制的实现

    由于之前实现的代码都使用了线程；所以如果我现在和之前一样用fork来实现socket的accept和读写，那么fork之后线程数量会翻倍，同样的线程都会同时运行两个，而父子进程又可能对angle的值改变，引起混乱。

    所以，我尝试将socket的编程也使用线程的方式来实现，由于在线程的实现中，会出现多个线程修改angle的情况，为了防止竞争，需要加互斥锁。

    代码展示：

    v2_server.c：
    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8.  
    9. #include 
    10. #include 
    11. #include 
    12. #include 
    13. #include 
    14. #include 
    15. #include 
    16. #include 
    17. #include 
    18. #include 
    19.  
    20.  
    21. #define PWM 5
    22. #define BEEP 2
    23. #define Trig 9
    24. #define Echo 10
    25.  
    26. int angle;
    27. double dist;
    28. static int i;
    29.  
    30. int sockfd;
    31. int conn_sockfd;
    32. int len = sizeof(struct sockaddr_in);
    33. int ret;
    34. char readbuf[128];
    35. struct sockaddr_in my_addr;
    36. struct sockaddr_in client_addr;
    37. static int conn_flag;
    38.  
    39. pthread_mutex_t mutex;
    40.  
    41.  
    42. int cmd_handler(int fd, char readbuf[128])
    43. {
    44. 	int ret;
    45. 	int i = 0;
    46. 	char str[128]; //将读到的数据备份在这里
    47.  
    48. 	strcpy(str,readbuf); //由于字符串的首地址是字符串的名字，所以此时相当于传入的地址，所有对字符串的操作都会影响它，所以需要进行备份，先备份再对备份的数据进行数据处理就不会影响原数据了
    49. 	if(strcmp((char *)str,"open")==0 && angle == 1){ //收到open指令时垃圾桶盖子是关着的
    50. 		ret = write(fd,"open success",20);
    51.         if(ret == -1){
    52.             perror("write");
    53.             pthread_exit(NULL);
    54.         }
    55. 		angle = 3;
    56. 		digitalWrite (BEEP, LOW) ;  //蜂鸣器响
    57. 		delay (100) ;
    58. 		digitalWrite (BEEP, HIGH) ; //蜂鸣器不响
    59. 		delay (100) ;
    60. 		digitalWrite (BEEP, LOW) ;  //蜂鸣器响
    61. 		delay (100) ;
    62. 		digitalWrite (BEEP, HIGH) ; //蜂鸣器不响
    63.  
    64. 		delay(2000);//延时2秒
    65. 	}else if(strcmp((char *)str,"open")==0 && angle == 3){  //收到open指令时垃圾桶盖子是开着的
    66. 		ret = write(fd,"already open!",20);
    67.         if(ret == -1){
    68.             perror("write");
    69.             pthread_exit(NULL);
    70.         }
    71. 	}else if(strcmp((char *)str,"close")==0 && angle == 3){ //收到close指令时垃圾桶盖子是开着的
    72. 		ret = write(fd,"close success",20);
    73.         if(ret == -1){
    74.             perror("write");
    75.             pthread_exit(NULL);
    76.         }
    77. 		angle = 1;
    78. 		delay(2000);//延时2秒
    79. 	}else if(strcmp((char *)str,"close")==0 && angle == 1){ //收到close指令时垃圾桶盖子是关着的
    80. 		ret = write(fd,"already close!",20);
    81.         if(ret == -1){
    82.             perror("write");
    83.             pthread_exit(NULL);
    84.         }
    85. 	}else if(strcmp((char *)str,"quit")==0){ //如果客户端打出了quit
    86. 		ret = write(fd,"Bye",4); //立刻回发一个Bye，目的是让客户端取消接收阻塞然后成功从FIFO读取到退出信息
    87. 		if(ret == -1){
    88. 			perror("write");
    89. 			pthread_exit(NULL);
    90. 		}
    91. 	}
    92. }
    93.  
    94.  
    95. void startHC() //先要给Trig一个至少10us/ms的高电平方波
    96. {
    97. 	digitalWrite (Trig, LOW) ;
    98. 	delay(5); //5ms
    99. 	digitalWrite (Trig, HIGH) ;
    100. 	delay(5);
    101. 	delay(5);
    102. 	digitalWrite (Trig, LOW) ;
    103. }
    104.  
    105.  
    106. void signal_handler(int signum)
    107. {
    108. 	if(i <= angle){
    109. 		digitalWrite(PWM, HIGH);
    110. 	}else{
    111. 		digitalWrite(PWM, LOW);
    112. 	}
    113. 	if(i == 40){ //40*500 = 20000us = 20ms
    114. 		i = 0;
    115. 	}
    116. 	i++;
    117.  
    118. }
    119.  
    120. void *thread1(void *arg)
    121. {
    122. 	struct timeval startTime;
    123. 	struct timeval stopTime;
    124. 	double diffTime;
    125. 	//double dist
    126.  
    127. 	while(1){
    128.         delay(300); //让HC-SR04稳定一下
    129. 		startHC();
    130. 		while(digitalRead(Echo) == 0); //程序会卡在这里直到Echo变高的一瞬间
    131. 		gettimeofday(&startTime,NULL);
    132. 		while(digitalRead(Echo) == 1); //程序会卡在这里直到Echo变低的一瞬间
    133. 		gettimeofday(&stopTime,NULL);
    134.  
    135. 		diffTime = 1000000*(stopTime.tv_sec - startTime.tv_sec) + (stopTime.tv_usec - startTime.tv_usec);
    136. 		dist = 0.034 * diffTime * 0.5;
    137.  
    138. 		//printf("dist = %f---",dist);
    139. 		//fflush(stdout);
    140.  
    141. 		pthread_mutex_lock(&mutex);//对angle值修改需要先上锁
    142.  
    143. 		if(dist < 30 && angle == 1){//当距离小于30且盖子未开
    144. 			angle = 3; //开盖
    145.  
    146. 			digitalWrite (BEEP, LOW) ;  //蜂鸣器响
    147. 			delay (100) ;      
    148. 			digitalWrite (BEEP, HIGH) ; //蜂鸣器不响
    149. 			delay (100) ;
    150. 			digitalWrite (BEEP, LOW) ;  //蜂鸣器响
    151. 			delay (100) ;      
    152. 			digitalWrite (BEEP, HIGH) ; //蜂鸣器不响
    153.  
    154. 			delay(2000);
    155. 		}else if(dist > 30 && angle == 3){//当距离大于30且盖子打开
    156. 			angle = 1; //关盖
    157. 		}
    158.  
    159. 		pthread_mutex_unlock(&mutex);
    160.  
    161. 	}
    162.  
    163. 	pthread_exit(NULL);
    164. }
    165.  
    166. void *thread2(void *arg)
    167. {
    168. 	struct timeval startTime;
    169. 	struct timeval stopTime;
    170. 	double diffTime;
    171.  
    172. 	while(1){
    173. 		while(angle == 1);//程序会卡在这里直到盖子打开
    174. 		gettimeofday(&startTime,NULL);
    175. 		while(angle == 3){
    176. 			gettimeofday(&stopTime,NULL);
    177. 			diffTime = (stopTime.tv_sec - startTime.tv_sec) + 1/1000000 *(stopTime.tv_usec - startTime.tv_usec);
    178. 			if(diffTime > 10){ //盖子打开超过10秒
    179. 				digitalWrite (BEEP, LOW) ;  //蜂鸣器响
    180. 				delay (1000) ; //一秒长鸣警报
    181. 				digitalWrite (BEEP, HIGH) ; //蜂鸣器不响
    182. 				break;
    183. 			}
    184. 		}
    185.  
    186. 	}
    187.  
    188. 	pthread_exit(NULL);
    189. }
    190.  
    191. void *thread3(void *arg)
    192. {
    193. 	while(1){
    194. 		//accept
    195. 		conn_sockfd = accept(sockfd,(struct sockaddr *)&client_addr,&len);
    196. 		if(conn_sockfd == -1){
    197. 			perror("accept");
    198. 			pthread_exit(NULL);;
    199. 		}else{
    200. 			conn_flag = 1; //保证连接成功后才开始接收
    201. 			printf("accept success, client IP = %s\n",inet_ntoa(client_addr.sin_addr));
    202. 			fflush(stdout);
    203. 		}
    204. 	}
    205.  
    206. 	pthread_exit(NULL);
    207. }
    208.  
    209. void *thread4(void *arg)
    210. {
    211. 	while(1){ //切不可直接“while(conn_flag == 1)”，这样在没有接入时会直接退出，要不停的循环查看flag的值
    212. 		while(conn_flag == 1){
    213. 			//read
    214. 			memset(&readbuf,0,sizeof(readbuf));
    215. 			ret = recv(conn_sockfd, &readbuf, sizeof(readbuf), 0);
    216. 			if(ret == 0){ //如果recv函数返回0表示连接已经断开
    217. 				printf("client has quit\n");
    218. 				fflush(stdout);
    219. 				close(conn_sockfd);
    220. 				break;
    221. 			}else if(ret == -1){
    222. 				perror("recv");
    223. 				conn_flag = 0; //此时打印一遍错误信息就会结束，如果不把flag置1，在一个客户端退出另一个客户端还未接入时就会不停的打印错误信息
    224. 				//pthread_exit(NULL); //此处不能退出，因为因为这样如果有一个客户端接入并退出后这个线程就会退出，为了保证一个客户端退出后，另一个客户端还可以接入并正常工作，此处仅显示错误信息而不退出
    225. 			}
    226.  
    227.  
    228. 			pthread_mutex_lock(&mutex);//对angle值修改需要先上锁
    229. 			cmd_handler(conn_sockfd, readbuf); //对客户端发来的消息进行判断的总函数
    230. 			pthread_mutex_unlock(&mutex);
    231.  
    232. 			printf("\nclient: %s\n",readbuf);
    233. 			fflush(stdout);
    234. 		}
    235.  
    236. 	}
    237.  
    238. 	pthread_exit(NULL);
    239. }
    240.  
    241. int main(int argc, char **argv)
    242. {
    243. 	struct itimerval itv;
    244. 	//int param = 100;
    245. 	pthread_t t1_id;
    246. 	pthread_t t2_id;
    247. 	pthread_t t3_id;
    248. 	pthread_t t4_id;
    249.  
    250. 	memset(&my_addr,0,sizeof(struct sockaddr_in));
    251. 	memset(&client_addr,0,sizeof(struct sockaddr_in));
    252.  
    253.  
    254. 	if(argc != 3){
    255. 		printf("param error!\n");
    256. 		return 1;
    257. 	}
    258.  
    259. 	wiringPiSetup () ;
    260. 	pinMode (PWM, OUTPUT);
    261. 	pinMode (Trig, OUTPUT);
    262. 	pinMode (Echo, INPUT);
    263. 	pinMode (BEEP, OUTPUT);
    264.  
    265. 	digitalWrite (Trig, LOW) ;
    266. 	digitalWrite (Echo, LOW) ;
    267. 	digitalWrite (BEEP, HIGH) ;
    268.  
    269. 	//设定定时时间
    270. 	itv.it_interval.tv_sec = 0;
    271. 	itv.it_interval.tv_usec = 500;
    272. 	//设定开始生效，启动定时器的时间
    273. 	itv.it_value.tv_sec = 1;
    274. 	itv.it_value.tv_usec = 0;
    275.  
    276. 	//设定定时方式
    277. 	if( -1 == setitimer(ITIMER_REAL, &itv, NULL)){
    278. 		perror("error");
    279. 		exit(-1);
    280. 	}
    281.  
    282. 	//信号处理
    283. 	signal(SIGALRM,signal_handler);
    284.  
    285. 	angle = 1;//初始化角度为关盖
    286.  
    287. 	//socket
    288. 	sockfd = socket(AF_INET,SOCK_STREAM,0);
    289. 	if(sockfd == -1){
    290. 		perror("socket");
    291. 		return 1;
    292. 	}else{
    293. 		printf("socket success, sockfd = %d\n",sockfd);
    294. 	}
    295.  
    296. 	//bind
    297. 	my_addr.sin_family = AF_INET;
    298. 	my_addr.sin_port = htons(atoi(argv[2]));//host to net (2 bytes)
    299. 	inet_aton(argv[1],&my_addr.sin_addr); //char* format -> net format
    300.  
    301. 	ret = bind(sockfd, (struct sockaddr *)&my_addr, len);
    302. 	if(ret == -1){
    303. 		perror("bind");
    304. 		return 1;
    305. 	}else{
    306. 		printf("bind success\n");
    307. 	}
    308.  
    309. 	//listen
    310. 	ret = listen(sockfd,10);
    311. 	if(ret == -1){
    312. 		perror("listen");
    313. 		return 1;
    314. 	}else{
    315. 		printf("listening...\n");
    316. 	}
    317.  
    318. 	ret = pthread_mutex_init(&mutex, NULL);
    319. 	if(ret != 0){
    320. 		printf("mutex create error\n");
    321. 	}
    322.  
    323. 	ret = pthread_create(&t1_id,NULL,thread1,NULL);
    324. 	if(ret != 0){
    325. 		printf("thread1 create error\n");
    326. 	}
    327. 	ret = pthread_create(&t2_id,NULL,thread2,NULL);
    328. 	if(ret != 0){
    329. 		printf("thread2 create error\n");
    330. 	}
    331. 	ret = pthread_create(&t3_id,NULL,thread3,NULL);
    332. 	if(ret != 0){
    333. 		printf("thread3 create error\n");
    334. 	}
    335. 	ret = pthread_create(&t4_id,NULL,thread4,NULL);
    336. 	if(ret != 0){
    337. 		printf("thread4 create error\n");
    338. 	}
    339.  
    340. 	pthread_join(t1_id,NULL);
    341. 	pthread_join(t2_id,NULL);
    342. 	pthread_join(t3_id,NULL);
    343. 	pthread_join(t4_id,NULL);
    344.  
    345. 	return 0;
    346. }
    v2_client.c：
    1. #include      
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    12. #include 
    13. #include 
    14.  
    15.  
    16.  
    17. int main(int argc, char **argv)
    18. {
    19. 	int sockfd;
    20. 	int ret;
    21. 	int n_read;
    22. 	int n_write;
    23. 	char readbuf[128];
    24. 	char msg[128];
    25.  
    26. 	int fd; //fifo
    27. 	char fifo_readbuf[20] = {0};
    28. 	char *fifo_msg = "quit";
    29.  
    30. 	pid_t fork_return;
    31.  
    32. 	if(argc != 3){
    33. 		printf("param error!\n");
    34. 		return 1;
    35. 	}
    36.  
    37.  
    38. 	struct sockaddr_in server_addr;
    39. 	memset(&server_addr,0,sizeof(struct sockaddr_in));
    40.  
    41. 	//socket
    42. 	sockfd = socket(AF_INET,SOCK_STREAM,0);
    43. 	if(sockfd == -1){
    44. 		perror("socket");
    45. 		return 1;
    46. 	}else{
    47. 		printf("socket success, sockfd = %d\n",sockfd);
    48. 	}
    49.  
    50. 	//connect
    51. 	server_addr.sin_family = AF_INET;
    52. 	server_addr.sin_port = htons(atoi(argv[2]));//host to net (2 bytes)
    53. 	inet_aton(argv[1],&server_addr.sin_addr); 
    54. 	ret = connect(sockfd, (struct sockaddr *)&server_addr, sizeof(struct sockaddr_in));
    55. 	if(ret == -1){
    56. 		perror("connect");
    57. 		return 1;
    58. 	}else{
    59. 		printf("connect success!\n");
    60. 	}
    61.  
    62. 	//fifo
    63. 	if(mkfifo("./fifo",S_IRWXU) == -1 && errno != EEXIST)
    64. 	{
    65. 		perror("fifo");
    66. 	}
    67.  
    68. 	//fork
    69. 	fork_return = fork();
    70.  
    71. 	if(fork_return > 0){//father keeps writing msg
    72. 		while(1){
    73. 			//write
    74. 			memset(&msg,0,sizeof(msg));
    75. 			//printf("\ntype msg:");
    76. 			scanf("%s",(char *)msg);
    77. 			n_write = write(sockfd,&msg,strlen(msg));
    78. 			if(msg[0]=='q' && msg[1]=='u' && msg[2]=='i' && msg[3]=='t'){
    79. 				printf("quit detected!\n");
    80. 				fd = open("./fifo",O_WRONLY);
    81. 				write(fd,fifo_msg,strlen(fifo_msg));
    82. 				close(fd);
    83. 				close(sockfd);
    84. 				wait(NULL);
    85. 				break;
    86. 			}
    87. 			if(n_write == -1){
    88. 				perror("write");
    89. 				return 1;
    90. 			}else{
    91. 				printf("%d bytes msg sent\n",n_write);
    92. 			}
    93. 		}
    94. 	}else if(fork_return < 0){
    95. 		perror("fork");
    96. 		return 1;
    97. 	}else{//son keeps reading 
    98. 		while(1){
    99. 			fd = open("./fifo",O_RDONLY|O_NONBLOCK);
    100. 			lseek(fd, 0, SEEK_SET);
    101. 			read(fd,&fifo_readbuf,20);
    102. 			//printf("read from fifo:%s\n",fifo_readbuf);
    103. 			if(fifo_readbuf[0]=='q' && fifo_readbuf[1]=='u' && fifo_readbuf[2]=='i' && fifo_readbuf[3]=='t'){
    104. 				exit(1);
    105. 			}
    106.  
    107. 			//read
    108. 			memset(&readbuf,0,sizeof(readbuf));
    109. 			n_read = read(sockfd,&readbuf,128);
    110. 			if(n_read == -1){
    111. 				perror("read");
    112. 				return 1;
    113. 			}else{
    114. 				printf("\nserver: %s\n",readbuf);
    115. 			}
    116. 		}
    117.  
    118. 	}
    119.  
    120.  
    121. 	return 0;
    122. }

    实现效果：

    编译两个C文件：

    然后先启动服务器端：

     

    此时，如果距离检测到30cm以内就会开盖了，只是还没有客户端无法远程控制 

    再启动客户端：

     

    反观服务端：

     

    此时在客户端输入open或close即可实时遥控，并可以得到服务器的反馈：

    如果客户端输入“quit”即可退出，并支持新的客户端的接入

    （比如如果盖子已经打开，收到open会提示已经打开等..）

    1. 此处我先使用open指令打开盖子两秒
    2. 等盖子关闭后我靠近测距传感器让盖子打开两秒后再次输入open指令
    3. 然后在盖子打开时输入close指令，同时把手拿开（如果不把手拿开，盖子会因为close指令关闭两秒，然后因为距离小于30再次打开）
    4. 最后在盖子关上后输入close指令

    1. 由于盖子没开且收到了open指令，所以盖子打开2秒
    2. 由于盖子已经打开且收到了open指令，所以提示“盖子已经打开”
    3. 由于盖子打开且收到了close指令，所以盖子关闭2秒
    4. 由于盖子关闭且收到了close指令，所以提示“盖子已经关闭”

    需求5 --- 语音识别模块的配置，烧录和编程

    和之前学习的一样，使用SU-03T来实现语音识别，先进行语音识别的配置，以下只展示关键截图，具体的步骤和烧写流程参考我之前写的两篇：

    基于香橙派和SU-03T 使用Linux实现语音控制刷抖音-CSDN博客

    语音小车---6 + 最终整合-CSDN博客

    1. 创建产品

    2. 设置PIN脚为串口模式：

    对于SU-03T，串口的RX和TX分别对应B6和B7

    并设置相应的波特率：

    3.  设置唤醒词：

    4. 设置指令语句：

    5. 设置控制详情：

     参数的设置就是行为的名字 -> 16进制ASCII码，已空格分开

     

    open -> 6F 70 65 6E

    close ->63 6C 6F 73 65

     6. 其他配置，如声音，开机播报，主动退出等，都是按喜好设置

    7. 下载SDK并烧写进入SU-03T

    代码展示（client的代码不需要更新）

    v3_server.c：
    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8.  
    9. #include 
    10. #include 
    11. #include 
    12. #include 
    13. #include 
    14. #include 
    15. #include 
    16. #include 
    17. #include 
    18. #include 
    19.  
    20. #include 
    21. #include 
    22. #include 
    23. #include 
    24. #include "mjm_uart_tool.h"
    25.  
    26. #define PWM 5
    27. #define BEEP 2
    28. #define Trig 9
    29. #define Echo 10
    30.  
    31. int angle;
    32. double dist;
    33. static int i;
    34.  
    35. int sockfd;
    36. int conn_sockfd;
    37. int len = sizeof(struct sockaddr_in);
    38. int ret;
    39. char readbuf[128];
    40. struct sockaddr_in my_addr;
    41. struct sockaddr_in client_addr;
    42. static int conn_flag;
    43.  
    44. pthread_mutex_t mutex;
    45.  
    46.  
    47. int cmd_handler(int fd, char readbuf[128])
    48. {
    49. 	int ret;
    50. 	int i = 0;
    51. 	char str[128]; //将读到的数据备份在这里
    52.  
    53. 	strcpy(str,readbuf); //由于字符串的首地址是字符串的名字，所以此时相当于传入的地址，所有对字符串的操作都会影响它，所以需要进行备份，先备份再对备份的数据进行数据处理就不会影响原数据了
    54. 	if(strcmp((char *)str,"open")==0 && angle == 1){ //收到open指令时垃圾桶盖子是关着的
    55. 		ret = write(fd,"open success",20);
    56. 		if(ret == -1){
    57. 			perror("write");
    58. 			pthread_exit(NULL);
    59. 		}
    60. 		angle = 3;
    61. 		digitalWrite (BEEP, LOW) ;  //蜂鸣器响
    62. 		delay (100) ;
    63. 		digitalWrite (BEEP, HIGH) ; //蜂鸣器不响
    64. 		delay (100) ;
    65. 		digitalWrite (BEEP, LOW) ;  //蜂鸣器响
    66. 		delay (100) ;
    67. 		digitalWrite (BEEP, HIGH) ; //蜂鸣器不响
    68.  
    69. 		delay(2000);//延时2秒
    70. 	}else if(strcmp((char *)str,"open")==0 && angle == 3){  //收到open指令时垃圾桶盖子是开着的
    71. 		ret = write(fd,"already open!",20);
    72. 		if(ret == -1){
    73. 			perror("write");
    74. 			pthread_exit(NULL);
    75. 		}
    76. 	}else if(strcmp((char *)str,"close")==0 && angle == 3){ //收到close指令时垃圾桶盖子是开着的
    77. 		ret = write(fd,"close success",20);
    78. 		if(ret == -1){
    79. 			perror("write");
    80. 			pthread_exit(NULL);
    81. 		}
    82. 		angle = 1;
    83. 		delay(2000);//延时2秒
    84. 	}else if(strcmp((char *)str,"close")==0 && angle == 1){ //收到close指令时垃圾桶盖子是关着的
    85. 		ret = write(fd,"already close!",20);
    86. 		if(ret == -1){
    87. 			perror("write");
    88. 			pthread_exit(NULL);
    89. 		}
    90. 	}else if(strcmp((char *)str,"quit")==0){ //如果客户端打出了quit
    91. 		ret = write(fd,"Bye",4); //立刻回发一个Bye，目的是让客户端取消接收阻塞然后成功从FIFO读取到退出信息
    92. 		if(ret == -1){
    93. 			perror("write");
    94. 			pthread_exit(NULL);
    95. 		}
    96. 	}
    97. }
    98.  
    99.  
    100. void startHC() //先要给Trig一个至少10us/ms的高电平方波
    101. {
    102. 	digitalWrite (Trig, LOW) ;
    103. 	delay(5); //5ms
    104. 	digitalWrite (Trig, HIGH) ;
    105. 	delay(5);
    106. 	delay(5);
    107. 	digitalWrite (Trig, LOW) ;
    108. }
    109.  
    110.  
    111. void signal_handler(int signum)
    112. {
    113. 	if(i <= angle){
    114. 		digitalWrite(PWM, HIGH);
    115. 	}else{
    116. 		digitalWrite(PWM, LOW);
    117. 	}
    118. 	if(i == 40){ //40*500 = 20000us = 20ms
    119. 		i = 0;
    120. 	}
    121. 	i++;
    122.  
    123. }
    124.  
    125. void *thread1(void *arg) //负责不断检测距离，小于30cm就滴滴开盖的线程
    126. {
    127. 	struct timeval startTime;
    128. 	struct timeval stopTime;
    129. 	double diffTime;
    130. 	//double dist
    131.  
    132. 	while(1){
    133.         delay(300); //让HC-SR04稳定一下
    134. 		startHC();
    135. 		while(digitalRead(Echo) == 0); //程序会卡在这里直到Echo变高的一瞬间
    136. 		gettimeofday(&startTime,NULL);
    137. 		while(digitalRead(Echo) == 1); //程序会卡在这里直到Echo变低的一瞬间
    138. 		gettimeofday(&stopTime,NULL);
    139.  
    140. 		diffTime = 1000000*(stopTime.tv_sec - startTime.tv_sec) + (stopTime.tv_usec - startTime.tv_usec);
    141. 		dist = 0.034 * diffTime * 0.5;
    142.  
    143. 		//printf("dist = %f---",dist);
    144. 		//fflush(stdout);
    145.  
    146. 		pthread_mutex_lock(&mutex);//对angle值修改需要先上锁
    147.  
    148. 		if(dist < 30 && angle == 1){//当距离小于30且盖子未开
    149. 			angle = 3; //开盖
    150.  
    151. 			digitalWrite (BEEP, LOW) ;  //蜂鸣器响
    152. 			delay (100) ;      
    153. 			digitalWrite (BEEP, HIGH) ; //蜂鸣器不响
    154. 			delay (100) ;
    155. 			digitalWrite (BEEP, LOW) ;  //蜂鸣器响
    156. 			delay (100) ;      
    157. 			digitalWrite (BEEP, HIGH) ; //蜂鸣器不响
    158.  
    159. 			//sleep(2); //睡眠2秒，此处如果是sleep则运行到此处时其他线程会抢占，如果是delay则不会
    160. 			delay(2000);
    161. 		}else if(dist > 30 && angle == 3){//当距离大于30且盖子打开
    162. 			angle = 1; //关盖
    163. 		}
    164.  
    165. 		pthread_mutex_unlock(&mutex);
    166.  
    167. 	}
    168.  
    169. 	pthread_exit(NULL);
    170. }
    171.  
    172. void *thread2(void *arg) //负责检测开盖时间，超过10s就报警的线程
    173. {
    174. 	struct timeval startTime;
    175. 	struct timeval stopTime;
    176. 	double diffTime;
    177.  
    178. 	while(1){
    179. 		while(angle == 1);//程序会卡在这里直到盖子打开
    180. 		gettimeofday(&startTime,NULL);
    181. 		while(angle == 3){
    182. 			gettimeofday(&stopTime,NULL);
    183. 			diffTime = (stopTime.tv_sec - startTime.tv_sec) + 1/1000000 *(stopTime.tv_usec - startTime.tv_usec);
    184. 			if(diffTime > 10){ //盖子打开超过10秒
    185. 				digitalWrite (BEEP, LOW) ;  //蜂鸣器响
    186. 				delay (1000) ; //一秒长鸣警报
    187. 				digitalWrite (BEEP, HIGH) ; //蜂鸣器不响
    188. 				break;
    189. 			}
    190. 		}
    191.  
    192. 	}
    193.  
    194. 	pthread_exit(NULL);
    195. }
    196.  
    197. void *thread3(void *arg) //负责不断等待socket客户端接入的线程
    198. {
    199. 	while(1){
    200. 		//accept
    201. 		conn_sockfd = accept(sockfd,(struct sockaddr *)&client_addr,&len);
    202. 		if(conn_sockfd == -1){
    203. 			perror("accept");
    204. 			pthread_exit(NULL);;
    205. 		}else{
    206. 			conn_flag = 1; //保证连接成功后才开始接收
    207. 			printf("accept success, client IP = %s\n",inet_ntoa(client_addr.sin_addr));
    208. 			fflush(stdout);
    209. 		}
    210. 	}
    211.  
    212. 	pthread_exit(NULL);
    213. }
    214.  
    215. void *thread4(void *arg) //负责socket客户端接入后接收处理客户端指令的线程
    216. {
    217. 	while(1){ //切不可直接“while(conn_flag == 1)”，这样在没有接入时会直接退出，要不停的循环查看flag的值
    218. 		while(conn_flag == 1){
    219. 			//read
    220. 			memset(&readbuf,0,sizeof(readbuf));
    221. 			ret = recv(conn_sockfd, &readbuf, sizeof(readbuf), 0);
    222. 			if(ret == 0){ //如果recv函数返回0表示连接已经断开
    223. 				printf("client has quit\n");
    224. 				fflush(stdout);
    225. 				close(conn_sockfd);
    226. 				break;
    227. 			}else if(ret == -1){
    228. 				perror("recv");
    229. 				conn_flag = 0; //此时打印一遍错误信息就会结束，如果不把flag置1，在一个客户端退出另一个客户端还未接入时就会不停的打印错误信息
    230. 				//pthread_exit(NULL); //此处不能退出，因为因为这样如果有一个客户端接入并退出后这个线程就会退出，为了保证一个客户端退出后，另一个客户端还可以接入并正常工作，此处仅显示错误信息而不退出
    231. 			}
    232.  
    233.  
    234. 			pthread_mutex_lock(&mutex);//对angle值修改需要先上锁
    235. 			cmd_handler(conn_sockfd, readbuf); //对客户端发来的消息进行判断的总函数
    236. 			pthread_mutex_unlock(&mutex);
    237.  
    238. 			printf("\nclient: %s\n",readbuf);
    239. 			fflush(stdout);
    240. 		}
    241.  
    242. 	}
    243.  
    244. 	pthread_exit(NULL);
    245. }
    246.  
    247. void *thread5(void *arg) //负责通过串口接收语音模块指令的线程
    248. {
    249. 	char readbuf[32] = {'\0'};
    250. 	while(1){
    251. 		while(serialDataAvail (*((int *)arg))){
    252. 			serialGetstring (*((int *)arg),readbuf) ;
    253. 			//printf("-> %s\n",readbuf);
    254.  
    255. 			pthread_mutex_lock(&mutex);//对angle值修改需要先上锁
    256.  
    257. 			if(strcmp(readbuf,"open") == 0 && angle == 1){ //当收到open指令且盖子关闭时
    258. 				angle = 3; //开盖
    259. 				digitalWrite (BEEP, LOW) ;  //蜂鸣器响
    260. 				delay (100) ;
    261. 				digitalWrite (BEEP, HIGH) ; //蜂鸣器不响
    262. 				delay (100) ;
    263. 				digitalWrite (BEEP, LOW) ;  //蜂鸣器响
    264. 				delay (100) ;
    265. 				digitalWrite (BEEP, HIGH) ; //蜂鸣器不响
    266.  
    267. 				delay(2000);//延时2秒
    268.  
    269. 			}else if(strcmp(readbuf,"close") == 0 && angle == 3){//当收到close指令且盖子打开时
    270. 				angle = 1; //关盖
    271. 				delay(2000);//延时2秒
    272. 			}else if(strcmp(readbuf,"open") == 0 && angle == 3){
    273. 				printf("already open\n");
    274.                 fflush(stdout);
    275. 			}else if(strcmp(readbuf,"close") == 0 && angle == 1){
    276. 				printf("already close\n");
    277.                 fflush(stdout);
    278. 			}else{
    279. 				printf("unkown command\n");
    280. 				fflush(stdout);
    281. 			}
    282.  
    283. 			pthread_mutex_unlock(&mutex);
    284.  
    285. 			memset(readbuf,'\0',32);
    286. 		}
    287. 	}
    288.  
    289. 	pthread_exit(NULL);
    290. }
    291.  
    292. int main(int argc, char **argv)
    293. {
    294. 	struct itimerval itv;
    295. 	int io_fd;
    296.  
    297. 	pthread_t t1_id;
    298. 	pthread_t t2_id;
    299. 	pthread_t t3_id;
    300. 	pthread_t t4_id;
    301. 	pthread_t t5_id;
    302.  
    303. 	memset(&my_addr,0,sizeof(struct sockaddr_in));
    304. 	memset(&client_addr,0,sizeof(struct sockaddr_in));
    305.  
    306.  
    307. 	if(argc != 3){
    308. 		printf("param error!\n");
    309. 		return 1;
    310. 	}
    311.  
    312. 	wiringPiSetup () ;
    313. 	pinMode (PWM, OUTPUT);
    314. 	pinMode (Trig, OUTPUT);
    315. 	pinMode (Echo, INPUT);
    316. 	pinMode (BEEP, OUTPUT);
    317.  
    318. 	digitalWrite (Trig, LOW) ;
    319. 	digitalWrite (Echo, LOW) ;
    320. 	digitalWrite (BEEP, HIGH) ;
    321.  
    322. 	//设定定时时间
    323. 	itv.it_interval.tv_sec = 0;
    324. 	itv.it_interval.tv_usec = 500;
    325. 	//设定开始生效，启动定时器的时间
    326. 	itv.it_value.tv_sec = 1;
    327. 	itv.it_value.tv_usec = 0;
    328.  
    329. 	//设定定时方式
    330. 	if( -1 == setitimer(ITIMER_REAL, &itv, NULL)){
    331. 		perror("error");
    332. 		exit(-1);
    333. 	}
    334.  
    335. 	//信号处理
    336. 	signal(SIGALRM,signal_handler);
    337.  
    338. 	angle = 1;//初始化角度为关盖
    339.  
    340. 	//打开串口驱动文件，配置波特率
    341. 	if ((io_fd = myserialOpen ("/dev/ttyS5", 115200)) < 0)	{
    342. 		fprintf (stderr, "Unable to open serial device: %s\n", strerror (errno)) ;
    343. 		return 1 ;
    344. 	}
    345.  
    346. 	//socket
    347. 	sockfd = socket(AF_INET,SOCK_STREAM,0);
    348. 	if(sockfd == -1){
    349. 		perror("socket");
    350. 		return 1;
    351. 	}else{
    352. 		printf("socket success, sockfd = %d\n",sockfd);
    353. 	}
    354.  
    355. 	//bind
    356. 	my_addr.sin_family = AF_INET;
    357. 	my_addr.sin_port = htons(atoi(argv[2]));//host to net (2 bytes)
    358. 	inet_aton(argv[1],&my_addr.sin_addr); //char* format -> net format
    359.  
    360. 	ret = bind(sockfd, (struct sockaddr *)&my_addr, len);
    361. 	if(ret == -1){
    362. 		perror("bind");
    363. 		return 1;
    364. 	}else{
    365. 		printf("bind success\n");
    366. 	}
    367.  
    368. 	//listen
    369. 	ret = listen(sockfd,10);
    370. 	if(ret == -1){
    371. 		perror("listen");
    372. 		return 1;
    373. 	}else{
    374. 		printf("listening...\n");
    375. 	}
    376.  
    377. 	ret = pthread_mutex_init(&mutex, NULL);
    378. 	if(ret != 0){
    379. 		printf("mutex create error\n");
    380. 	}
    381.  
    382. 	ret = pthread_create(&t1_id,NULL,thread1,NULL);
    383. 	if(ret != 0){
    384. 		printf("thread1 create error\n");
    385. 	}
    386. 	ret = pthread_create(&t2_id,NULL,thread2,NULL);
    387. 	if(ret != 0){
    388. 		printf("thread2 create error\n");
    389. 	}
    390. 	ret = pthread_create(&t3_id,NULL,thread3,NULL);
    391. 	if(ret != 0){
    392. 		printf("thread3 create error\n");
    393. 	}
    394. 	ret = pthread_create(&t4_id,NULL,thread4,NULL);
    395. 	if(ret != 0){
    396. 		printf("thread4 create error\n");
    397. 	}
    398. 	ret = pthread_create(&t5_id,NULL,thread5,(void *)&io_fd);
    399. 	if(ret != 0){
    400. 		printf("thread5 create error\n");
    401. 	}
    402.  
    403.  
    404. 	pthread_join(t1_id,NULL);
    405. 	pthread_join(t2_id,NULL);
    406. 	pthread_join(t3_id,NULL);
    407. 	pthread_join(t4_id,NULL);
    408. 	pthread_join(t5_id,NULL);
    409.  
    410. 	return 0;
    411. }

    实现效果

    由于此处使用了之前自己写的串口库，所以编译的时候需要连同那个串口库一起编译：

    gcc mjm_uart_tool.c v3_server.c -lwiringPi -lwiringPiDev -lpthread -lm -lcrypt -lrt -o v3_server

    1. 开机播报“小智随时准备着”

    1. 当说出“你好小智"可以唤醒模块，模块回复“我是小智，你好”

    2. 当超过10s没有指令或说出“退下”时，模块会进入休眠模式，并回复“有需要再叫我”

    3. 当说出“打开盖子”时，模块回复“已为您打开盖子”，并打开盖子

    4. 当说出“关闭盖子”时，模块回复“已为您关闭盖子”，并关闭盖子

    需求6 --- 使用文件编程实现开关盖的历史记录

    回顾具体的需求:

    记录一段时间内垃圾桶开关盖动作及开关盖指令来源并记录在文件中

    回顾之前关于文件学习的博文：

    文件的写入 和 读取_mjmmm的博客-CSDN博客

    Linux 系统编程 开篇/ 文件的打开/创建-CSDN博客

     Linux显示当前的时间：date指令

    详见：

    Linux打印时间_笔记大全_设计学院

    总结一下，就是使用以下指令即可打印当前的 “年-月-日-时-分-秒”

    date +"%Y-%m-%d %H:%M:%S"

    那么，相应在程序中调用popen函数执行这句话，就可以得到时间的字符串，将“时间的字符串”和“表示开关指令来源的字符串”以及“记录开关动作的字符串”进行拼接，就形成了一条历史记录；然后另开一个线程检测时间，当时间到达一天时，就将历史记录全部写入到指定的文件中。

    关于字符串的拼接，使用的是strcat函数，在我之前的博文也使用过，注意strcat的对象必须是可变的字符串：

     小插曲 -- 使用Linux编写 判断程序是否在运行的小程序-CSDN博客

    代码展示（client的代码不需要更新）

    v4_server：
    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8.  
    9. #include 
    10. #include 
    11. #include 
    12. #include 
    13. #include 
    14. #include 
    15. #include 
    16. #include 
    17. #include 
    18. #include 
    19.  
    20. #include 
    21. #include 
    22. #include 
    23. #include 
    24. #include "mjm_uart_tool.h"
    25.  
    26. #define PWM 5
    27. #define BEEP 2
    28. #define Trig 9
    29. #define Echo 10
    30.  
    31. int angle;
    32. double dist;
    33. static int i;
    34.  
    35. int sockfd;
    36. int conn_sockfd;
    37. int len = sizeof(struct sockaddr_in);
    38. int ret;
    39. char readbuf[128];
    40. struct sockaddr_in my_addr;
    41. struct sockaddr_in client_addr;
    42. static int conn_flag;
    43. char hist[128] = {0}; //用于存放一条历史记录,注意这个变量一定不能在create_hist里赋值，因为局部指针变量作为函数的返回值没有意义，会报错; 且作为strcat的对象必须是字符串变量
    44. char hist_whole[10000] = {0}; //用于存放所有历史记录; 且作为strcat的对象必须是字符串变量i
    45.  
    46. pthread_mutex_t mutex;
    47.  
    48. char *create_hist(int type, int action)//用于生成一条历史记录的函数
    49. 	//type的值1;2;3分别对应距离靠近开盖;客户端指令开盖;语音识别开盖
    50. 	//action的值1;2分别对应开盖;关盖
    51. {
    52. 	FILE *fp;
    53. 	char *dist = "||distance close||";
    54. 	char *sock = "||client request||";
    55. 	char *soun = "||voice  command||";
    56. 	char *open = "open action||";
    57. 	char *close = "close action||";
    58. 	char *c = "\n";
    59.  
    60. 	memset(&hist,'\0',sizeof(hist));
    61. 	fp = popen("date +\"%Y-%m-%d %H:%M:%S\"","r");
    62. 	fread(&hist, sizeof(char), 128, fp);
    63.  
    64. 	if(type == 1){ //如果时距离靠近导致的开关盖
    65. 		strcat(hist,dist); 
    66. 	}else if(type == 2){ //如果是客户端指令导致的开关盖
    67. 		strcat(hist,sock);
    68. 	}else if(type == 3){ //如果是语音识别导致的开关盖
    69. 		strcat(hist,soun);
    70. 	}
    71.  
    72. 	if(action == 1){
    73. 		strcat(hist,open);
    74. 	}else if(action == 2){
    75. 		strcat(hist,close);
    76. 	}
    77.  
    78. 	strcat(hist,c);//每条历史记录结束加上一个换行键
    79.  
    80. 	return (char *)hist;
    81.  
    82. }
    83.  
    84. int cmd_handler(int fd, char readbuf[128])
    85. {
    86. 	int ret;
    87. 	int i = 0;
    88. 	char str[128]; //将读到的数据备份在这里
    89.  
    90. 	strcpy(str,readbuf); //由于字符串的首地址是字符串的名字，所以此时相当于传入的地址，所有对字符串的操作都会影响它，所以需要进行备份，先备份再对备份的数据进行数据处理就不会影响原数据了
    91. 	if(strcmp((char *)str,"open")==0 && angle == 1){ //收到open指令时垃圾桶盖子是关着的
    92. 		ret = write(fd,"open success",20);
    93. 		if(ret == -1){
    94. 			perror("write");
    95. 			pthread_exit(NULL);
    96. 		}
    97. 		angle = 3;
    98.  
    99. 		create_hist(2,1);//构建一条历史记录
    100. 		strcat(hist_whole,hist);//在总的历史记录中添加刚刚构建的历史记录
    101.  
    102. 		digitalWrite (BEEP, LOW) ;  //蜂鸣器响
    103. 		delay (100) ;
    104. 		digitalWrite (BEEP, HIGH) ; //蜂鸣器不响
    105. 		delay (100) ;
    106. 		digitalWrite (BEEP, LOW) ;  //蜂鸣器响
    107. 		delay (100) ;
    108. 		digitalWrite (BEEP, HIGH) ; //蜂鸣器不响
    109.  
    110. 		delay(2000);//延时2秒
    111. 	}else if(strcmp((char *)str,"open")==0 && angle == 3){  //收到open指令时垃圾桶盖子是开着的
    112. 		ret = write(fd,"already open!",20);
    113. 		if(ret == -1){
    114. 			perror("write");
    115. 			pthread_exit(NULL);
    116. 		}
    117. 	}else if(strcmp((char *)str,"close")==0 && angle == 3){ //收到close指令时垃圾桶盖子是开着的
    118. 		ret = write(fd,"close success",20);
    119. 		if(ret == -1){
    120. 			perror("write");
    121. 			pthread_exit(NULL);
    122. 		}
    123. 		angle = 1;
    124.  
    125. 		create_hist(2,2);//构建一条历史记录
    126. 		strcat(hist_whole,hist);//在总的历史记录中添加刚刚构建的历史记录
    127.  
    128. 		delay(2000);//延时2秒
    129. 	}else if(strcmp((char *)str,"close")==0 && angle == 1){ //收到close指令时垃圾桶盖子是关着的
    130. 		ret = write(fd,"already close!",20);
    131. 		if(ret == -1){
    132. 			perror("write");
    133. 			pthread_exit(NULL);
    134. 		}
    135. 	}else if(strcmp((char *)str,"quit")==0){ //如果客户端打出了quit
    136. 		ret = write(fd,"Bye",4); //立刻回发一个Bye，目的是让客户端取消接收阻塞然后成功从FIFO读取到退出信息
    137. 		if(ret == -1){
    138. 			perror("write");
    139. 			pthread_exit(NULL);
    140. 		}
    141. 	}
    142. }
    143.  
    144.  
    145. void startHC() //先要给Trig一个至少10us/ms的高电平方波
    146. {
    147. 	digitalWrite (Trig, LOW) ;
    148. 	delay(5); //5ms
    149. 	digitalWrite (Trig, HIGH) ;
    150. 	delay(5);
    151. 	delay(5);
    152. 	digitalWrite (Trig, LOW) ;
    153. }
    154.  
    155.  
    156. void signal_handler(int signum)
    157. {
    158. 	if(i <= angle){
    159. 		digitalWrite(PWM, HIGH);
    160. 	}else{
    161. 		digitalWrite(PWM, LOW);
    162. 	}
    163. 	if(i == 40){ //40*500 = 20000us = 20ms
    164. 		i = 0;
    165. 	}
    166. 	i++;
    167.  
    168. }
    169.  
    170. void *thread1(void *arg) //负责不断检测距离，小于30cm就滴滴开盖的线程
    171. {
    172. 	struct timeval startTime;
    173. 	struct timeval stopTime;
    174. 	double diffTime;
    175. 	//double dist
    176.  
    177. 	while(1){
    178. 		delay(300); //让HC-SR04稳定一下
    179. 		startHC();
    180. 		while(digitalRead(Echo) == 0); //程序会卡在这里直到Echo变高的一瞬间
    181. 		gettimeofday(&startTime,NULL);
    182. 		while(digitalRead(Echo) == 1); //程序会卡在这里直到Echo变低的一瞬间
    183. 		gettimeofday(&stopTime,NULL);
    184.  
    185. 		diffTime = 1000000*(stopTime.tv_sec - startTime.tv_sec) + (stopTime.tv_usec - startTime.tv_usec);
    186. 		dist = 0.034 * diffTime * 0.5;
    187.  
    188. 		//printf("dist = %f---",dist);
    189. 		//fflush(stdout);
    190.  
    191. 		pthread_mutex_lock(&mutex);//对angle值修改需要先上锁
    192.  
    193. 		if(dist < 30 && angle == 1){//当距离小于30且盖子未开
    194. 			angle = 3; //开盖
    195.  
    196. 			create_hist(1,1);//构建一条历史记录
    197. 			strcat(hist_whole,hist);//在总的历史记录中添加刚刚构建的历史记录
    198.  
    199. 			digitalWrite (BEEP, LOW) ;  //蜂鸣器响
    200. 			delay (100) ;      
    201. 			digitalWrite (BEEP, HIGH) ; //蜂鸣器不响
    202. 			delay (100) ;
    203. 			digitalWrite (BEEP, LOW) ;  //蜂鸣器响
    204. 			delay (100) ;      
    205. 			digitalWrite (BEEP, HIGH) ; //蜂鸣器不响
    206.  
    207. 			delay(2000);
    208. 		}else if(dist > 30 && angle == 3){//当距离大于30且盖子打开
    209. 			angle = 1; //关盖
    210.  
    211. 			create_hist(1,2);//构建一条历史记录
    212. 			strcat(hist_whole,hist);//在总的历史记录中添加刚刚构建的历史记录
    213. 		}
    214.  
    215. 		pthread_mutex_unlock(&mutex);
    216.  
    217. 	}
    218.  
    219. 	pthread_exit(NULL);
    220. }
    221.  
    222. void *thread2(void *arg) //负责检测开盖时间，超过10s就报警的线程
    223. {
    224. 	struct timeval startTime;
    225. 	struct timeval stopTime;
    226. 	double diffTime;
    227.  
    228. 	while(1){
    229. 		while(angle == 1);//程序会卡在这里直到盖子打开
    230. 		gettimeofday(&startTime,NULL);
    231. 		while(angle == 3){
    232. 			gettimeofday(&stopTime,NULL);
    233. 			diffTime = (stopTime.tv_sec - startTime.tv_sec) + 1/1000000 *(stopTime.tv_usec - startTime.tv_usec);
    234. 			if(diffTime > 10){ //盖子打开超过10秒
    235. 				digitalWrite (BEEP, LOW) ;  //蜂鸣器响
    236. 				delay (1000) ; //一秒长鸣警报
    237. 				digitalWrite (BEEP, HIGH) ; //蜂鸣器不响
    238. 				break;
    239. 			}
    240. 		}
    241.  
    242. 	}
    243.  
    244. 	pthread_exit(NULL);
    245. }
    246.  
    247. void *thread3(void *arg) //负责不断等待socket客户端接入的线程
    248. {
    249. 	while(1){
    250. 		//accept
    251. 		conn_sockfd = accept(sockfd,(struct sockaddr *)&client_addr,&len);
    252. 		if(conn_sockfd == -1){
    253. 			perror("accept");
    254. 			pthread_exit(NULL);;
    255. 		}else{
    256. 			conn_flag = 1; //保证连接成功后才开始接收
    257. 			printf("accept success, client IP = %s\n",inet_ntoa(client_addr.sin_addr));
    258. 			fflush(stdout);
    259. 		}
    260. 	}
    261.  
    262. 	pthread_exit(NULL);
    263. }
    264.  
    265. void *thread4(void *arg) //负责socket客户端接入后接收处理客户端指令的线程
    266. {
    267. 	while(1){ //切不可直接“while(conn_flag == 1)”，这样在没有接入时会直接退出，要不停的循环查看flag的值
    268. 		while(conn_flag == 1){
    269. 			//read
    270. 			memset(&readbuf,0,sizeof(readbuf));
    271. 			ret = recv(conn_sockfd, &readbuf, sizeof(readbuf), 0);
    272. 			if(ret == 0){ //如果recv函数返回0表示连接已经断开
    273. 				printf("client has quit\n");
    274. 				fflush(stdout);
    275. 				close(conn_sockfd);
    276. 				break;
    277. 			}else if(ret == -1){
    278. 				perror("recv");
    279. 				conn_flag = 0; //此时打印一遍错误信息就会结束，如果不把flag置1，在一个客户端退出另一个客户端还未接入时就会不停的打印错误信息
    280. 				//pthread_exit(NULL); //此处不能退出，因为因为这样如果有一个客户端接入并退出后这个线程就会退出，为了保证一个客户端退出后，另一个客户端还可以接入并正常工作，此处仅显示错误信息而不退出
    281. 			}
    282.  
    283.  
    284. 			pthread_mutex_lock(&mutex);//对angle值修改需要先上锁
    285. 			cmd_handler(conn_sockfd, readbuf); //对客户端发来的消息进行判断的总函数
    286. 			pthread_mutex_unlock(&mutex);
    287.  
    288. 			printf("\nclient: %s\n",readbuf);
    289. 			fflush(stdout);
    290. 		}
    291.  
    292. 	}
    293.  
    294. 	pthread_exit(NULL);
    295. }
    296.  
    297. void *thread5(void *arg) //负责通过串口接收语音模块指令的线程
    298. {
    299. 	char io_readbuf[32] = {'\0'};
    300. 	while(1){
    301. 		while(serialDataAvail (*((int *)arg))){
    302. 			serialGetstring (*((int *)arg),io_readbuf) ;
    303. 			//printf("-> %s\n",io_readbuf);
    304.  
    305. 			pthread_mutex_lock(&mutex);//对angle值修改需要先上锁
    306.  
    307. 			if(strcmp(io_readbuf,"open") == 0 && angle == 1){ //当收到open指令且盖子关闭时
    308. 				angle = 3; //开盖
    309.  
    310. 				create_hist(3,1);//构建一条历史记录
    311. 				strcat(hist_whole,hist);//在总的历史记录中添加刚刚构建的历史记录
    312.  
    313. 				digitalWrite (BEEP, LOW) ;  //蜂鸣器响
    314. 				delay (100) ;
    315. 				digitalWrite (BEEP, HIGH) ; //蜂鸣器不响
    316. 				delay (100) ;
    317. 				digitalWrite (BEEP, LOW) ;  //蜂鸣器响
    318. 				delay (100) ;
    319. 				digitalWrite (BEEP, HIGH) ; //蜂鸣器不响
    320.  
    321. 				delay(2000);//延时2秒
    322. 			}else if(strcmp(io_readbuf,"close") == 0 && angle == 3){//当收到close指令且盖子打开时
    323. 				angle = 1; //关盖
    324.  
    325. 				create_hist(3,2);//构建一条历史记录
    326. 				strcat(hist_whole,hist);//在总的历史记录中添加刚刚构建的历史记录
    327.  
    328. 				delay(2000);//延时2秒
    329. 			}else if(strcmp(io_readbuf,"open") == 0 && angle == 3){
    330. 				printf("already open\n");
    331. 				fflush(stdout);
    332. 			}else if(strcmp(io_readbuf,"close") == 0 && angle == 1){
    333. 				printf("already close\n");
    334. 				fflush(stdout);
    335. 			}else{
    336. 				printf("unkown command\n");
    337. 				fflush(stdout);
    338. 			}
    339.  
    340. 			pthread_mutex_unlock(&mutex);
    341.  
    342. 			memset(io_readbuf,'\0',32);
    343. 		}
    344. 	}
    345.  
    346. 	pthread_exit(NULL);
    347. }
    348.  
    349. void *thread6(void *arg) //负责每隔一段时间写入历史记录的线程
    350. {
    351. 	struct timeval startTime;
    352.     struct timeval stopTime;
    353.     double diffTime;
    354. 	int hist_fd; // file description
    355.  
    356. 	while(1){
    357. 		gettimeofday(&startTime,NULL);
    358. 		while(1){
    359.         	gettimeofday(&stopTime,NULL);
    360.         	diffTime = (stopTime.tv_sec - startTime.tv_sec) + 1/1000000 *(stopTime.tv_usec - startTime.tv_usec); //单位为秒
    361. 			if(diffTime > 60){//如果时间是2分钟,由于线程的竞争机制，不一定会非常精确，所以使用>号
    362. 				hist_fd = open("./history.txt",O_RDWR|O_CREAT|O_APPEND, 0666); //可读可写可打开的打开历史记录的文件，不存在就创建，且每次都追加写入
    363. 				if(hist_fd < 0){
    364. 					printf("fail to open history file!\n");
    365.                     fflush(stdout);
    366. 				}
    367. 				ret = write(hist_fd, &hist_whole, strlen(hist_whole));
    368. 				if(ret == -1){
    369. 					printf("fail to write history write to file!\n");
    370. 					fflush(stdout);
    371. 				}else{
    372. 					printf("write the following history write to file:\n");
    373. 					printf("------------------------\n");
    374. 					printf("%s",hist_whole);
    375. 					printf("------------------------\n");
    376.                     fflush(stdout);
    377. 				}
    378. 				close(hist_fd);
    379. 				memset(hist_whole,'\0',sizeof(hist_whole)); //清空hist_whole!
    380.             	break;
    381. 			}
    382. 		}
    383. 	}
    384.  
    385. 	pthread_exit(NULL);
    386. }
    387.  
    388.  
    389. int main(int argc, char **argv)
    390. {
    391. 	struct itimerval itv;
    392. 	int io_fd;
    393.  
    394. 	pthread_t t1_id;
    395. 	pthread_t t2_id;
    396. 	pthread_t t3_id;
    397. 	pthread_t t4_id;
    398. 	pthread_t t5_id;
    399. 	pthread_t t6_id;
    400.  
    401. 	memset(&my_addr,0,sizeof(struct sockaddr_in));
    402. 	memset(&client_addr,0,sizeof(struct sockaddr_in));
    403.  
    404.  
    405. 	if(argc != 3){
    406. 		printf("param error!\n");
    407. 		return 1;
    408. 	}
    409.  
    410. 	wiringPiSetup () ;
    411. 	pinMode (PWM, OUTPUT);
    412. 	pinMode (Trig, OUTPUT);
    413. 	pinMode (Echo, INPUT);
    414. 	pinMode (BEEP, OUTPUT);
    415.  
    416. 	digitalWrite (Trig, LOW) ;
    417. 	digitalWrite (Echo, LOW) ;
    418. 	digitalWrite (BEEP, HIGH) ;
    419.  
    420. 	//设定定时时间
    421. 	itv.it_interval.tv_sec = 0;
    422. 	itv.it_interval.tv_usec = 500;
    423. 	//设定开始生效，启动定时器的时间
    424. 	itv.it_value.tv_sec = 1;
    425. 	itv.it_value.tv_usec = 0;
    426.  
    427. 	//设定定时方式
    428. 	if( -1 == setitimer(ITIMER_REAL, &itv, NULL)){
    429. 		perror("error");
    430. 		exit(-1);
    431. 	}
    432.  
    433. 	//信号处理
    434. 	signal(SIGALRM,signal_handler);
    435.  
    436. 	angle = 1;//初始化角度为关盖
    437.  
    438. 	//打开串口驱动文件，配置波特率
    439. 	if ((io_fd = myserialOpen ("/dev/ttyS5", 115200)) < 0)	{
    440. 		fprintf (stderr, "Unable to open serial device: %s\n", strerror (errno)) ;
    441. 		return 1 ;
    442. 	}
    443.  
    444. 	//socket
    445. 	sockfd = socket(AF_INET,SOCK_STREAM,0);
    446. 	if(sockfd == -1){
    447. 		perror("socket");
    448. 		return 1;
    449. 	}else{
    450. 		printf("socket success, sockfd = %d\n",sockfd);
    451. 	}
    452.  
    453. 	//bind
    454. 	my_addr.sin_family = AF_INET;
    455. 	my_addr.sin_port = htons(atoi(argv[2]));//host to net (2 bytes)
    456. 	inet_aton(argv[1],&my_addr.sin_addr); //char* format -> net format
    457.  
    458. 	ret = bind(sockfd, (struct sockaddr *)&my_addr, len);
    459. 	if(ret == -1){
    460. 		perror("bind");
    461. 		return 1;
    462. 	}else{
    463. 		printf("bind success\n");
    464. 	}
    465.  
    466. 	//listen
    467. 	ret = listen(sockfd,10);
    468. 	if(ret == -1){
    469. 		perror("listen");
    470. 		return 1;
    471. 	}else{
    472. 		printf("listening...\n");
    473. 	}
    474.  
    475. 	ret = pthread_mutex_init(&mutex, NULL);
    476. 	if(ret != 0){
    477. 		printf("mutex create error\n");
    478. 	}
    479.  
    480. 	ret = pthread_create(&t1_id,NULL,thread1,NULL);
    481. 	if(ret != 0){
    482. 		printf("thread1 create error\n");
    483. 	}
    484. 	ret = pthread_create(&t2_id,NULL,thread2,NULL);
    485. 	if(ret != 0){
    486. 		printf("thread2 create error\n");
    487. 	}
    488. 	ret = pthread_create(&t3_id,NULL,thread3,NULL);
    489. 	if(ret != 0){
    490. 		printf("thread3 create error\n");
    491. 	}
    492. 	ret = pthread_create(&t4_id,NULL,thread4,NULL);
    493. 	if(ret != 0){
    494. 		printf("thread4 create error\n");
    495. 	}
    496. 	ret = pthread_create(&t5_id,NULL,thread5,(void *)&io_fd);
    497. 	if(ret != 0){
    498. 		printf("thread5 create error\n");
    499. 	}
    500. 	ret = pthread_create(&t6_id,NULL,thread6,NULL);
    501. 	if(ret != 0){
    502. 		printf("thread6 create error\n");
    503. 	}
    504.  
    505.  
    506. 	pthread_join(t1_id,NULL);
    507. 	pthread_join(t2_id,NULL);
    508. 	pthread_join(t3_id,NULL);
    509. 	pthread_join(t4_id,NULL);
    510. 	pthread_join(t5_id,NULL);
    511. 	pthread_join(t6_id,NULL);
    512.  
    513. 	return 0;
    514. }

    实现效果

    由于测试需要，我将代码修改为每隔1分钟向文件写入并在屏幕上打印历史记录，如果需要实现每隔5分钟，1小时，1天，只需要修改thread6里difftime的判断条件即可！

    编译并运行代码：

    gcc mjm_uart_tool.c v4_server.c -lwiringPi -lwiringPiDev -lpthread -lm -lcrypt -lrt -o v4_server

    然后接入v2_client，模拟各种操作，包括距离接近开关盖；客户端指令开关盖；语音控制开关盖....

    可见，每隔一分钟，就会生成这一分钟内的所有历史记录并打印在屏幕上： 

    同时，打开该路径下新创建的“history.txt” ，可见历史记录已追加的方式不断写入：

    需求7 --- 使用嵌入式数据库实现开关盖的历史记录

    回顾需求：

    统计一段时间内垃圾桶开关盖次数及开关盖指令来源并记录在数据库中

    回顾之前学习嵌入式数据库的博文：

    使用香橙派学习 嵌入式数据库---SQLite-CSDN博客

    注意，虽然同样是历史记录，但是写入文件的是详细的每一次的记录，而写入数据库的是开关盖次数和指令来源的统计！

    思路是创建一个名为history的数据库，然后在其中创建一个名为history的表格，表格有三个字段，分别为char型的cause；Integer型的open；Integer型的close

    然后分别就每一种指令形式创建开关盖的计数量，在刚刚的thread6计时时间到了只后统一通过sprintf构建sql指令字符串写入数据库

    代码展示（client的代码不需要更新）

    v5_server.c：
    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8.  
    9. #include 
    10. #include 
    11. #include 
    12. #include 
    13. #include 
    14. #include 
    15. #include 
    16. #include 
    17. #include 
    18. #include 
    19.  
    20. #include 
    21. #include 
    22. #include 
    23. #include 
    24. #include "mjm_uart_tool.h"
    25.  
    26. #include 
    27.  
    28. #define PWM 5
    29. #define BEEP 2
    30. #define Trig 9
    31. #define Echo 10
    32.  
    33. int angle;
    34. double dist;
    35. static int i;
    36.  
    37. int sockfd;
    38. int conn_sockfd;
    39. int len = sizeof(struct sockaddr_in);
    40. int ret;
    41. char readbuf[128];
    42. struct sockaddr_in my_addr;
    43. struct sockaddr_in client_addr;
    44. static int conn_flag;
    45. char hist[128] = {0}; //用于存放一条历史记录,注意这个变量一定不能在create_hist里赋值，因为局部指针变量作为函数的返回值没有意义，会报错; 且作为strcat的对象必须是字符串变量
    46. char hist_whole[10000] = {0}; //用于存放所有历史记录; 且作为strcat的对象必须是字符串变量
    47. sqlite3 *db;
    48. char *zErrMsg = 0;
    49. int dist_open_count = 0;
    50. int dist_close_count = 0;
    51. int sock_open_count = 0;
    52. int sock_close_count = 0;
    53. int soun_open_count = 0;
    54. int soun_close_count = 0;
    55.  
    56. pthread_mutex_t mutex;
    57.  
    58. int callback(void *arg, int column_size, char *column_value[], char *column_name[]) //数据库exec函数对应的callback函数
    59. {
    60. 	int j;
    61. 	//printf("arg=%s\n",(char *)arg);
    62.  
    63. 	for(j=0;j
    64. 		printf("%s = %s\n", column_name[j], column_value[j]);
    65. 		fflush(stdout); //由于callback可能在线程运行中被调用,所以这句话不能忘
    66. 	}
    67. 	printf("=======================\n");
    68. 	fflush(stdout);
    69. 	return 0;//必须返回0，这样数据库中有多少条数据,这个回调函数就会被调用多少次
    70. }
    71.  
    72. void init_table() //用于初始化数据库中表格的值
    73. {
    74. 	char *init_table_sql;
    75.  
    76. 	init_table_sql = "insert into history values('dist',0,0);";
    77. 	ret = sqlite3_exec(db, init_table_sql, callback, 0, &zErrMsg);
    78. 	if(ret != SQLITE_OK){
    79. 		printf("Can't init table value: %s\n", sqlite3_errmsg(db));
    80. 	}
    81. 	init_table_sql = "insert into history values('socket',0,0);";
    82. 	ret = sqlite3_exec(db, init_table_sql, callback, 0, &zErrMsg);
    83. 	if(ret != SQLITE_OK){
    84. 		printf("Can't init table value: %s\n", sqlite3_errmsg(db));
    85. 	}
    86. 	init_table_sql = "insert into history values('sound',0,0);";
    87. 	ret = sqlite3_exec(db, init_table_sql, callback, 0, &zErrMsg);
    88. 	if(ret != SQLITE_OK){
    89. 		printf("Can't init table value: %s\n", sqlite3_errmsg(db));
    90. 	}
    91.  
    92. }
    93.  
    94. void write2file() //将历史记录写入文件的函数
    95. {
    96. 	int hist_fd; // file description
    97.  
    98. 	hist_fd = open("./history.txt",O_RDWR|O_CREAT|O_APPEND, 0666); //可读可写可打开的打开历史记录的文件，不存在就创建，且每次都追加写入
    99. 	if(hist_fd < 0){
    100. 		printf("fail to open history file!\n");
    101. 		fflush(stdout);
    102. 	}
    103. 	ret = write(hist_fd, &hist_whole, strlen(hist_whole));
    104. 	if(ret == -1){
    105. 		printf("fail to write history write to file!\n");
    106. 		fflush(stdout);
    107. 	}else{
    108. 		printf("write history to file successfully!\n");
    109. 		/*printf("write the following history to file:\n");
    110. 		  printf("------------------------\n");
    111. 		  printf("%s",hist_whole);
    112. 		  printf("------------------------\n");*/
    113. 		fflush(stdout);
    114. 	}
    115. 	close(hist_fd);
    116. 	memset(hist_whole,'\0',sizeof(hist_whole)); //清空hist_whole!
    117.  
    118. }
    119.  
    120. void write2sql() //将历史记录写入数据库的函数
    121. {
    122. 	char update_sql[128] = {'\0'};
    123.  
    124. 	sprintf(update_sql,"update history set open = %d, close = %d where cause = 'dist';",dist_open_count, dist_close_count);
    125. 	ret = sqlite3_exec(db, (const char *)update_sql, callback, 0, &zErrMsg);
    126. 	if(ret != SQLITE_OK){ 
    127. 		printf("Can't update date: %s\n", sqlite3_errmsg(db));
    128. 	}
    129. 	sprintf(update_sql,"update history set open = %d, close = %d where cause = 'socket';",sock_open_count, sock_close_count);
    130.     ret = sqlite3_exec(db, (const char *)update_sql, callback, 0, &zErrMsg);
    131.     if(ret != SQLITE_OK){
    132.         printf("Can't update date: %s\n", sqlite3_errmsg(db));
    133.     }
    134. 	sprintf(update_sql,"update history set open = %d, close = %d where cause = 'sound';",soun_open_count, soun_close_count);
    135.     ret = sqlite3_exec(db, (const char *)update_sql, callback, 0, &zErrMsg);
    136.     if(ret != SQLITE_OK){
    137.         printf("Can't update date: %s\n", sqlite3_errmsg(db));
    138.     }
    139.  
    140.  
    141. 	ret = sqlite3_exec(db, "select * from history;", callback, 0, &zErrMsg); //将数据库数据打印到屏幕
    142. 	if(ret != SQLITE_OK){
    143. 		printf("Can't show date: %s\n", sqlite3_errmsg(db));
    144. 	}
    145. 	dist_open_count = 0;
    146. 	dist_close_count = 0;
    147. 	sock_open_count = 0;
    148. 	sock_close_count = 0;
    149. 	soun_open_count = 0;
    150. 	soun_close_count = 0;
    151. }
    152.  
    153. char *create_hist(int type, int action)//用于生成一条历史记录的函数
    154. 	//type的值1;2;3分别对应距离靠近开盖;客户端指令开盖;语音识别开盖
    155. 	//action的值1;2分别对应开盖;关盖
    156. {
    157. 	FILE *fp;
    158. 	char *dist = "||distance close||";
    159. 	char *sock = "||client request||";
    160. 	char *soun = "||voice  command||";
    161. 	char *open = "open action||";
    162. 	char *close = "close action||";
    163. 	char *c = "\n";
    164.  
    165. 	memset(&hist,'\0',sizeof(hist));
    166. 	fp = popen("date +\"%Y-%m-%d %H:%M:%S\"","r");
    167. 	fread(&hist, sizeof(char), 128, fp);
    168.  
    169. 	if(type == 1){ //如果时距离靠近导致的开关盖
    170. 		strcat(hist,dist); 
    171. 	}else if(type == 2){ //如果是客户端指令导致的开关盖
    172. 		strcat(hist,sock);
    173. 	}else if(type == 3){ //如果是语音识别导致的开关盖
    174. 		strcat(hist,soun);
    175. 	}
    176.  
    177. 	if(action == 1){
    178. 		strcat(hist,open);
    179. 	}else if(action == 2){
    180. 		strcat(hist,close);
    181. 	}
    182.  
    183. 	strcat(hist,c);//每条历史记录结束加上一个换行键
    184.  
    185. 	return (char *)hist;
    186.  
    187. }
    188.  
    189. int cmd_handler(int fd, char readbuf[128])
    190. {
    191. 	int ret;
    192. 	int i = 0;
    193. 	char str[128]; //将读到的数据备份在这里
    194.  
    195. 	strcpy(str,readbuf); //由于字符串的首地址是字符串的名字，所以此时相当于传入的地址，所有对字符串的操作都会影响它，所以需要进行备份，先备份再对备份的数据进行数据处理就不会影响原数据了
    196. 	if(strcmp((char *)str,"open")==0 && angle == 1){ //收到open指令时垃圾桶盖子是关着的
    197. 		ret = write(fd,"open success",20);
    198. 		if(ret == -1){
    199. 			perror("write");
    200. 			pthread_exit(NULL);
    201. 		}
    202. 		angle = 3;
    203.  
    204. 		sock_open_count++;
    205. 		create_hist(2,1);//构建一条历史记录
    206. 		strcat(hist_whole,hist);//在总的历史记录中添加刚刚构建的历史记录
    207.  
    208. 		digitalWrite (BEEP, LOW) ;  //蜂鸣器响
    209. 		delay (100) ;
    210. 		digitalWrite (BEEP, HIGH) ; //蜂鸣器不响
    211. 		delay (100) ;
    212. 		digitalWrite (BEEP, LOW) ;  //蜂鸣器响
    213. 		delay (100) ;
    214. 		digitalWrite (BEEP, HIGH) ; //蜂鸣器不响
    215.  
    216. 		delay(2000);//延时2秒
    217. 	}else if(strcmp((char *)str,"open")==0 && angle == 3){  //收到open指令时垃圾桶盖子是开着的
    218. 		ret = write(fd,"already open!",20);
    219. 		if(ret == -1){
    220. 			perror("write");
    221. 			pthread_exit(NULL);
    222. 		}
    223. 	}else if(strcmp((char *)str,"close")==0 && angle == 3){ //收到close指令时垃圾桶盖子是开着的
    224. 		ret = write(fd,"close success",20);
    225. 		if(ret == -1){
    226. 			perror("write");
    227. 			pthread_exit(NULL);
    228. 		}
    229. 		angle = 1;
    230.  
    231. 		sock_close_count++;
    232. 		create_hist(2,2);//构建一条历史记录
    233. 		strcat(hist_whole,hist);//在总的历史记录中添加刚刚构建的历史记录
    234.  
    235. 		delay(2000);//延时2秒
    236. 	}else if(strcmp((char *)str,"close")==0 && angle == 1){ //收到close指令时垃圾桶盖子是关着的
    237. 		ret = write(fd,"already close!",20);
    238. 		if(ret == -1){
    239. 			perror("write");
    240. 			pthread_exit(NULL);
    241. 		}
    242. 	}else if(strcmp((char *)str,"quit")==0){ //如果客户端打出了quit
    243. 		ret = write(fd,"Bye",4); //立刻回发一个Bye，目的是让客户端取消接收阻塞然后成功从FIFO读取到退出信息
    244. 		if(ret == -1){
    245. 			perror("write");
    246. 			pthread_exit(NULL);
    247. 		}
    248. 	}
    249. }
    250.  
    251.  
    252. void startHC() //先要给Trig一个至少10us/ms的高电平方波
    253. {
    254. 	digitalWrite (Trig, LOW) ;
    255. 	delay(5); //5ms
    256. 	digitalWrite (Trig, HIGH) ;
    257. 	delay(5);
    258. 	delay(5);
    259. 	digitalWrite (Trig, LOW) ;
    260. }
    261.  
    262.  
    263. void signal_handler(int signum)
    264. {
    265. 	if(i <= angle){
    266. 		digitalWrite(PWM, HIGH);
    267. 	}else{
    268. 		digitalWrite(PWM, LOW);
    269. 	}
    270. 	if(i == 40){ //40*500 = 20000us = 20ms
    271. 		i = 0;
    272. 	}
    273. 	i++;
    274.  
    275. }
    276.  
    277. void *thread1(void *arg) //负责不断检测距离，小于30cm就滴滴开盖的线程
    278. {
    279. 	struct timeval startTime;
    280. 	struct timeval stopTime;
    281. 	double diffTime;
    282. 	//double dist
    283.  
    284. 	while(1){
    285. 		delay(300); //让HC-SR04稳定一下
    286. 		startHC();
    287. 		while(digitalRead(Echo) == 0); //程序会卡在这里直到Echo变高的一瞬间
    288. 		gettimeofday(&startTime,NULL);
    289. 		while(digitalRead(Echo) == 1); //程序会卡在这里直到Echo变低的一瞬间
    290. 		gettimeofday(&stopTime,NULL);
    291.  
    292. 		diffTime = 1000000*(stopTime.tv_sec - startTime.tv_sec) + (stopTime.tv_usec - startTime.tv_usec);
    293. 		dist = 0.034 * diffTime * 0.5;
    294.  
    295. 		//printf("dist = %f---",dist);
    296. 		//fflush(stdout);
    297.  
    298. 		pthread_mutex_lock(&mutex);//对angle值修改需要先上锁
    299.  
    300. 		if(dist < 30 && angle == 1){//当距离小于30且盖子未开
    301. 			angle = 3; //开盖
    302.  
    303. 			dist_open_count++;
    304. 			create_hist(1,1);//构建一条历史记录
    305. 			strcat(hist_whole,hist);//在总的历史记录中添加刚刚构建的历史记录
    306.  
    307. 			digitalWrite (BEEP, LOW) ;  //蜂鸣器响
    308. 			delay (100) ;      
    309. 			digitalWrite (BEEP, HIGH) ; //蜂鸣器不响
    310. 			delay (100) ;
    311. 			digitalWrite (BEEP, LOW) ;  //蜂鸣器响
    312. 			delay (100) ;      
    313. 			digitalWrite (BEEP, HIGH) ; //蜂鸣器不响
    314.  
    315. 			delay(2000);
    316. 		}else if(dist > 30 && angle == 3){//当距离大于30且盖子打开
    317. 			angle = 1; //关盖
    318.  
    319. 			dist_close_count++;
    320. 			create_hist(1,2);//构建一条历史记录
    321. 			strcat(hist_whole,hist);//在总的历史记录中添加刚刚构建的历史记录
    322. 		}
    323.  
    324. 		pthread_mutex_unlock(&mutex);
    325.  
    326. 	}
    327.  
    328. 	pthread_exit(NULL);
    329. }
    330.  
    331. void *thread2(void *arg) //负责检测开盖时间，超过10s就报警的线程
    332. {
    333. 	struct timeval startTime;
    334. 	struct timeval stopTime;
    335. 	double diffTime;
    336.  
    337. 	while(1){
    338. 		while(angle == 1);//程序会卡在这里直到盖子打开
    339. 		gettimeofday(&startTime,NULL);
    340. 		while(angle == 3){
    341. 			gettimeofday(&stopTime,NULL);
    342. 			diffTime = (stopTime.tv_sec - startTime.tv_sec) + 1/1000000 *(stopTime.tv_usec - startTime.tv_usec);
    343. 			if(diffTime > 10){ //盖子打开超过10秒
    344. 				digitalWrite (BEEP, LOW) ;  //蜂鸣器响
    345. 				delay (1000) ; //一秒长鸣警报
    346. 				digitalWrite (BEEP, HIGH) ; //蜂鸣器不响
    347. 				break;
    348. 			}
    349. 		}
    350.  
    351. 	}
    352.  
    353. 	pthread_exit(NULL);
    354. }
    355.  
    356. void *thread3(void *arg) //负责不断等待socket客户端接入的线程
    357. {
    358. 	while(1){
    359. 		//accept
    360. 		conn_sockfd = accept(sockfd,(struct sockaddr *)&client_addr,&len);
    361. 		if(conn_sockfd == -1){
    362. 			perror("accept");
    363. 			pthread_exit(NULL);;
    364. 		}else{
    365. 			conn_flag = 1; //保证连接成功后才开始接收
    366. 			printf("accept success, client IP = %s\n",inet_ntoa(client_addr.sin_addr));
    367. 			fflush(stdout);
    368. 		}
    369. 	}
    370.  
    371. 	pthread_exit(NULL);
    372. }
    373.  
    374. void *thread4(void *arg) //负责socket客户端接入后接收处理客户端指令的线程
    375. {
    376. 	while(1){ //切不可直接“while(conn_flag == 1)”，这样在没有接入时会直接退出，要不停的循环查看flag的值
    377. 		while(conn_flag == 1){
    378. 			//read
    379. 			memset(&readbuf,0,sizeof(readbuf));
    380. 			ret = recv(conn_sockfd, &readbuf, sizeof(readbuf), 0);
    381. 			if(ret == 0){ //如果recv函数返回0表示连接已经断开
    382. 				printf("client has quit\n");
    383. 				fflush(stdout);
    384. 				close(conn_sockfd);
    385. 				break;
    386. 			}else if(ret == -1){
    387. 				perror("recv");
    388. 				conn_flag = 0; //此时打印一遍错误信息就会结束，如果不把flag置1，在一个客户端退出另一个客户端还未接入时就会不停的打印错误信息
    389. 				//pthread_exit(NULL); //此处不能退出，因为因为这样如果有一个客户端接入并退出后这个线程就会退出，为了保证一个客户端退出后，另一个客户端还可以接入并正常工作，此处仅显示错误信息而不退出
    390. 			}
    391.  
    392.  
    393. 			pthread_mutex_lock(&mutex);//对angle值修改需要先上锁
    394. 			cmd_handler(conn_sockfd, readbuf); //对客户端发来的消息进行判断的总函数
    395. 			pthread_mutex_unlock(&mutex);
    396.  
    397. 			printf("\nclient: %s\n",readbuf);
    398. 			fflush(stdout);
    399. 		}
    400.  
    401. 	}
    402.  
    403. 	pthread_exit(NULL);
    404. }
    405.  
    406. void *thread5(void *arg) //负责通过串口接收语音模块指令的线程
    407. {
    408. 	char io_readbuf[32] = {'\0'};
    409. 	while(1){
    410. 		while(serialDataAvail (*((int *)arg))){
    411. 			serialGetstring (*((int *)arg),io_readbuf) ;
    412. 			//printf("-> %s\n",io_readbuf);
    413.  
    414. 			pthread_mutex_lock(&mutex);//对angle值修改需要先上锁
    415.  
    416. 			if(strcmp(io_readbuf,"open") == 0 && angle == 1){ //当收到open指令且盖子关闭时
    417. 				angle = 3; //开盖
    418.  
    419. 				soun_open_count++;
    420. 				create_hist(3,1);//构建一条历史记录
    421. 				strcat(hist_whole,hist);//在总的历史记录中添加刚刚构建的历史记录
    422.  
    423. 				digitalWrite (BEEP, LOW) ;  //蜂鸣器响
    424. 				delay (100) ;
    425. 				digitalWrite (BEEP, HIGH) ; //蜂鸣器不响
    426. 				delay (100) ;
    427. 				digitalWrite (BEEP, LOW) ;  //蜂鸣器响
    428. 				delay (100) ;
    429. 				digitalWrite (BEEP, HIGH) ; //蜂鸣器不响
    430.  
    431. 				delay(2000);//延时2秒
    432. 			}else if(strcmp(io_readbuf,"close") == 0 && angle == 3){//当收到close指令且盖子打开时
    433. 				angle = 1; //关盖
    434.  
    435. 				soun_close_count++;
    436. 				create_hist(3,2);//构建一条历史记录
    437. 				strcat(hist_whole,hist);//在总的历史记录中添加刚刚构建的历史记录
    438.  
    439. 				delay(2000);//延时2秒
    440. 			}else if(strcmp(io_readbuf,"open") == 0 && angle == 3){
    441. 				printf("already open\n");
    442. 				fflush(stdout);
    443. 			}else if(strcmp(io_readbuf,"close") == 0 && angle == 1){
    444. 				printf("already close\n");
    445. 				fflush(stdout);
    446. 			}else{
    447. 				printf("unkown command\n");
    448. 				fflush(stdout);
    449. 			}
    450.  
    451. 			pthread_mutex_unlock(&mutex);
    452.  
    453. 			memset(io_readbuf,'\0',32);
    454. 		}
    455. 	}
    456.  
    457. 	pthread_exit(NULL);
    458. }
    459.  
    460. void *thread6(void *arg) //负责每隔一段时间向文件和数据库写入历史记录的线程
    461. {
    462. 	struct timeval startTime;
    463. 	struct timeval stopTime;
    464. 	double diffTime;
    465.  
    466. 	while(1){
    467. 		gettimeofday(&startTime,NULL);
    468. 		while(1){
    469. 			gettimeofday(&stopTime,NULL);
    470. 			diffTime = (stopTime.tv_sec - startTime.tv_sec) + 1/1000000 *(stopTime.tv_usec - startTime.tv_usec); //单位为秒
    471. 			if(diffTime > 60){//如果时间是2分钟,由于线程的竞争机制，不一定会非常精确，所以使用>号				
    472. 				write2file();//将历史记录写入文件
    473. 				write2sql();//将历史记录写入数据库
    474. 				break;
    475. 			}
    476. 		}
    477. 	}
    478.  
    479. 	pthread_exit(NULL);
    480. }
    481.  
    482.  
    483. int main(int argc, char **argv)
    484. {
    485. 	struct itimerval itv;
    486. 	int io_fd;
    487. 	char *create_table_sql;
    488.  
    489. 	pthread_t t1_id;
    490. 	pthread_t t2_id;
    491. 	pthread_t t3_id;
    492. 	pthread_t t4_id;
    493. 	pthread_t t5_id;
    494. 	pthread_t t6_id;
    495.  
    496. 	memset(&my_addr,0,sizeof(struct sockaddr_in));
    497. 	memset(&client_addr,0,sizeof(struct sockaddr_in));
    498.  
    499.  
    500. 	if(argc != 3){
    501. 		printf("param error!\n");
    502. 		return 1;
    503. 	}
    504.  
    505. 	wiringPiSetup () ;
    506. 	pinMode (PWM, OUTPUT);
    507. 	pinMode (Trig, OUTPUT);
    508. 	pinMode (Echo, INPUT);
    509. 	pinMode (BEEP, OUTPUT);
    510.  
    511. 	digitalWrite (Trig, LOW) ;
    512. 	digitalWrite (Echo, LOW) ;
    513. 	digitalWrite (BEEP, HIGH) ;
    514.  
    515. 	//设定定时时间
    516. 	itv.it_interval.tv_sec = 0;
    517. 	itv.it_interval.tv_usec = 500;
    518. 	//设定开始生效，启动定时器的时间
    519. 	itv.it_value.tv_sec = 1;
    520. 	itv.it_value.tv_usec = 0;
    521.  
    522. 	//设定定时方式
    523. 	if( -1 == setitimer(ITIMER_REAL, &itv, NULL)){
    524. 		perror("error");
    525. 		exit(-1);
    526. 	}
    527.  
    528. 	//信号处理
    529. 	signal(SIGALRM,signal_handler);
    530.  
    531. 	angle = 1;//初始化角度为关盖
    532.  
    533. 	//打开串口驱动文件，配置波特率
    534. 	if ((io_fd = myserialOpen ("/dev/ttyS5", 115200)) < 0)	{
    535. 		fprintf (stderr, "Unable to open serial device: %s\n", strerror (errno)) ;
    536. 		return 1 ;
    537. 	}
    538.  
    539. 	//打开数据库
    540. 	ret = sqlite3_open("history.db", &db);
    541.  
    542. 	if(ret != SQLITE_OK){
    543. 		printf("Can't open database: %s\n", sqlite3_errmsg(db));
    544. 		exit(0);
    545. 	}else{
    546. 		printf("Open database successfully\n");
    547. 	}
    548.  
    549. 	//创建表格
    550. 	//create_table_sql = "create table history(cause char,open Integer,close Integer);";
    551. 	create_table_sql = "CREATE TABLE HISTORY(" \
    552. 					   "CAUSE CHAR(30) PRIMARY KEY NOT NULL," \
    553. 					   "OPEN INT NOT NULL," \
    554. 					   "CLOSE INT NOT NULL );" ;
    555.  
    556. 	ret = sqlite3_exec(db, create_table_sql, callback, 0, &zErrMsg);
    557. 	if(ret != SQLITE_OK){
    558. 		printf("Can't create table: %s\n", sqlite3_errmsg(db));
    559. 		//exit(0);
    560. 	}else{
    561. 		printf("Table create successfully\n");
    562. 	}
    563.  
    564. 	//初始化表格数据
    565. 	init_table();
    566.  
    567. 	//socket
    568. 	sockfd = socket(AF_INET,SOCK_STREAM,0);
    569. 	if(sockfd == -1){
    570. 		perror("socket");
    571. 		return 1;
    572. 	}else{
    573. 		printf("socket success, sockfd = %d\n",sockfd);
    574. 	}
    575.  
    576. 	//bind
    577. 	my_addr.sin_family = AF_INET;
    578. 	my_addr.sin_port = htons(atoi(argv[2]));//host to net (2 bytes)
    579. 	inet_aton(argv[1],&my_addr.sin_addr); //char* format -> net format
    580.  
    581. 	ret = bind(sockfd, (struct sockaddr *)&my_addr, len);
    582. 	if(ret == -1){
    583. 		perror("bind");
    584. 		return 1;
    585. 	}else{
    586. 		printf("bind success\n");
    587. 	}
    588.  
    589. 	//listen
    590. 	ret = listen(sockfd,10);
    591. 	if(ret == -1){
    592. 		perror("listen");
    593. 		return 1;
    594. 	}else{
    595. 		printf("listening...\n");
    596. 	}
    597.  
    598. 	ret = pthread_mutex_init(&mutex, NULL);
    599. 	if(ret != 0){
    600. 		printf("mutex create error\n");
    601. 	}
    602.  
    603. 	ret = pthread_create(&t1_id,NULL,thread1,NULL);
    604. 	if(ret != 0){
    605. 		printf("thread1 create error\n");
    606. 	}
    607. 	ret = pthread_create(&t2_id,NULL,thread2,NULL);
    608. 	if(ret != 0){
    609. 		printf("thread2 create error\n");
    610. 	}
    611. 	ret = pthread_create(&t3_id,NULL,thread3,NULL);
    612. 	if(ret != 0){
    613. 		printf("thread3 create error\n");
    614. 	}
    615. 	ret = pthread_create(&t4_id,NULL,thread4,NULL);
    616. 	if(ret != 0){
    617. 		printf("thread4 create error\n");
    618. 	}
    619. 	ret = pthread_create(&t5_id,NULL,thread5,(void *)&io_fd);
    620. 	if(ret != 0){
    621. 		printf("thread5 create error\n");
    622. 	}
    623. 	ret = pthread_create(&t6_id,NULL,thread6,NULL);
    624. 	if(ret != 0){
    625. 		printf("thread6 create error\n");
    626. 	}
    627.  
    628.  
    629. 	pthread_join(t1_id,NULL);
    630. 	pthread_join(t2_id,NULL);
    631. 	pthread_join(t3_id,NULL);
    632. 	pthread_join(t4_id,NULL);
    633. 	pthread_join(t5_id,NULL);
    634. 	pthread_join(t6_id,NULL);
    635.  
    636. 	return 0;
    637. }

    实现效果

    由于使用了SQL数据库，不要忘了链上“-lsqlite3”：

    gcc mjm_uart_tool.c v5_server.c -lwiringPi -lwiringPiDev -lpthread -lm -lcrypt -lrt -lsqlite3 -o v5_server

    且此处为了让屏幕显示不要太乱，且关于写入历史记录文件的代码已经证明了没问题，所以我将“把写入历史记录文件的历史记录打印到屏幕上” 的功能注释掉了

    然后接入v2_client，模拟各种操作，包括距离接近开关盖；客户端指令开关盖；语音控制开关盖....

    可见，每隔一分钟，就会统计这一分钟内的开关盖记录和来源并打印表格在屏幕上： 

    进入sql环境验证：

    发现确实写入数据库成功！！

  • 相关阅读:
    电视剧里的代码真能运行吗？
    【Node.js实战】一文带你开发博客项目（API 对接 MySQL）
    轻量级分布式协调工具Etcd介绍和使用
    第三十二节——组合式API计算属性+watch
    常用自动化运维工具简介和Ansible安装
    R语言dplyr包summarise_at函数计算dataframe数据中多个数据列（通过向量指定）的方差
    SOS救命，我怎么没早看到这个测试面试答案（完整答案版）
    Leetcode 137. Single Number II (Python)
    C++ Reference: Standard C++ Library reference: C Library: cmath: scalbln
    深入理解Pod对象：基本管理
  • 原文地址：https://blog.csdn.net/mjmmm/article/details/133446171