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

使用香橙派并基于Linux实现最终版智能垃圾桶项目 --- 上_香橙派 ir-keytable_香橙派 面试

作者：2023面试高手 | 2024-06-06 18:00:25

赞

踩

香橙派 面试

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Linux运维全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。
img
img
img
img
img

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上运维知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip1024b （备注运维）
img

正文


#### 


#### 实现效果：


编译两个C文件：


![](https://img-blog.csdnimg.cn/4d53212ebec14a6796cf22b8060acf9c.png)


![](https://img-blog.csdnimg.cn/8a8cea9a5ff945d0a76fdd9f13248a18.png)


然后先启动服务器端：


 ![](https://img-blog.csdnimg.cn/c3b77d27223343b8a8c230d17f493e2f.png)


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


再启动客户端：


 ![](https://img-blog.csdnimg.cn/c1607fa0ff3b4146b07547be0acb1779.png)


反观服务端：


 ![](https://img-blog.csdnimg.cn/010a9585249d48ed832d0c5ae41dacd1.png)


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


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


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



> 
> 1. 此处我先使用open指令打开盖子两秒
> 2. 等盖子关闭后我靠近测距传感器让盖子打开两秒后再次输入open指令
> 3. 然后在盖子打开时输入close指令，同时把手拿开（如果不把手拿开，盖子会因为close指令关闭两秒，然后因为距离小于30再次打开）
> 4. 最后在盖子关上后输入close指令
> 
> 
> ![](https://img-blog.csdnimg.cn/31729dfce70f435e8f6e55c31abd52f1.png)
> 
> 
> 1. *由于盖子没开且收到了open指令，所以盖子打开2秒*
> 2. *由于盖子已经打开且收到了open指令，所以提示“盖子已经打开”*
> 3. *由于盖子打开且收到了close指令，所以盖子关闭2秒*
> 4. *由于盖子关闭且收到了close指令，所以提示“盖子已经关闭”*
> 
> 
> 


## 


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



> 
> 和之前学习的一样，使用SU-03T来实现语音识别，先进行语音识别的配置，以下只展示关键截图，具体的步骤和烧写流程参考我之前写的两篇：
> 
> 
> [基于香橙派和SU-03T 使用Linux实现语音控制刷抖音-CSDN博客]( )
> 
> 
> [语音小车---6 + 最终整合-CSDN博客]( )
> 
> 
> 


#### 1. 创建产品


![](https://img-blog.csdnimg.cn/878632bfef8c45e8b307dee8d5e1c75b.png)


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


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


并设置相应的波特率：


![](https://img-blog.csdnimg.cn/6948498764e74f659571b328be468ef0.png)


#### 3.  设置唤醒词：


![](https://img-blog.csdnimg.cn/62c93177b9cd4b18ad474b98b0285fe9.png)


#### 4. 设置指令语句：


![](https://img-blog.csdnimg.cn/ee14901316fe46eaa2b2ff62e22dc401.png)


#### 5. 设置控制详情：


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


![](https://img-blog.csdnimg.cn/919efc4033e94696b5fd85ce69e97713.png)![](https://img-blog.csdnimg.cn/b4e39930d54245a687fc0e67550cf7ff.png) 


![](https://img-blog.csdnimg.cn/d78c9e08aca24b6880961d8f38fc63f5.png)


**open -> 6F 70 65 6E**


**close ->63 6C 6F 73 65**


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


![](https://img-blog.csdnimg.cn/85d8b23be1194773a5d82c9147393214.png)


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


![](https://img-blog.csdnimg.cn/2bf51700d8b24641ab316c17e2c084f9.png)


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


##### v3\_server.c：




  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
  • 147
  • 148
  • 149
  • 150
  • 151
  • 152
  • 153

#include <stdio.h>
#include <sys/time.h>
#include <signal.h>
#include <stdlib.h>
#include <wiringPi.h>
#include <pthread.h>
#include <unistd.h>

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <linux/in.h>
#include <string.h>
#include <sys/wait.h>
#include <sys/stat.h>
#include <errno.h>
#include <fcntl.h>

#include <stdint.h>
#include <stdarg.h>
#include <termios.h>
#include <sys/ioctl.h>
#include “mjm_uart_tool.h”

#define PWM 5
#define BEEP 2
#define Trig 9
#define Echo 10

int angle;
double dist;
static int i;

int sockfd;
int conn_sockfd;
int len = sizeof(struct sockaddr_in);
int ret;
char readbuf[128];
struct sockaddr_in my_addr;
struct sockaddr_in client_addr;
static int conn_flag;

pthread_mutex_t mutex;

int cmd_handler(int fd, char readbuf[128])
{
int ret;
int i = 0;
char str[128]; //将读到的数据备份在这里

strcpy(str,readbuf); //由于字符串的首地址是字符串的名字，所以此时相当于传入的地址，所有对字符串的操作都会影响它，所以需要进行备份，先备份再对备份的数据进行数据处理就不会影响原数据了
if(strcmp((char *)str,"open")==0 && angle == 1){ //收到open指令时垃圾桶盖子是关着的
	ret = write(fd,"open success",20);
	if(ret == -1){
		perror("write");
		pthread_exit(NULL);
	}
	angle = 3;
	digitalWrite (BEEP, LOW) ;  //蜂鸣器响
	delay (100) ;
	digitalWrite (BEEP, HIGH) ; //蜂鸣器不响
	delay (100) ;
	digitalWrite (BEEP, LOW) ;  //蜂鸣器响
	delay (100) ;
	digitalWrite (BEEP, HIGH) ; //蜂鸣器不响

	delay(2000);//延时2秒
}else if(strcmp((char *)str,"open")==0 && angle == 3){  //收到open指令时垃圾桶盖子是开着的
	ret = write(fd,"already open!",20);
	if(ret == -1){
		perror("write");
		pthread_exit(NULL);
	}
}else if(strcmp((char *)str,"close")==0 && angle == 3){ //收到close指令时垃圾桶盖子是开着的
	ret = write(fd,"close success",20);
	if(ret == -1){
		perror("write");
		pthread_exit(NULL);
	}
	angle = 1;
	delay(2000);//延时2秒
}else if(strcmp((char *)str,"close")==0 && angle == 1){ //收到close指令时垃圾桶盖子是关着的
	ret = write(fd,"already close!",20);
	if(ret == -1){
		perror("write");
		pthread_exit(NULL);
	}
}else if(strcmp((char *)str,"quit")==0){ //如果客户端打出了quit
	ret = write(fd,"Bye",4); //立刻回发一个Bye，目的是让客户端取消接收阻塞然后成功从FIFO读取到退出信息
	if(ret == -1){
		perror("write");
		pthread_exit(NULL);
	}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44

}

void startHC() //先要给Trig一个至少10us/ms的高电平方波
{
digitalWrite (Trig, LOW) ;
delay(5); //5ms
digitalWrite (Trig, HIGH) ;
delay(5);
delay(5);
digitalWrite (Trig, LOW) ;
}

void signal_handler(int signum)
{
if(i <= angle){
digitalWrite(PWM, HIGH);
}else{
digitalWrite(PWM, LOW);
}
if(i == 40){ //40*500 = 20000us = 20ms
i = 0;
}
i++;

}

void *thread1(void *arg) //负责不断检测距离，小于30cm就滴滴开盖的线程
{
struct timeval startTime;
struct timeval stopTime;
double diffTime;
//double dist

while(1){
    delay(300); //让HC-SR04稳定一下
	startHC();
	while(digitalRead(Echo) == 0); //程序会卡在这里直到Echo变高的一瞬间
	gettimeofday(&startTime,NULL);
	while(digitalRead(Echo) == 1); //程序会卡在这里直到Echo变低的一瞬间
	gettimeofday(&stopTime,NULL);

	diffTime = 1000000*(stopTime.tv_sec - startTime.tv_sec) + (stopTime.tv_usec - startTime.tv_usec);
	dist = 0.034 * diffTime * 0.5;

	//printf("dist = %f---",dist);
	//fflush(stdout);

	pthread_mutex_lock(&mutex);//对angle值修改需要先上锁

	if(dist < 30 && angle == 1){//当距离小于30且盖子未开
		angle = 3; //开盖

		digitalWrite (BEEP, LOW) ;  //蜂鸣器响
		delay (100) ;      
		digitalWrite (BEEP, HIGH) ; //蜂鸣器不响
		delay (100) ;
		digitalWrite (BEEP, LOW) ;  //蜂鸣器响
		delay (100) ;      
		digitalWrite (BEEP, HIGH) ; //蜂鸣器不响

		//sleep(2); //睡眠2秒，此处如果是sleep则运行到此处时其他线程会抢占，如果是delay则不会
		delay(2000);
	}else if(dist > 30 && angle == 3){//当距离大于30且盖子打开
		angle = 1; //关盖
	}

	pthread_mutex_unlock(&mutex);

}

pthread_exit(NULL);

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38

}

void *thread2(void *arg) //负责检测开盖时间，超过10s就报警的线程
{
struct timeval startTime;
struct timeval stopTime;
double diffTime;

while(1){
	while(angle == 1);//程序会卡在这里直到盖子打开
	gettimeofday(&startTime,NULL);
	while(angle == 3){
		gettimeofday(&stopTime,NULL);
		diffTime = (stopTime.tv_sec - startTime.tv_sec) + 1/1000000 *(stopTime.tv_usec - startTime.tv_usec);
		if(diffTime > 10){ //盖子打开超过10秒
			digitalWrite (BEEP, LOW) ;  //蜂鸣器响
			delay (1000) ; //一秒长鸣警报
			digitalWrite (BEEP, HIGH) ; //蜂鸣器不响
			break;
		}
	}

}

pthread_exit(NULL);

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

}

void *thread3(void *arg) //负责不断等待socket客户端接入的线程
{
while(1){
//accept
conn_sockfd = accept(sockfd,(struct sockaddr *)&client_addr,&len);
if(conn_sockfd == -1){
perror(“accept”);
pthread_exit(NULL);;
}else{
conn_flag = 1; //保证连接成功后才开始接收
printf(“accept success, client IP = %s\n”,inet_ntoa(client_addr.sin_addr));
fflush(stdout);
}
}

pthread_exit(NULL);

  • 1

}

void *thread4(void *arg) //负责socket客户端接入后接收处理客户端指令的线程
{
while(1){ //切不可直接“while(conn_flag == 1)”，这样在没有接入时会直接退出，要不停的循环查看flag的值
while(conn_flag == 1){
//read
memset(&readbuf,0,sizeof(readbuf));
ret = recv(conn_sockfd, &readbuf, sizeof(readbuf), 0);
if(ret == 0){ //如果recv函数返回0表示连接已经断开
printf(“client has quit\n”);
fflush(stdout);
close(conn_sockfd);
break;
}else if(ret == -1){
perror(“recv”);
conn_flag = 0; //此时打印一遍错误信息就会结束，如果不把flag置1，在一个客户端退出另一个客户端还未接入时就会不停的打印错误信息
//pthread_exit(NULL); //此处不能退出，因为因为这样如果有一个客户端接入并退出后这个线程就会退出，为了保证一个客户端退出后，另一个客户端还可以接入并正常工作，此处仅显示错误信息而不退出
}

		pthread_mutex_lock(&mutex);//对angle值修改需要先上锁
		cmd_handler(conn_sockfd, readbuf); //对客户端发来的消息进行判断的总函数
		pthread_mutex_unlock(&mutex);

		printf("\nclient: %s\n",readbuf);
		fflush(stdout);
	}

}

pthread_exit(NULL);

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

}

void *thread5(void arg) //负责通过串口接收语音模块指令的线程
{
char readbuf[32] = {‘\0’};
while(1){
while(serialDataAvail (((int )arg))){
serialGetstring (((int *)arg),readbuf) ;
//printf(“-> %s\n”,readbuf);

		pthread_mutex_lock(&mutex);//对angle值修改需要先上锁

		if(strcmp(readbuf,"open") == 0 && angle == 1){ //当收到open指令且盖子关闭时
			angle = 3; //开盖
			digitalWrite (BEEP, LOW) ;  //蜂鸣器响
			delay (100) ;
			digitalWrite (BEEP, HIGH) ; //蜂鸣器不响
			delay (100) ;
			digitalWrite (BEEP, LOW) ;  //蜂鸣器响
			delay (100) ;
			digitalWrite (BEEP, HIGH) ; //蜂鸣器不响

			delay(2000);//延时2秒

		}else if(strcmp(readbuf,"close") == 0 && angle == 3){//当收到close指令且盖子打开时
			angle = 1; //关盖
			delay(2000);//延时2秒
		}else if(strcmp(readbuf,"open") == 0 && angle == 3){
			printf("already open\n");
            fflush(stdout);
		}else if(strcmp(readbuf,"close") == 0 && angle == 1){
			printf("already close\n");
            fflush(stdout);
		}else{
			printf("unkown command\n");
			fflush(stdout);
		}

		pthread_mutex_unlock(&mutex);

		memset(readbuf,'\0',32);
	}
}

pthread_exit(NULL);

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35

}

int main(int argc, char **argv)
{
struct itimerval itv;
int io_fd;

pthread_t t1_id;
pthread_t t2_id;
pthread_t t3_id;
pthread_t t4_id;
pthread_t t5_id;

memset(&my_addr,0,sizeof(struct sockaddr_in));
memset(&client_addr,0,sizeof(struct sockaddr_in));


if(argc != 3){
	printf("param error!\n");
	return 1;
}

wiringPiSetup () ;
pinMode (PWM, OUTPUT);
pinMode (Trig, OUTPUT);
pinMode (Echo, INPUT);
pinMode (BEEP, OUTPUT);

digitalWrite (Trig, LOW) ;
digitalWrite (Echo, LOW) ;
digitalWrite (BEEP, HIGH) ;

//设定定时时间
itv.it_interval.tv_sec = 0;
itv.it_interval.tv_usec = 500;
//设定开始生效，启动定时器的时间
itv.it_value.tv_sec = 1;
itv.it_value.tv_usec = 0;

//设定定时方式
if( -1 == setitimer(ITIMER_REAL, &itv, NULL)){
	perror("error");
	exit(-1);
}

//信号处理
signal(SIGALRM,signal_handler);

angle = 1;//初始化角度为关盖

//打开串口驱动文件，配置波特率
if ((io_fd = myserialOpen ("/dev/ttyS5", 115200)) < 0)	{
	fprintf (stderr, "Unable to open serial device: %s\n", strerror (errno)) ;
	return 1 ;
}

//socket
sockfd = socket(AF_INET,SOCK_STREAM,0);
if(sockfd == -1){
	perror("socket");
	return 1;
}else{
	printf("socket success, sockfd = %d\n",sockfd);
}

//bind
my_addr.sin_family = AF_INET;
my_addr.sin_port = htons(atoi(argv[2]));//host to net (2 bytes)
inet_aton(argv[1],&my_addr.sin_addr); //char* format -> net format

ret = bind(sockfd, (struct sockaddr *)&my_addr, len);
if(ret == -1){
	perror("bind");
	return 1;
}else{
	printf("bind success\n");
}

//listen
ret = listen(sockfd,10);
if(ret == -1){
	perror("listen");
	return 1;
}else{
	printf("listening...\n");
}

ret = pthread_mutex_init(&mutex, NULL);
if(ret != 0){
	printf("mutex create error\n");
}

ret = pthread_create(&t1_id,NULL,thread1,NULL);
if(ret != 0){
	printf("thread1 create error\n");
}
ret = pthread_create(&t2_id,NULL,thread2,NULL);
if(ret != 0){
	printf("thread2 create error\n");
}
ret = pthread_create(&t3_id,NULL,thread3,NULL);
if(ret != 0){
	printf("thread3 create error\n");
}
ret = pthread_create(&t4_id,NULL,thread4,NULL);
if(ret != 0){
	printf("thread4 create error\n");
}
ret = pthread_create(&t5_id,NULL,thread5,(void *)&io_fd);
if(ret != 0){
	printf("thread5 create error\n");
}


pthread_join(t1_id,NULL);
pthread_join(t2_id,NULL);
pthread_join(t3_id,NULL);
pthread_join(t4_id,NULL);
pthread_join(t5_id,NULL);

return 0;

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114

}


#### 实现效果



> 
> 由于此处使用了之前自己写的串口库，**所以编译的时候需要连同那个串口库一起编译**：
> 
> 
> 
> ```
> 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打印时间\_笔记大全\_设计学院]( )
> 
> 
> 


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




  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75

date +“%Y-%m-%d %H:%M:%S”


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



> 
> 关于字符串的拼接，**使用的是strcat函数**，在我之前的博文也使用过，**注意strcat的对象必须是可变的字符串**：
> 
> 
>  [小插曲 -- 使用Linux编写 判断程序是否在运行的小程序-CSDN博客]( )
> 
> 
> 



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


##### v4\_server：




  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23

#include <stdio.h>
#include <sys/time.h>
#include <signal.h>
#include <stdlib.h>
#include <wiringPi.h>
#include <pthread.h>
#include <unistd.h>

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <linux/in.h>
#include <string.h>
#include <sys/wait.h>
#include <sys/stat.h>
#include <errno.h>
#include <fcntl.h>

#include <stdint.h>
#include <stdarg.h>
#include <termios.h>
#include <sys/ioctl.h>
#include “mjm_uart_tool.h”

#define PWM 5
#define BEEP 2
#define Trig 9
#define Echo 10

int angle;
double dist;
static int i;

int sockfd;
int conn_sockfd;
int len = sizeof(struct sockaddr_in);
int ret;
char readbuf[128];
struct sockaddr_in my_addr;
struct sockaddr_in client_addr;
static int conn_flag;
char hist[128] = {0}; //用于存放一条历史记录,注意这个变量一定不能在create_hist里赋值，因为局部指针变量作为函数的返回值没有意义，会报错; 且作为strcat的对象必须是字符串变量
char hist_whole[10000] = {0}; //用于存放所有历史记录; 且作为strcat的对象必须是字符串变量i

pthread_mutex_t mutex;

char *create_hist(int type, int action)//用于生成一条历史记录的函数
//type的值1;2;3分别对应距离靠近开盖;客户端指令开盖;语音识别开盖
//action的值1;2分别对应开盖;关盖
{
FILE *fp;
char *dist = “||distance close||”;
char *sock = “||client request||”;
char *soun = “||voice command||”;
char *open = “open action||”;
char *close = “close action||”;
char *c = “\n”;

memset(&hist,'\0',sizeof(hist));
fp = popen("date +\"%Y-%m-%d %H:%M:%S\"","r");
fread(&hist, sizeof(char), 128, fp);

if(type == 1){ //如果时距离靠近导致的开关盖
	strcat(hist,dist); 
}else if(type == 2){ //如果是客户端指令导致的开关盖
	strcat(hist,sock);
}else if(type == 3){ //如果是语音识别导致的开关盖
	strcat(hist,soun);
}

if(action == 1){
	strcat(hist,open);
}else if(action == 2){
	strcat(hist,close);
}

strcat(hist,c);//每条历史记录结束加上一个换行键

return (char *)hist;

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21

}

int cmd_handler(int fd, char readbuf[128])
{
int ret;
int i = 0;
char str[128]; //将读到的数据备份在这里

strcpy(str,readbuf); //由于字符串的首地址是字符串的名字，所以此时相当于传入的地址，所有对字符串的操作都会影响它，所以需要进行备份，先备份再对备份的数据进行数据处理就不会影响原数据了
if(strcmp((char *)str,"open")==0 && angle == 1){ //收到open指令时垃圾桶盖子是关着的
	ret = write(fd,"open success",20);
	if(ret == -1){
		perror("write");
		pthread_exit(NULL);
	}
	angle = 3;

	create_hist(2,1);//构建一条历史记录
	strcat(hist_whole,hist);//在总的历史记录中添加刚刚构建的历史记录

	digitalWrite (BEEP, LOW) ;  //蜂鸣器响
	delay (100) ;
	digitalWrite (BEEP, HIGH) ; //蜂鸣器不响
	delay (100) ;
	digitalWrite (BEEP, LOW) ;  //蜂鸣器响
	delay (100) ;
	digitalWrite (BEEP, HIGH) ; //蜂鸣器不响

	delay(2000);//延时2秒
}else if(strcmp((char *)str,"open")==0 && angle == 3){  //收到open指令时垃圾桶盖子是开着的
	ret = write(fd,"already open!",20);
	if(ret == -1){
		perror("write");
		pthread_exit(NULL);
	}
}else if(strcmp((char *)str,"close")==0 && angle == 3){ //收到close指令时垃圾桶盖子是开着的
	ret = write(fd,"close success",20);
	if(ret == -1){
		perror("write");
		pthread_exit(NULL);
	}
	angle = 1;

	create_hist(2,2);//构建一条历史记录
	strcat(hist_whole,hist);//在总的历史记录中添加刚刚构建的历史记录

	delay(2000);//延时2秒
}else if(strcmp((char *)str,"close")==0 && angle == 1){ //收到close指令时垃圾桶盖子是关着的
	ret = write(fd,"already close!",20);
	if(ret == -1){
		perror("write");
		pthread_exit(NULL);
	}
}else if(strcmp((char *)str,"quit")==0){ //如果客户端打出了quit
	ret = write(fd,"Bye",4); //立刻回发一个Bye，目的是让客户端取消接收阻塞然后成功从FIFO读取到退出信息
	if(ret == -1){
		perror("write");
		pthread_exit(NULL);
	}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52

}

void startHC() //先要给Trig一个至少10us/ms的高电平方波
{
digitalWrite (Trig, LOW) ;
delay(5); //5ms
digitalWrite (Trig, HIGH) ;
delay(5);
delay(5);
digitalWrite (Trig, LOW) ;
}

void signal_handler(int signum)
{
if(i <= angle){
digitalWrite(PWM, HIGH);
}else{
digitalWrite(PWM, LOW);
}
if(i == 40){ //40*500 = 20000us = 20ms
i = 0;
}
i++;

}

void *thread1(void *arg) //负责不断检测距离，小于30cm就滴滴开盖的线程
{
struct timeval startTime;
struct timeval stopTime;
double diffTime;
//double dist

while(1){
	delay(300); //让HC-SR04稳定一下
	startHC();
	while(digitalRead(Echo) == 0); //程序会卡在这里直到Echo变高的一瞬间
	gettimeofday(&startTime,NULL);
	while(digitalRead(Echo) == 1); //程序会卡在这里直到Echo变低的一瞬间
	gettimeofday(&stopTime,NULL);

	diffTime = 1000000*(stopTime.tv_sec - startTime.tv_sec) + (stopTime.tv_usec - startTime.tv_usec);
	dist = 0.034 * diffTime * 0.5;

	//printf("dist = %f---",dist);
	//fflush(stdout);

	pthread_mutex_lock(&mutex);//对angle值修改需要先上锁

	if(dist < 30 && angle == 1){//当距离小于30且盖子未开
		angle = 3; //开盖

		create_hist(1,1);//构建一条历史记录
		strcat(hist_whole,hist);//在总的历史记录中添加刚刚构建的历史记录

		digitalWrite (BEEP, LOW) ;  //蜂鸣器响
		delay (100) ;      
		digitalWrite (BEEP, HIGH) ; //蜂鸣器不响
		delay (100) ;
		digitalWrite (BEEP, LOW) ;  //蜂鸣器响
		delay (100) ;      
		digitalWrite (BEEP, HIGH) ; //蜂鸣器不响

		delay(2000);
	}else if(dist > 30 && angle == 3){//当距离大于30且盖子打开
		angle = 1; //关盖

		create_hist(1,2);//构建一条历史记录
		strcat(hist_whole,hist);//在总的历史记录中添加刚刚构建的历史记录
	}

	pthread_mutex_unlock(&mutex);

}

pthread_exit(NULL);

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43

}

void *thread2(void *arg) //负责检测开盖时间，超过10s就报警的线程
{
struct timeval startTime;
struct timeval stopTime;
double diffTime;

while(1){
	while(angle == 1);//程序会卡在这里直到盖子打开
	gettimeofday(&startTime,NULL);
	while(angle == 3){
		gettimeofday(&stopTime,NULL);
		diffTime = (stopTime.tv_sec - startTime.tv_sec) + 1/1000000 *(stopTime.tv_usec - startTime.tv_usec);
		if(diffTime > 10){ //盖子打开超过10秒
			digitalWrite (BEEP, LOW) ;  //蜂鸣器响
			delay (1000) ; //一秒长鸣警报
			digitalWrite (BEEP, HIGH) ; //蜂鸣器不响
			break;
		}
	}

}

pthread_exit(NULL);

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

}

void *thread3(void *arg) //负责不断等待socket客户端接入的线程
{
while(1){
//accept
conn_sockfd = accept(sockfd,(struct sockaddr *)&client_addr,&len);
if(conn_sockfd == -1){
perror(“accept”);
pthread_exit(NULL);;
}else{
conn_flag = 1; //保证连接成功后才开始接收
printf(“accept success, client IP = %s\n”,inet_ntoa(client_addr.sin_addr));
fflush(stdout);
}
}

pthread_exit(NULL);

  • 1

}

void *thread4(void *arg) //负责socket客户端接入后接收处理客户端指令的线程
{
while(1){ //切不可直接“while(conn_flag == 1)”，这样在没有接入时会直接退出，要不停的循环查看flag的值
while(conn_flag == 1){
//read
memset(&readbuf,0,sizeof(readbuf));
ret = recv(conn_sockfd, &readbuf, sizeof(readbuf), 0);
if(ret == 0){ //如果recv函数返回0表示连接已经断开
printf(“client has quit\n”);
fflush(stdout);
close(conn_sockfd);
break;
}else if(ret == -1){
perror(“recv”);
conn_flag = 0; //此时打印一遍错误信息就会结束，如果不把flag置1，在一个客户端退出另一个客户端还未接入时就会不停的打印错误信息
//pthread_exit(NULL); //此处不能退出，因为因为这样如果有一个客户端接入并退出后这个线程就会退出，为了保证一个客户端退出后，另一个客户端还可以接入并正常工作，此处仅显示错误信息而不退出
}

		pthread_mutex_lock(&mutex);//对angle值修改需要先上锁
		cmd_handler(conn_sockfd, readbuf); //对客户端发来的消息进行判断的总函数
		pthread_mutex_unlock(&mutex);

		printf("\nclient: %s\n",readbuf);
		fflush(stdout);
	}

}

pthread_exit(NULL);

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

}

void *thread5(void arg) //负责通过串口接收语音模块指令的线程
{
char io_readbuf[32] = {‘\0’};
while(1){
while(serialDataAvail (((int )arg))){
serialGetstring (((int *)arg),io_readbuf) ;
//printf(“-> %s\n”,io_readbuf);

		pthread_mutex_lock(&mutex);//对angle值修改需要先上锁

		if(strcmp(io_readbuf,"open") == 0 && angle == 1){ //当收到open指令且盖子关闭时
			angle = 3; //开盖

			create_hist(3,1);//构建一条历史记录
			strcat(hist_whole,hist);//在总的历史记录中添加刚刚构建的历史记录

			digitalWrite (BEEP, LOW) ;  //蜂鸣器响
			delay (100) ;
			digitalWrite (BEEP, HIGH) ; //蜂鸣器不响
			delay (100) ;
			digitalWrite (BEEP, LOW) ;  //蜂鸣器响
			delay (100) ;
			digitalWrite (BEEP, HIGH) ; //蜂鸣器不响

			delay(2000);//延时2秒
		}else if(strcmp(io_readbuf,"close") == 0 && angle == 3){//当收到close指令且盖子打开时
			angle = 1; //关盖

			create_hist(3,2);//构建一条历史记录
			strcat(hist_whole,hist);//在总的历史记录中添加刚刚构建的历史记录

			delay(2000);//延时2秒
		}else if(strcmp(io_readbuf,"open") == 0 && angle == 3){
			printf("already open\n");
			fflush(stdout);
		}else if(strcmp(io_readbuf,"close") == 0 && angle == 1){
			printf("already close\n");
			fflush(stdout);
		}else{
			printf("unkown command\n");
			fflush(stdout);
		}

		pthread_mutex_unlock(&mutex);

		memset(io_readbuf,'\0',32);
	}
}

pthread_exit(NULL);

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42

}

void *thread6(void *arg) //负责每隔一段时间写入历史记录的线程
{
struct timeval startTime;
struct timeval stopTime;
double diffTime;
int hist_fd; // file description

while(1){
	gettimeofday(&startTime,NULL);
	while(1){
    	gettimeofday(&stopTime,NULL);
    	diffTime = (stopTime.tv_sec - startTime.tv_sec) + 1/1000000 *(stopTime.tv_usec - startTime.tv_usec); //单位为秒
		if(diffTime > 60){//如果时间是2分钟,由于线程的竞争机制，不一定会非常精确，所以使用>号
			hist_fd = open("./history.txt",O_RDWR|O_CREAT|O_APPEND, 0666); //可读可写可打开的打开历史记录的文件，不存在就创建，且每次都追加写入
			if(hist_fd < 0){
				printf("fail to open history file!\n");
                fflush(stdout);
			}
			ret = write(hist_fd, &hist_whole, strlen(hist_whole));
			if(ret == -1){
				printf("fail to write history write to file!\n");
				fflush(stdout);
			}else{
				printf("write the following history write to file:\n");
				printf("------------------------\n");
				printf("%s",hist_whole);
				printf("------------------------\n");
                fflush(stdout);
			}
			close(hist_fd);
			memset(hist_whole,'\0',sizeof(hist_whole)); //清空hist_whole!
        	break;
		}
	}
}

pthread_exit(NULL);

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30

}

int main(int argc, char **argv)
{
struct itimerval itv;
int io_fd;

pthread_t t1_id;
pthread_t t2_id;
pthread_t t3_id;
pthread_t t4_id;
pthread_t t5_id;
pthread_t t6_id;

memset(&my_addr,0,sizeof(struct sockaddr_in));
memset(&client_addr,0,sizeof(struct sockaddr_in));


if(argc != 3){
	printf("param error!\n");
	return 1;
}

wiringPiSetup () ;
pinMode (PWM, OUTPUT);
pinMode (Trig, OUTPUT);
pinMode (Echo, INPUT);
pinMode (BEEP, OUTPUT);

digitalWrite (Trig, LOW) ;
digitalWrite (Echo, LOW) ;
digitalWrite (BEEP, HIGH) ;

//设定定时时间
itv.it_interval.tv_sec = 0;
itv.it_interval.tv_usec = 500;
//设定开始生效，启动定时器的时间
itv.it_value.tv_sec = 1;
itv.it_value.tv_usec = 0;

//设定定时方式
if( -1 == setitimer(ITIMER_REAL, &itv, NULL)){
	perror("error");
	exit(-1);
}

//信号处理
signal(SIGALRM,signal_handler);

angle = 1;//初始化角度为关盖

//打开串口驱动文件，配置波特率
if ((io_fd = myserialOpen ("/dev/ttyS5", 115200)) < 0)	{
	fprintf (stderr, "Unable to open serial device: %s\n", strerror (errno)) ;
	return 1 ;
}

//socket
sockfd = socket(AF_INET,SOCK_STREAM,0);
if(sockfd == -1){
	perror("socket");
	return 1;
}else{
	printf("socket success, sockfd = %d\n",sockfd);
}

//bind
my_addr.sin_family = AF_INET;
my_addr.sin_port = htons(atoi(argv[2]));//host to net (2 bytes)
inet_aton(argv[1],&my_addr.sin_addr); //char* format -> net format

ret = bind(sockfd, (struct sockaddr *)&my_addr, len);
if(ret == -1){
	perror("bind");
	return 1;
}else{
	printf("bind success\n");
}

//listen
ret = listen(sockfd,10);
if(ret == -1){
	perror("listen");
	return 1;
}else{
	printf("listening...\n");
}

ret = pthread_mutex_init(&mutex, NULL);
if(ret != 0){
	printf("mutex create error\n");
}

ret = pthread_create(&t1_id,NULL,thread1,NULL);
if(ret != 0){
	printf("thread1 create error\n");
}
ret = pthread_create(&t2_id,NULL,thread2,NULL);
if(ret != 0){
	printf("thread2 create error\n");
}
ret = pthread_create(&t3_id,NULL,thread3,NULL);
if(ret != 0){
	printf("thread3 create error\n");
}
ret = pthread_create(&t4_id,NULL,thread4,NULL);
if(ret != 0){
	printf("thread4 create error\n");
}
ret = pthread_create(&t5_id,NULL,thread5,(void *)&io_fd);
if(ret != 0){
	printf("thread5 create error\n");
}
ret = pthread_create(&t6_id,NULL,thread6,NULL);
if(ret != 0){
	printf("thread6 create error\n");
}


pthread_join(t1_id,NULL);
pthread_join(t2_id,NULL);
pthread_join(t3_id,NULL);
pthread_join(t4_id,NULL);
pthread_join(t5_id,NULL);
pthread_join(t6_id,NULL);

return 0;

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120

}



#### 实现效果



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


编译并运行代码：




  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

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


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


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


![](https://img-blog.csdnimg.cn/f5561a29e39f434fbcf3900b69ed00c6.png)


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


![](https://img-blog.csdnimg.cn/9e3f8c192542470490127fdf54805809.png)


![](https://img-blog.csdnimg.cn/c1670bce375d47cf8e46ef7e8118b8ad.png)



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



> 
> 回顾需求：
> 
> 
> ***统计一段时间内垃圾桶开关盖次数及开关盖指令来源并记录在数据库中***
> 
> 
> 回顾之前学习嵌入式数据库的博文：
> 
> 
> [使用香橙派学习 嵌入式数据库---SQLite-CSDN博客]( )
> 
> 
> 


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


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


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



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


##### v5\_server.c：




  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57

#include <stdio.h>
#include <sys/time.h>
#include <signal.h>
#include <stdlib.h>
#include <wiringPi.h>
#include <pthread.h>
#include <unistd.h>

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <linux/in.h>
#include <string.h>
#include <sys/wait.h>
#include <sys/stat.h>
#include <errno.h>
#include <fcntl.h>

#include <stdint.h>
#include <stdarg.h>
#include <termios.h>
#include <sys/ioctl.h>
#include “mjm_uart_tool.h”

#include <sqlite3.h>

#define PWM 5
#define BEEP 2
#define Trig 9
#define Echo 10

int angle;
double dist;
static int i;

int sockfd;
int conn_sockfd;
int len = sizeof(struct sockaddr_in);
int ret;
char readbuf[128];
struct sockaddr_in my_addr;
struct sockaddr_in client_addr;
static int conn_flag;
char hist[128] = {0}; //用于存放一条历史记录,注意这个变量一定不能在create_hist里赋值，因为局部指针变量作为函数的返回值没有意义，会报错; 且作为strcat的对象必须是字符串变量
char hist_whole[10000] = {0}; //用于存放所有历史记录; 且作为strcat的对象必须是字符串变量
sqlite3 *db;
char *zErrMsg = 0;
int dist_open_count = 0;
int dist_close_count = 0;
int sock_open_count = 0;
int sock_close_count = 0;
int soun_open_count = 0;
int soun_close_count = 0;

pthread_mutex_t mutex;

int callback(void *arg, int column_size, char *column_value[], char *column_name[]) //数据库exec函数对应的callback函数
{
int j;
//printf(“arg=%s\n”,(char *)arg);

for(j=0;j<column_size;j++){
	printf("%s = %s\n", column_name[j], column_value[j]);
	fflush(stdout); //由于callback可能在线程运行中被调用,所以这句话不能忘
}
printf("=======================\n");
fflush(stdout);
return 0;//必须返回0，这样数据库中有多少条数据,这个回调函数就会被调用多少次

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

}

void init_table() //用于初始化数据库中表格的值
{
char *init_table_sql;

init_table_sql = "insert into history values('dist',0,0);";
ret = sqlite3_exec(db, init_table_sql, callback, 0, &zErrMsg);
if(ret != SQLITE_OK){
	printf("Can't init table value: %s\n", sqlite3_errmsg(db));
}
init_table_sql = "insert into history values('socket',0,0);";
ret = sqlite3_exec(db, init_table_sql, callback, 0, &zErrMsg);
if(ret != SQLITE_OK){
	printf("Can't init table value: %s\n", sqlite3_errmsg(db));
}
init_table_sql = "insert into history values('sound',0,0);";
ret = sqlite3_exec(db, init_table_sql, callback, 0, &zErrMsg);
if(ret != SQLITE_OK){
	printf("Can't init table value: %s\n", sqlite3_errmsg(db));
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

}

void write2file() //将历史记录写入文件的函数
{
int hist_fd; // file description

hist_fd = open("./history.txt",O_RDWR|O_CREAT|O_APPEND, 0666); //可读可写可打开的打开历史记录的文件，不存在就创建，且每次都追加写入
if(hist_fd < 0){
	printf("fail to open history file!\n");
	fflush(stdout);
}
ret = write(hist_fd, &hist_whole, strlen(hist_whole));
if(ret == -1){
	printf("fail to write history write to file!\n");
	fflush(stdout);
}else{
	printf("write history to file successfully!\n");
	/*printf("write the following history to file:\n");
	  printf("------------------------\n");
	  printf("%s",hist_whole);
	  printf("------------------------\n");*/
	fflush(stdout);
}
close(hist_fd);
memset(hist_whole,'\0',sizeof(hist_whole)); //清空hist_whole!

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

}

void write2sql() //将历史记录写入数据库的函数
{
char update_sql[128] = {‘\0’};

sprintf(update_sql,"update history set open = %d, close = %d where cause = 'dist';",dist_open_count, dist_close_count);
ret = sqlite3_exec(db, (const char *)update_sql, callback, 0, &zErrMsg);
if(ret != SQLITE_OK){ 
	printf("Can't update date: %s\n", sqlite3_errmsg(db));
}
sprintf(update_sql,"update history set open = %d, close = %d where cause = 'socket';",sock_open_count, sock_close_count);
ret = sqlite3_exec(db, (const char *)update_sql, callback, 0, &zErrMsg);
if(ret != SQLITE_OK){
    printf("Can't update date: %s\n", sqlite3_errmsg(db));
}
sprintf(update_sql,"update history set open = %d, close = %d where cause = 'sound';",soun_open_count, soun_close_count);
ret = sqlite3_exec(db, (const char *)update_sql, callback, 0, &zErrMsg);
if(ret != SQLITE_OK){
    printf("Can't update date: %s\n", sqlite3_errmsg(db));
}


ret = sqlite3_exec(db, "select * from history;", callback, 0, &zErrMsg); //将数据库数据打印到屏幕
if(ret != SQLITE_OK){
	printf("Can't show date: %s\n", sqlite3_errmsg(db));
}
dist_open_count = 0;
dist_close_count = 0;
sock_open_count = 0;
sock_close_count = 0;
soun_open_count = 0;
soun_close_count = 0;

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27

}

char *create_hist(int type, int action)//用于生成一条历史记录的函数
//type的值1;2;3分别对应距离靠近开盖;客户端指令开盖;语音识别开盖
//action的值1;2分别对应开盖;关盖
{
FILE *fp;
char *dist = “||distance close||”;
char *sock = “||client request||”;
char *soun = “||voice command||”;
char *open = “open action||”;
char *close = “close action||”;
char *c = “\n”;

memset(&hist,'\0',sizeof(hist));
fp = popen("date +\"%Y-%m-%d %H:%M:%S\"","r");
fread(&hist, sizeof(char), 128, fp);

if(type == 1){ //如果时距离靠近导致的开关盖
	strcat(hist,dist); 
}else if(type == 2){ //如果是客户端指令导致的开关盖
	strcat(hist,sock);
}else if(type == 3){ //如果是语音识别导致的开关盖
	strcat(hist,soun);
}

if(action == 1){
	strcat(hist,open);
}else if(action == 2){
	strcat(hist,close);
}

strcat(hist,c);//每条历史记录结束加上一个换行键

return (char *)hist;

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21

}

int cmd_handler(int fd, char readbuf[128])
{
int ret;
int i = 0;
char str[128]; //将读到的数据备份在这里

strcpy(str,readbuf); //由于字符串的首地址是字符串的名字，所以此时相当于传入的地址，所有对字符串的操作都会影响它，所以需要进行备份，先备份再对备份的数据进行数据处理就不会影响原数据了
if(strcmp((char *)str,"open")==0 && angle == 1){ //收到open指令时垃圾桶盖子是关着的
	ret = write(fd,"open success",20);
	if(ret == -1){
		perror("write");
		pthread_exit(NULL);
	}
	angle = 3;

	sock_open_count++;
	create_hist(2,1);//构建一条历史记录
	strcat(hist_whole,hist);//在总的历史记录中添加刚刚构建的历史记录

	digitalWrite (BEEP, LOW) ;  //蜂鸣器响
	delay (100) ;
	digitalWrite (BEEP, HIGH) ; //蜂鸣器不响
	delay (100) ;
	digitalWrite (BEEP, LOW) ;  //蜂鸣器响
	delay (100) ;
	digitalWrite (BEEP, HIGH) ; //蜂鸣器不响

	delay(2000);//延时2秒
}else if(strcmp((char *)str,"open")==0 && angle == 3){  //收到open指令时垃圾桶盖子是开着的
	ret = write(fd,"already open!",20);
	if(ret == -1){
		perror("write");
		pthread_exit(NULL);
	}
}else if(strcmp((char *)str,"close")==0 && angle == 3){ //收到close指令时垃圾桶盖子是开着的
	ret = write(fd,"close success",20);
	if(ret == -1){
		perror("write");
		pthread_exit(NULL);
	}
	angle = 1;

	sock_close_count++;
	create_hist(2,2);//构建一条历史记录
	strcat(hist_whole,hist);//在总的历史记录中添加刚刚构建的历史记录

	delay(2000);//延时2秒
}else if(strcmp((char *)str,"close")==0 && angle == 1){ //收到close指令时垃圾桶盖子是关着的
	ret = write(fd,"already close!",20);
	if(ret == -1){
		perror("write");
		pthread_exit(NULL);
	}
}else if(strcmp((char *)str,"quit")==0){ //如果客户端打出了quit
	ret = write(fd,"Bye",4); //立刻回发一个Bye，目的是让客户端取消接收阻塞然后成功从FIFO读取到退出信息
	if(ret == -1){
		perror("write");
		pthread_exit(NULL);
	}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54

}

void startHC() //先要给Trig一个至少10us/ms的高电平方波
{
digitalWrite (Trig, LOW) ;
delay(5); //5ms
digitalWrite (Trig, HIGH) ;
delay(5);
delay(5);
digitalWrite (Trig, LOW) ;
}

void signal_handler(int signum)
{
if(i <= angle){
digitalWrite(PWM, HIGH);
}else{
digitalWrite(PWM, LOW);
}
if(i == 40){ //40*500 = 20000us = 20ms
i = 0;
}
i++;

}

void *thread1(void *arg) //负责不断检测距离，小于30cm就滴滴开盖的线程
{
struct timeval startTime;
struct timeval stopTime;
double diffTime;
//double dist

while(1){
	delay(300); //让HC-SR04稳定一下
	startHC();
	while(digitalRead(Echo) == 0); //程序会卡在这里直到Echo变高的一瞬间
	gettimeofday(&startTime,NULL);
	while(digitalRead(Echo) == 1); //程序会卡在这里直到Echo变低的一瞬间
	gettimeofday(&stopTime,NULL);

	diffTime = 1000000*(stopTime.tv_sec - startTime.tv_sec) + (stopTime.tv_usec - startTime.tv_usec);
	dist = 0.034 * diffTime * 0.5;

	//printf("dist = %f---",dist);
	//fflush(stdout);

	pthread_mutex_lock(&mutex);//对angle值修改需要先上锁

	if(dist < 30 && angle == 1){//当距离小于30且盖子未开
		angle = 3; //开盖

		dist_open_count++;
		create_hist(1,1);//构建一条历史记录
		strcat(hist_whole,hist);//在总的历史记录中添加刚刚构建的历史记录

		digitalWrite (BEEP, LOW) ;  //蜂鸣器响
		delay (100) ;      
		digitalWrite (BEEP, HIGH) ; //蜂鸣器不响
		delay (100) ;
		digitalWrite (BEEP, LOW) ;  //蜂鸣器响
		delay (100) ;      
		digitalWrite (BEEP, HIGH) ; //蜂鸣器不响

		delay(2000);
	}else if(dist > 30 && angle == 3){//当距离大于30且盖子打开
		angle = 1; //关盖

		dist_close_count++;
		create_hist(1,2);//构建一条历史记录
		strcat(hist_whole,hist);//在总的历史记录中添加刚刚构建的历史记录
	}

	pthread_mutex_unlock(&mutex);

}

pthread_exit(NULL);

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45

}

void *thread2(void *arg) //负责检测开盖时间，超过10s就报警的线程
{
struct timeval startTime;
struct timeval stopTime;
double diffTime;

while(1){
	while(angle == 1);//程序会卡在这里直到盖子打开
	gettimeofday(&startTime,NULL);
	while(angle == 3){
		gettimeofday(&stopTime,NULL);
		diffTime = (stopTime.tv_sec - startTime.tv_sec) + 1/1000000 *(stopTime.tv_usec - startTime.tv_usec);
		if(diffTime > 10){ //盖子打开超过10秒
			digitalWrite (BEEP, LOW) ;  //蜂鸣器响
			delay (1000) ; //一秒长鸣警报
			digitalWrite (BEEP, HIGH) ; //蜂鸣器不响
			break;
		}
	}

}

pthread_exit(NULL);

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

}

void *thread3(void *arg) //负责不断等待socket客户端接入的线程
{
while(1){
//accept
conn_sockfd = accept(sockfd,(struct sockaddr *)&client_addr,&len);
if(conn_sockfd == -1){
perror(“accept”);
pthread_exit(NULL);;
}else{
conn_flag = 1; //保证连接成功后才开始接收
printf(“accept success, client IP = %s\n”,inet_ntoa(client_addr.sin_addr));
fflush(stdout);
}
}

pthread_exit(NULL);

  • 1

}

void *thread4(void *arg) //负责socket客户端接入后接收处理客户端指令的线程
{
while(1){ //切不可直接“while(conn_flag == 1)”，这样在没有接入时会直接退出，要不停的循环查看flag的值
while(conn_flag == 1){
//read
memset(&readbuf,0,sizeof(readbuf));
ret = recv(conn_sockfd, &readbuf, sizeof(readbuf), 0);
if(ret == 0){ //如果recv函数返回0表示连接已经断开
printf(“client has quit\n”);
fflush(stdout);
close(conn_sockfd);
break;
}else if(ret == -1){
perror(“recv”);
conn_flag = 0; //此时打印一遍错误信息就会结束，如果不把flag置1，在一个客户端退出另一个客户端还未接入时就会不停的打印错误信息
//pthread_exit(NULL); //此处不能退出，因为因为这样如果有一个客户端接入并退出后这个线程就会退出，为了保证一个客户端退出后，另一个客户端还可以接入并正常工作，此处仅显示错误信息而不退出
}

		pthread_mutex_lock(&mutex);//对angle值修改需要先上锁
		cmd_handler(conn_sockfd, readbuf); //对客户端发来的消息进行判断的总函数
		pthread_mutex_unlock(&mutex);

		printf("\nclient: %s\n",readbuf);
		fflush(stdout);
	}

}

pthread_exit(NULL);

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

}

void *thread5(void arg) //负责通过串口接收语音模块指令的线程
{
char io_readbuf[32] = {‘\0’};
while(1){
while(serialDataAvail (((int )arg))){
serialGetstring (((int *)arg),io_readbuf) ;
//printf(“-> %s\n”,io_readbuf);

		pthread_mutex_lock(&mutex);//对angle值修改需要先上锁

		if(strcmp(io_readbuf,"open") == 0 && angle == 1){ //当收到open指令且盖子关闭时
			angle = 3; //开盖

			soun_open_count++;

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

为了做好运维面试路上的助攻手，特整理了上百道 【运维技术栈面试题集锦】 ，让你面试不慌心不跳，高薪offer怀里抱！

这次整理的面试题，小到shell、MySQL，大到K8s等云原生技术栈，不仅适合运维新人入行面试需要，还适用于想提升进阶跳槽加薪的运维朋友。

本份面试集锦涵盖了

  • 174 道运维工程师面试题
  • 128道k8s面试题
  • 108道shell脚本面试题
  • 200道Linux面试题
  • 51道docker面试题
  • 35道Jenkis面试题
  • 78道MongoDB面试题
  • 17道ansible面试题
  • 60道dubbo面试题
  • 53道kafka面试
  • 18道mysql面试题
  • 40道nginx面试题
  • 77道redis面试题
  • 28道zookeeper

总计 1000+ 道面试题， 内容 又全含金量又高

  • 174道运维工程师面试题

1、什么是运维?

2、在工作中，运维人员经常需要跟运营人员打交道，请问运营人员是做什么工作的?

3、现在给你三百台服务器，你怎么对他们进行管理?

4、简述raid0 raid1raid5二种工作模式的工作原理及特点

5、LVS、Nginx、HAproxy有什么区别?工作中你怎么选择?

6、Squid、Varinsh和Nginx有什么区别，工作中你怎么选择?

7、Tomcat和Resin有什么区别，工作中你怎么选择?

8、什么是中间件?什么是jdk?

9、讲述一下Tomcat8005、8009、8080三个端口的含义？

10、什么叫CDN?

11、什么叫网站灰度发布?

12、简述DNS进行域名解析的过程?

13、RabbitMQ是什么东西?

14、讲一下Keepalived的工作原理?

15、讲述一下LVS三种模式的工作过程?

16、mysql的innodb如何定位锁问题，mysql如何减少主从复制延迟?

17、如何重置mysql root密码?

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注运维）
img

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

	}

}

pthread_exit(NULL);

  • 1
  • 2
  • 3
  • 4
  • 5

}

void *thread5(void arg) //负责通过串口接收语音模块指令的线程
{
char io_readbuf[32] = {‘\0’};
while(1){
while(serialDataAvail (((int )arg))){
serialGetstring (((int *)arg),io_readbuf) ;
//printf(“-> %s\n”,io_readbuf);

		pthread_mutex_lock(&mutex);//对angle值修改需要先上锁

		if(strcmp(io_readbuf,"open") == 0 && angle == 1){ //当收到open指令且盖子关闭时
			angle = 3; //开盖

			soun_open_count++;

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

为了做好运维面试路上的助攻手，特整理了上百道 【运维技术栈面试题集锦】 ，让你面试不慌心不跳，高薪offer怀里抱！

这次整理的面试题，小到shell、MySQL，大到K8s等云原生技术栈，不仅适合运维新人入行面试需要，还适用于想提升进阶跳槽加薪的运维朋友。

[外链图片转存中…(img-T0G8L2ya-1713220053164)]

本份面试集锦涵盖了

  • 174 道运维工程师面试题
  • 128道k8s面试题
  • 108道shell脚本面试题
  • 200道Linux面试题
  • 51道docker面试题
  • 35道Jenkis面试题
  • 78道MongoDB面试题
  • 17道ansible面试题
  • 60道dubbo面试题
  • 53道kafka面试
  • 18道mysql面试题
  • 40道nginx面试题
  • 77道redis面试题
  • 28道zookeeper

总计 1000+ 道面试题， 内容 又全含金量又高

  • 174道运维工程师面试题

1、什么是运维?

2、在工作中，运维人员经常需要跟运营人员打交道，请问运营人员是做什么工作的?

3、现在给你三百台服务器，你怎么对他们进行管理?

4、简述raid0 raid1raid5二种工作模式的工作原理及特点

5、LVS、Nginx、HAproxy有什么区别?工作中你怎么选择?

6、Squid、Varinsh和Nginx有什么区别，工作中你怎么选择?

7、Tomcat和Resin有什么区别，工作中你怎么选择?

8、什么是中间件?什么是jdk?

9、讲述一下Tomcat8005、8009、8080三个端口的含义？

10、什么叫CDN?

11、什么叫网站灰度发布?

12、简述DNS进行域名解析的过程?

13、RabbitMQ是什么东西?

14、讲一下Keepalived的工作原理?

15、讲述一下LVS三种模式的工作过程?

16、mysql的innodb如何定位锁问题，mysql如何减少主从复制延迟?

17、如何重置mysql root密码?

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注运维）
[外链图片转存中…(img-gYiwqwM0-1713220053164)]

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

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

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

  

闽ICP备14008679号