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

使用香橙派并基于Linux实现最终版智能垃圾桶项目 --- 上_香橙派 ir-keytable(1)

作者：你好赵伟 | 2024-06-06 18:06:52

赞

踩

使用香橙派并基于Linux实现最终版智能垃圾桶项目 --- 上_香橙派 ir-keytable(1)

最全的Linux教程，Linux从入门到精通

======================

  1. linux从入门到精通(第2版)

  2. Linux系统移植

  3. Linux驱动开发入门与实战

  4. LINUX 系统移植 第2版

  5. Linux开源网络全栈详解 从DPDK到OpenFlow

华为18级工程师呕心沥血撰写3000页Linux学习笔记教程

第一份《Linux从入门到精通》466页

====================

内容简介

====

本书是获得了很多读者好评的Linux经典畅销书**《Linux从入门到精通》的第2版**。本书第1版出版后曾经多次印刷，并被51CTO读书频道评为“最受读者喜爱的原创IT技术图书奖”。本书第﹖版以最新的Ubuntu 12.04为版本，循序渐进地向读者介绍了Linux 的基础应用、系统管理、网络应用、娱乐和办公、程序开发、服务器配置、系统安全等。本书附带1张光盘，内容为本书配套多媒体教学视频。另外,本书还为读者提供了大量的Linux学习资料和Ubuntu安装镜像文件，供读者免费下载。

华为18级工程师呕心沥血撰写3000页Linux学习笔记教程

本书适合广大Linux初中级用户、开源软件爱好者和大专院校的学生阅读，同时也非常适合准备从事Linux平台开发的各类人员。

需要《Linux入门到精通》、《linux系统移植》、《Linux驱动开发入门实战》、《Linux开源网络全栈》电子书籍及教程的工程师朋友们劳烦您转发+评论

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

需要这份系统化的资料的朋友，可以点击这里获取！

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

int main()
{
struct itimerval itv;
int ret;
//int param = 100;
pthread_t t1_id;
pthread_t t2_id;

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;//初始化角度为关盖


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");
}


pthread_join(t1_id,NULL);
pthread_join(t2_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

}



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



> 
> 由于之前实现的代码都使用了线程；所以如果我现在和之前一样用fork来实现socket的accept和读写，那么fork之后线程数量会翻倍，同样的线程都会同时运行两个，而父子进程又可能对angle的值改变，引起混乱。
> 
> 
> 所以，**我尝试将socket的编程也使用线程的方式来实现，由于在线程的实现中，会出现多个线程修改angle的情况，为了防止竞争，需要加互斥锁**。
> 
> 
> 


#### 代码展示：


##### v2\_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

#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>

#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)
{
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) ; //蜂鸣器不响

		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

}

void *thread2(void *arg)
{
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)
{
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)
{
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

}

int main(int argc, char **argv)
{
struct itimerval itv;
//int param = 100;
pthread_t t1_id;
pthread_t t2_id;
pthread_t t3_id;
pthread_t t4_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;//初始化角度为关盖

//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");
}

pthread_join(t1_id,NULL);
pthread_join(t2_id,NULL);
pthread_join(t3_id,NULL);
pthread_join(t4_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

}


##### v2\_client.c：




  • 1
  • 2
  • 3
  • 4
  • 5

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

int main(int argc, char **argv)
{
int sockfd;
int ret;
int n_read;
int n_write;
char readbuf[128];
char msg[128];

int fd; //fifo
char fifo_readbuf[20] = {0};
char *fifo_msg = "quit";

pid_t fork_return;

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


struct sockaddr_in server_addr;
memset(&server_addr,0,sizeof(struct sockaddr_in));

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

//connect
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(atoi(argv[2]));//host to net (2 bytes)
inet_aton(argv[1],&server_addr.sin_addr); 
ret = connect(sockfd, (struct sockaddr *)&server_addr, sizeof(struct sockaddr_in));
if(ret == -1){
	perror("connect");
	return 1;
}else{
	printf("connect success!\n");
}

//fifo
if(mkfifo("./fifo",S_IRWXU) == -1 && errno != EEXIST)
{
	perror("fifo");
}

//fork
fork_return = fork();

if(fork_return > 0){//father keeps writing msg
	while(1){
		//write
		memset(&msg,0,sizeof(msg));
		//printf("\ntype msg:");
		scanf("%s",(char *)msg);
		n_write = write(sockfd,&msg,strlen(msg));
		if(msg[0]=='q' && msg[1]=='u' && msg[2]=='i' && msg[3]=='t'){
			printf("quit detected!\n");
			fd = open("./fifo",O_WRONLY);
			write(fd,fifo_msg,strlen(fifo_msg));
			close(fd);
			close(sockfd);
			wait(NULL);
			break;
		}
		if(n_write == -1){
			perror("write");
			return 1;
		}else{
			printf("%d bytes msg sent\n",n_write);
		}
	}
}else if(fork_return < 0){
	perror("fork");
	return 1;
}else{//son keeps reading 
	while(1){
		fd = open("./fifo",O_RDONLY|O_NONBLOCK);
		lseek(fd, 0, SEEK_SET);
		read(fd,&fifo_readbuf,20);
		//printf("read from fifo:%s\n",fifo_readbuf);
		if(fifo_readbuf[0]=='q' && fifo_readbuf[1]=='u' && fifo_readbuf[2]=='i' && fifo_readbuf[3]=='t'){
			exit(1);
		}

		//read
		memset(&readbuf,0,sizeof(readbuf));
		n_read = read(sockfd,&readbuf,128);
		if(n_read == -1){
			perror("read");
			return 1;
		}else{
			printf("\nserver: %s\n",readbuf);
		}
	}

}


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

}


#### 


#### 实现效果：


编译两个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

  • 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

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

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

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

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

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

需要这份系统化的资料的朋友，可以点击这里获取！

gc != 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

  • 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

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

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

因此收集整理了一份《2024年最新Linux运维全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。
[外链图片转存中…(img-plV2bjif-1715465160502)]
[外链图片转存中…(img-qeqetFlA-1715465160503)]
[外链图片转存中…(img-hdNkAu3w-1715465160503)]
[外链图片转存中…(img-vLYLrOq9-1715465160503)]
[外链图片转存中…(img-vwC5Brgs-1715465160504)]

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

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

需要这份系统化的资料的朋友，可以点击这里获取！

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

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

  

闽ICP备14008679号