智能垃圾桶项目：Linux环境下

最新推荐文章于 2024-03-26 22:16:43 发布
最新推荐文章于 2024-03-26 22:16:43 发布
阅读量307 收藏 8
点赞数 1
分类专栏： linux学习 嵌入式学习 文章标签： linux 服务器 网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/GS8FG/article/details/130570784
版权

这里写目录标题

原理图

image.png

功能需求

  • 靠近时，垃圾桶开启2秒，2秒后关闭
  • 垃圾桶开启带滴滴声
  • 垃圾桶开启超过10秒，滴滴声警报
  • 语音控制垃圾桶开关盖
  • 回顾二阶段的Socket编程，实现Sockect客户端发送指令远程打开/关闭垃圾桶，并显示垃圾桶状态
  • 统计当天垃圾桶开关盖次数及开关盖指令来源并记录在文件中
  • 统计当天垃圾桶开关盖次数及开关盖指令来源并记录在数据库中

第一部分

1.靠近时，垃圾桶开启2秒，2秒后关闭

事实上，做内核开发的人知道，setitimer和sleep是冲突的！因为它们都使用了信号SIGPROF，所以会产生冲突。解决办法是：把setitimer(ITIMER_PROF, &val, NULL);换成setitimer(ITIMER_REAL, &val, NULL);。其中：ITIMER_PROF和SIGPROF对应，ITIMER_REAL和SIGALRM对应：因为sleep()和setitimer()会互相干扰，都会发送SIGLARM信号

实际上，对于Linux而言，两个不同进程之间是不共享信号的，那么基于此，我们就可以通过使用进程来解决setitimer和sleep冲突的问题

2.垃圾桶开启带滴滴声 垃圾桶开启超过10秒，滴滴声警报

这里计时，采用开启一个线程来实现，其实第一部分，也可以通过开启线程来实现

开启bb线程，bb线程里面处理当垃圾桶开启时响1下，同时开始计时，超过了10s，再滴3s

计时demo

#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/time.h>
#include <errno.h>
//定时3s，如果3s内没有解锁，那么输出
//如果3s内解锁了，那么不输出

pthread_mutex_t mutex;
pthread_cond_t cond;
//定时d秒，j秒后解锁
int d,j;
//定时器的初始化
//定时器多长时间后超时
void timeD_init(struct timespec* timeD)
{

    timespec_get(timeD,TIME_UTC);
    timeD->tv_sec += j;
    printf("tv_sec=%ld\n",timeD->tv_sec);
}

int flag=0;

void* beep_wait_handler(void* arg)
{
    //等待主线程释放mutex锁
    pthread_mutex_lock(&mutex);
    //开始sleep
    printf("pthread_mutex_unlock=%d\n",pthread_mutex_unlock(&mutex));
    sleep(d);
    flag=1;
    pthread_cond_signal(&cond);
    pthread_exit(arg);
}

int main()
{

    int arg=2;
    //定时
    struct timespec timeD;
    //锁初始化
    pthread_mutex_init(&mutex,NULL);
    pthread_cond_init(&cond,NULL);

    //开启线程
    pthread_t beep_tidp;
    char* ret=NULL;

    while(1){
        flag=0;
        printf("定时d秒，j秒后超时\n");
        //定时d秒，j秒后超时

        scanf("%d %d",&d,&j);
        printf("定时%d,%d后超时",d,j);
        //锁住尽量确保定时的精准
        pthread_mutex_lock(&mutex);

        printf("lock run\n");
        if(pthread_create(&beep_tidp,NULL,beep_wait_handler,(void*)&arg) != 0){
            printf("beep_pthread create error\n");
            perror("why");
            exit(-1);
        }
        timeD_init(&timeD);

        //主线程初始化完毕，释放锁，让子线程开始计时
        pthread_mutex_unlock(&mutex);
        //等待子线程计时完毕，或者超时

        printf("flag1=%d\n",flag);

        if(pthread_cond_timedwait(&cond,&mutex,&timeD)==ETIMEDOUT){
            printf("超时了\n");
        }
        pthread_mutex_unlock(&mutex);
        pthread_join(beep_tidp,(void**)&ret);
        printf("flag2=%d\n",flag);
    }

    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&cond);

    return 0;
}

对于这个计时demo有一个很奇怪的点，在子线程中释放了互斥锁，但是在主线程中却依然要去再解一次锁，否则主线程会一直阻塞等待mutex这个锁。有点不理解为什么，以后有时间再搞明白。

注意：pthread_cond_timedwait(&cond,&mutex,&timeD)有时会出现超时了依然阻塞的情况，是因为运行到这里时，mutex锁无法被获取导致的，所以为了让其正常的超时时不阻塞，那么mutex锁在运行：wq时，必须是可获取状态

pthread的源码参考

int pthread_cond_timedwait(pthread_cond_t *restrict cond,
        pthread_mutex_t *restrict mutex,
        const struct timespec *restrict abstime)
{
    int err = 0;
    /* 获取互斥锁 */
    if ((err = pthread_mutex_lock(mutex)) != 0) {
        return err;
    }
    /* 根据cond的值挂起当前线程 */
    err = __pthread_cond_wait(cond, mutex, abstime, 0);
    /* 解除互斥锁 */
    (void)pthread_mutex_unlock(mutex);
    return err;
}

语音控制开关盖

这一块凸显出来的问题就是不同线程之间的调度问题，我太浅了，还没达到这个地步，将就着使用

主函数

 #include <stdio.h>
 #include <wiringPi.h>
 #include <unistd.h>
 #include <sys/time.h>
 #include <stdlib.h>
 #include <signal.h>
 #include "hc.h"
 #include <string.h>
 #include "sg90.h"
 #include <pthread.h>
 #include "beep.h"
 #include <wiringSerial.h>
 #include "voice.h"

 extern int jd;
 extern int sg90_cnt;

 double dis=0;//距离
 char flag=0;//防止响多次

 //舵机子进程
 int pip = 0;
 int hc_pipefd;
 int pipefd[2];
 char buf[24];

 //语音
 int voice_cmd=0;

 int main()
 {
     int arg=100;
     //初始化wiring为串口模式
     if(wiringPiSetup() == -1){
         fprintf(stderr,"%s","wiringPiSetup error\n");
         exit(-1);
     }

     //初始化hc
     hc_Init();
     printf("hcInit\n");
     //开启hc超声波线程
     pthread_t hc_tidp;
     if(pthread_create(&hc_tidp,NULL,hc_pthread_handler,(void*)&arg) != 0){
         printf("hc_tidp pthread_create error\n");
         perror("why:");
         exit(-1);
     }

     //舵机相关
     pip=pipe(pipefd);
     if(pip==-1){
         printf("error pip\n");
         exit(-1);
     }
     int pid = fork();
     if(pid == 0){
         //关闭子进程的写通道
         close(pipefd[1]);
         //初始化sg90舵机
         sg90_Init();
         sg90_process_handler(pipefd[0]);
     }else {
         //关闭父进程的读通道
         hc_pipefd = pipefd[1];
         close(pipefd[0]);
     }

     //初始化蜂鸣器
     beep_Init();
     //开启bb线程
     pthread_t beep_tidp;
     if(pthread_create(&beep_tidp,NULL,beep_pthread_handler,(void*)&arg) != 0){
         printf("beep_tidp pthread_create error\n");
         perror("why");
         exit(-1);
     }

     //语音控制开关盖
     //voic_Init();
     pthread_t voic_tidp;
     if(pthread_create(&voic_tidp,NULL,voic_pthread_handler,(void*)&arg) != 0 ){
       printf("voic_tidp pthread_create error\n");
       perror("why");
       exit(-1);
       }

     printf("voic_tidp\n");
     //voic_pthread_handler();
     while(1 && pid!=0){
         sleep(2);
     }

     return 0;
 }

超声波测距实现

#include <stdio.h>
#include <wiringPi.h>
#include <sys/time.h>
#include <unistd.h>
#include <string.h>

#define echo 9
#define trig 10
#define echo_value digitalRead(echo)

extern double dis;
extern char flag;
extern int hc_pipefd;//进程的pid
extern int voice_cmd;//语音的状态

void hc_Init()
{
    //设置echo为输出模式
    pinMode(echo,INPUT);
    //设置trig为输入模式
    pinMode(trig,OUTPUT);
}

double getDistance()
{
    double dis;
    struct timeval time_start;
    struct timeval time_stop;

    //怎么让它发波
    //Trig，给Trig端口至少10us的高电平
    digitalWrite(echo,LOW);
    digitalWrite(trig,LOW);
    usleep(5);
    digitalWrite(trig,HIGH);
    usleep(10);
    digitalWrite(trig,LOW);

    //怎么知道开始发了
    //Echo信号，由低电平跳转到高电平，表示开始发送波
    while(!echo_value);
    gettimeofday(&time_start,NULL);

    //怎么知道接收了返回波
    //Echo，由高电平跳转回低电平，表示波回来了

    while(echo_value){};
    gettimeofday(&time_stop,NULL);

    //怎么算时间
    //Echo引脚维持高电平的时间！
    long time = time_stop.tv_usec-time_start.tv_usec + (time_stop.tv_sec-time_start.tv_sec)*1000000;

    dis = (340/2)*time*0.0001;

    return dis;
}

void* hc_pthread_handler(void* arg)
{
    while(1){
        dis=getDistance();
        printf("distance:%lf\n",dis);
        if(dis<10 || voice_cmd == 1){
            //只响一次
            if(flag == 0){
                flag=1;
                write(hc_pipefd,"open",strlen("open"));
                sleep(2);
                voice_cmd = 0;
            }
        }else {
            write(hc_pipefd,"close",strlen("close"));
            flag=0;
        }
        sleep(1);

    }
}

舵机控制实现

:::info
必须把他放到子进程中，因为多线程中信号是共享的，也就是sleep()和setitimer()函数是共享一个信号的，会互相打断运行，同一进程就更不用说
:::

#include <stdio.h>
#include <wiringPi.h>
#include <signal.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#define pwm 2

extern double dis;
extern char flag;

int jd=0;
int sg90_cnt=0;

void sg90_signal_handler(int signal)
{

    if(signal == SIGALRM){

        sg90_cnt++;
        if(sg90_cnt <= jd){
            digitalWrite(pwm,HIGH);
        }else {
            digitalWrite(pwm,LOW);
        }

        if(sg90_cnt == 40){
            sg90_cnt=0;
            digitalWrite(pwm,HIGH);
        }
    }
}


void timer_Init()
{
    //定时器
    struct itimerval timer;
    //设定定时时长
    timer.it_interval.tv_sec=0;
    timer.it_interval.tv_usec=500;
    //多长时间后开始
    timer.it_value.tv_sec=1;
    timer.it_value.tv_usec=0;

    if(setitimer(ITIMER_REAL,&timer,NULL) == -1){
        fprintf(stderr,"%s","setitimer() error\n");
        exit(-1);
    }

    signal(SIGALRM,sg90_signal_handler);
}

void sg90_Init()
{
    pinMode(pwm,OUTPUT);
    timer_Init();
}

int sg90_process_handler(int pipefd)
{
    char buf[24];
    while(1){
        //子进程只起到一个控制舵机的功能
        //子进程不断从管道中获取值，一旦获取到相应的，那么就代表开关盖子
        memset(buf,'\0',24);
        read(pipefd,buf,24);
        if(strstr(buf,"open")){
            jd=5;
            sg90_cnt=0;
        }else if(strstr(buf,"close")){
            jd=0;
            sg90_cnt=0;
        }
        fflush(stdout);
    }
    return 0;
}

蜂鸣器实现

:::info
注意：pthread_cond_timedwait(&cond,&mutex,&timeD)有时会出现超时了依然阻塞的情况，是因为运行到这里时，mutex锁无法被获取导致的，所以为了让其正常的超时后不阻塞，那么mutex锁在运行时，必须是可获取状态
:::

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

#define BEEP 6
#define beep_high digitalWrite(BEEP,HIGH)
#define beep_low digitalWrite(BEEP,LOW)

extern char flag;

void beep_Init()
{
    pinMode(BEEP,OUTPUT);
    digitalWrite(BEEP,HIGH);
}

pthread_mutex_t mutex;
pthread_cond_t cond;
//定时d秒，j秒后解锁
//int d,j;
//定时器的初始化
//指定定时几秒
struct timespec timeD_init()
{
    struct timespec timeD;
    timespec_get(&timeD,TIME_UTC);
    timeD.tv_sec += 10;

    return timeD;
}

void* beep_wait_handler(void* arg)
{
    //等待主线程释放mutex锁
    pthread_mutex_lock(&mutex);

    pthread_mutex_unlock(&mutex);
    //开始sleep
    //等待flag变为0
    while(flag != 0);

    pthread_cond_signal(&cond);
    pthread_exit(arg);
}

//beep main pthread
//beep函数的主线程
void* beep_pthread_handler(void* arg)
{
    struct timespec timeD;
    //锁初始化
    pthread_mutex_init(&mutex,NULL);
    pthread_cond_init(&cond,NULL);

    //开启线程
    pthread_t beep_tidp;
    char* ret=NULL;

    while(1){

        beep_high;
        while(flag==0);
        beep_low;
        sleep(1);
        beep_high;

        pthread_mutex_unlock(&mutex);
        pthread_mutex_lock(&mutex);

        printf("lock run\n");
        if(pthread_create(&beep_tidp,NULL,beep_wait_handler,arg) != 0){
            printf("beep_pthread create error\n");
            perror("why");
            exit(-1);
        }
        timeD=timeD_init();

        //主线程初始化完毕，释放锁，让子线程开始计时
        pthread_mutex_unlock(&mutex);
        //等待子线程计时完毕，或者超时
        while(pthread_cond_timedwait(&cond,&mutex,&timeD) == ETIMEDOUT){
            printf("flag=%d\n",flag);
            beep_low;
            sleep(2);
            break;
        }
        pthread_mutex_unlock(&mutex);
        pthread_join(beep_tidp,(void**)&ret);
    }

    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&cond);

    return 0;
}

语音控制

语音控制偶尔失效的原因我猜测是线程调度问题，如果放到主线程中，运行应该不会出现偶尔失效的问题。

voice.c
#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>
#include "uartTools.h"

int voic_fd;
extern int voice_cmd;

void voic_Init()
{
    if((voic_fd = myserialOpen("/dev/ttyS5",9600)) < 0){
        printf("mySerialOpen() error\n");
        perror("why");
        exit(-1);
    }
}

void* voic_pthread_handler(void* arg)
{
    voic_Init();
    char cmd;
    printf("voic_fd=%d\n",voic_fd);

    while(1){
        cmd = serial_Get_char_one(voic_fd);

        printf("this is cmd=%c\n",cmd);
        switch(cmd){
            case 'O':
                printf("open\n");
                voice_cmd=1;
                break;
            case 'C':
                printf("close\n");
                voice_cmd=0;
                break;
        }
        
        /*
		这一个while()的作用是用于提高线程优先级，如果疑惑，可以尝试将这段while删除
        看看语音控制是否会偶尔失效
        */
        while(serialDataAvail(voic_fd));
        
        sleep(1);
    }
    pthread_exit(arg);

}

uartTools.c
 #include <string.h>
 #include <termios.h>
 #include <unistd.h>
 #include <fcntl.h>
 #include <sys/ioctl.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include "wiringSerial.h"

 int myserialOpen (const char *device, const int baud)
 {
     struct termios options ;
     speed_t myBaud ;
     int     status, fd ;
     switch(baud)
     {
         case    9600:   myBaud =    B9600 ; break ;
         case  115200:   myBaud =  B115200 ; break ;
         default:
                         return -2 ;
     }

     if ((fd = open (device, O_RDWR | O_NOCTTY | O_NDELAY | O_NONBLOCK)) == -1)
         return -1 ;
     fcntl (fd, F_SETFL, O_RDWR) ;

     // Get and modify current options:

     tcgetattr (fd, &options) ;

     cfmakeraw   (&options) ;
     cfsetispeed (&options, myBaud) ;
     cfsetospeed (&options, myBaud) ;

     options.c_cflag |= (CLOCAL | CREAD) ;
     options.c_cflag &= ~PARENB ;
     options.c_cflag &= ~CSTOPB ;
     options.c_cflag &= ~CSIZE ;
     options.c_cflag |= CS8 ;
     options.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG) ;
     options.c_oflag &= ~OPOST ;

     options.c_cc [VMIN]  =   0 ;
     options.c_cc [VTIME] = 100 ;    // Ten seconds (100 deciseconds)

     tcsetattr (fd, TCSANOW, &options) ;

     ioctl (fd, TIOCMGET, &status);

     status |= TIOCM_DTR ;
     status |= TIOCM_RTS ;

     ioctl (fd, TIOCMSET, &status);

     usleep (10000) ;    // 10mS

     return fd ;

 }

 int serial_Get_char_one(const int fd)
 {
     char ch;
     read(fd,&ch,1);

     return ch;
 }

第二部分

  • 回顾二阶段的Socket编程，实现Sockect客户端发送指令远程打开/关闭垃圾桶，并显示垃圾桶状态
  • 统计当天垃圾桶开关盖次数及开关盖指令来源并记录在文件中
  • 统计当天垃圾桶开关盖次数及开关盖指令来源并记录在数据库中

Socket

demo如下

服务器端
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <string.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <pthread.h>

void error_handler(char* reason)
{
    printf("%s error\n",reason);
    perror("why");
    exit(-1);

}

int socket_connect=0;

void* read_pthread_handler(void* arg)
{
    char read_buf[1024];
    while(1){
        memset(read_buf,'\0',strlen(read_buf));
        if(read(socket_connect,read_buf,1024) == -1){
            error_handler("read()");
        }
        printf("client:%s\n",read_buf);
        fflush(stdout);
    }

    pthread_exit(arg);
}

int main(int argc,char** argv)
{
    if(argc<2){
        error_handler("argc");
        exit(-1);
    }

    int socket_fd=0;
    //1.创建套接字
    //int socket(int domain, int type, int protocol)
    if((socket_fd = socket(AF_INET,SOCK_STREAM,0)) == -1){
        error_handler("socket()");
    }
    printf("socket success\n");

    //2.为套接字添加信息：IP地址和端口
    //int bind(int sockfd,const struct sockaddr *addr,socklen_t addrlen)
    struct sockaddr_in addr;
    memset(&addr,0,sizeof(addr));
    addr.sin_family = AF_INET;
    addr.sin_port = htons(atoi(argv[1]));
    if(inet_aton("192.168.31.75",&(addr.sin_addr)) == 0){
        error_handler("inet_aton()");
    }

    if(bind(socket_fd,(struct sockaddr*)&addr,sizeof(addr)) == -1){
        error_handler("bind()");
    }
    printf("bind success\n");

    //3.监听网络连接
    //int listen(int sockfd,int backlog);
    if(listen(socket_fd,2) == -1){
        error_handler("listen()");
    }
    printf("listen success\n");

    //4.监听到有客户端接入，接收一个连接

    //int accept(int sockfd,struct sockaddr* addr,socklen_t* addrlen)
    int addr_len = sizeof(addr);
    if((socket_connect = accept(socket_fd,(struct sockaddr*)&addr,&addr_len))==-1){
        error_handler("accept()");
    }
    //5.数据交互
    //read()、write()
    char buf[1024] = "hello,this is service\n";

    //开启一个子线程负责读取客户端的发送
    //主线程负责发送
    pthread_t socket_pthread_tidp;
    int arg=10;
    if(pthread_create(&socket_pthread_tidp,NULL,read_pthread_handler,(void*)&arg) != 0){
        error_handler("socket_pthread");
    }

    while(1){
        memset(buf,'\0',strlen(buf));
        scanf("%s",buf);
        write(socket_connect,buf,strlen(buf));
        fflush(stdin);
    }

    //收取线程资源
    pthread_join(socket_pthread_tidp,NULL);

    //6.关闭套接字，断开连接
    //close()
    close(socket_fd);
    return 0;
}

客户端
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <string.h>
#include <pthread.h>
#include <arpa/inet.h>


int socket_id =0;
void error_handler(char* reason){

    printf("%s error\n",reason);
    perror("why?");
    exit(-1);
}

void* chail_read_pthread_handler(void* arg)
{
    char read_buf[1024];

    while(1){
        memset(read_buf,'\0',strlen(read_buf));
        read(socket_id,read_buf,1024);
        printf("service:%s\n",read_buf);
        fflush(stdout);
    }

    pthread_exit(arg);
}
//子线程负责读，主线程负责写
int main(int argc,char** argv)
{
    if(argc<2){
        error_handler("argc<2");
    }
    //int socket(int domain, int type, int protocol)
    if((socket_id = socket(AF_INET,SOCK_STREAM,0)) == -1){
        error_handler("socket()");
    }
    printf("socket success\n");

    //int connect(int sock, struct sockaddr *serv_addr, socklen_t addrlen);
    struct sockaddr_in addr;
    memset(&addr,0,sizeof(addr));

    addr.sin_family=AF_INET;
    addr.sin_port=htons(atoi(argv[1]));
    inet_aton("192.168.31.75",&(addr.sin_addr));

    if(connect(socket_id,(struct sockaddr*)&addr,sizeof(addr)) == -1){
        error_handler("connect()");
    }

    //write()、read()
    //create child process
    pthread_t read_tidp;
    int arg=11;
    if(pthread_create(&read_tidp,NULL,chail_read_pthread_handler,(void*)&arg));

    char write_buf[1024];
    while(1){
        memset(write_buf,'\0',1024);
        scanf("%s",write_buf);
        write(socket_id,write_buf,strlen(write_buf));
        fflush(stdin);
    }
    pthread_join(read_tidp,NULL);
    //close()
    close(socket_id);
    return 0;
}

这一套demo有问题，当服务器端或者客户端断开时，另一端会疯狂刷屏
然后，项目进行到这里，必须抛弃管道了（可能是我不太熟练的原因），替代品是共享内存，同时为了避免竞争，socket控制开关盖使用信号控制

共享内存demo
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/types.h>
#include <stdlib.h>

//创建两个子进程，一个子进程向父进程中写，一个子进程读父进程中写的东西
int pid1,pid2;
void one_process(int share_id)
{
    void* one_addr = shmat(share_id,0,0);
    char buf[1024];
    while(1){
        memset(buf,'\0',strlen(buf));
        scanf("%s",buf);
        strcpy((char*)one_addr,buf);
        sleep(1);
    }
    shmdt(one_addr);
}
void two_process(int share_id)
{   void* two_addr = shmat(share_id,0,0);
    perror("why:");
    while(1){
        printf("this is two read:%s\n",(char*)two_addr);
        sleep(1);
    }
 	shmdt(two_addr);
}
int main()
{
    //创建共享内存
    key_t key = ftok(".",12);
    int share_id = shmget(key,1024*4,IPC_CREAT|0600);
    void *map_address = shmat(share_id,0,0);
    printf("shmat:OK\n");


    pid1 = fork();
    if(pid1 == 0){
        //这里负责读
        one_process(share_id);
        return 0;
    }

    pid2 = fork();

    if(pid2 == 0){
        //负责写
        two_process(share_id);
        return 0;
    }
    while(1){
        sleep(1);
    }
    shmctl(share_id,IPC_RMID,0);
    return 0;
}

统计当天垃圾桶开关盖次数及开关盖指令来源并记录在文件中

统计当天：获取系统的日期，即年月日然后进行判断
开关盖有三个来源，分别是socket、超声波以及语音控制
当dis<10时，超声波开盖加1
当dis>10时，超声波关盖加1
socket发送一次open，socket开盖+1
发送一次close，socket关盖+1
语音控制一个open，语音开盖+1
发送一次close，语音关盖+1

测试的demo

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>

void error_handler(char* reason);
void file_Init(int fd);
void config_ration(int fd);
time_t now;
//today date
char now_date[50];

//file data
char buf[500];
char addr_buf[200];
time_t now;
struct tm* tm_now;
char datetime[200];
int gd_len=0;

//数字转换
char num_buf[10];
//得到数字
int getNum(char* addr)
{
    char* p = addr;

    memset(num_buf,'\0',strlen(num_buf));
    int i=0;
    while((*p) != '\n'){
        num_buf[i++] = *p;
        p++;
    }
    printf("num1=%s\n",num_buf);
    return atoi(num_buf);

}
//将数字塞进去
void setNum(char* addr,int int_num)
{
    char* p = addr;
    memset(num_buf,'\0',strlen(num_buf));

    printf("sprintf\n");
    sprintf(num_buf,"%d%c",int_num,'\0');
    printf("stop sprintf\n");
    int i=0;
    while(num_buf[i] != '\0'){
        *p=num_buf[i++];
        p++;
    }
}

//第二个参数是指，来源是什么，如果是hc_open,那么sorce=hc_open
void date_Init(int fd,char* sorce)
{
    //注意光标位置，运行到这里时，光标要么在首部(<450)，要么在基于尾部的450处(>450)
    //每一次开关盖，都获取当天日期，然后比对，如果没有那么运行初始化
    //获取
    time(&now);
    tm_now = localtime(&now);
    strftime(datetime,200,"%Y-%m-%d\n",tm_now);
    char* str_addr=NULL;
    //比对
    if((str_addr = strstr(buf,datetime)) == NULL){
        //如果没有，那么就代表是新的一天，需要重新建立数据
        //运行完毕后buf中会重新填满数据
        config_ration(fd);
        str_addr = strstr(buf,datetime);
    }
    //运行到了这里，代表文件中是一定有对应日期的相应数据
    //str_addr一定是指向了第一次出现对应日期的首地址
    //移动光标到相应首地址位置
    int len = str_addr-buf;
    lseek(fd,len,SEEK_CUR);

    //那么重新获取相应的地址填充addr_buf
    //计算确认要读取多少个字节
    int str_num = strlen(buf)-len;
    //准备读取数据
    read(fd,addr_buf,str_num);
    //再次移动光标到addr_buf对应的首地址处
    lseek(fd,-str_num,SEEK_END);
    //获取对应数据的首地址
    char* num_addr = strstr(addr_buf,sorce);
    //移动num_addr到数据处
    num_addr = num_addr+strlen("hc_open     =");
    //将数字读取出来
    printf("addr_buf:%s\n",addr_buf);
    int num = getNum(num_addr);
    num = num+1;
    setNum(num_addr,num);
    write(fd,addr_buf,strlen(addr_buf));
}

int main()
{
    int fd = open("record",O_RDWR|O_CREAT,0600);
    gd_len = strlen("hc_open     =0   \n");
    if(fd == -1){
        error_handler("fd error\n");
    }
    file_Init(fd);
    date_Init(fd,"hc_open");
    close(fd);
    return 0;
}
//读取文件，将光标移动到文件尾部，判断是否超过了450
//如果超过了，那么只读取450个字节，如果没有超过，那么全部读取出来
//这样做是为了尽量避免buf溢出
//这一个程序只负责移动光标以及填充buf
void file_Init(int fd)
{

    //移动光标到头部，保证进入这一段程序时，光标一定在头部
    lseek(fd,0,SEEK_SET);
    int file_num = lseek(fd,0,SEEK_END);
    lseek(fd,0,SEEK_SET);
    if(file_num>450){
        //大于450，那么移动光标
        lseek(fd,-450,SEEK_END);
    }
    //冲刷buf
    memset(buf,'\0',strlen(buf));
    //读取文件
    read(fd,buf,450);
    //读取完毕，将光标移回去
    if(file_num>450){
        lseek(fd,-450,SEEK_END);
    }else {
        lseek(fd,0,SEEK_SET);
    }
}
void error_handler(char* reason)
{
    printf("%s error\n",reason);
    perror("why?");
    exit(-1);
}
void config_ration(int fd){

    //移动光标到尾部
    lseek(fd,0,SEEK_END);
    //写入数据
    //这里依然可以优化，也就是如果是不对齐的呢？
    //时间
    write(fd,datetime,strlen(datetime));
    //hc num
    write(fd,"hc_open     =0   \n",gd_len);
    write(fd,"hc_close    =0   \n",gd_len);
    //voice num
    write(fd,"voice_open  =0   \n",gd_len);
    write(fd,"voice_close =0   \n",gd_len);
    //socket num
    write(fd,"socket_open =0   \n",gd_len);
    write(fd,"socket_close=0   \n",gd_len);
    //写入完毕，再次重新刷新buf，(这是一个优化点)
    //printf("strlen=%ld\n",strlen("socket_open =0\n"));
    file_Init(fd);
}

统计当天垃圾桶开关盖次数及开关盖指令来源并记录在数据库中

1张表

create table datetime(
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    dateTime TEXT	NOT NULL,
    hc_open INT DEFAULT 0,
    hc_close INT DEFAULT 0,
    voice_open INT DEFAULT 0,
    voice_close INT DEFAULT 0,
    socket_open INT DEFAULT 0,
    socket_close INT DEFAULT 0
);
insert into datetime values(NULL,"2023-5-8",0,0,0,0,0,0);

sqlite测试demo

 #include <stdio.h>
 #include <stdlib.h>
 #include <sqlite3.h>
 #include <string.h>
 #include <time.h>

 char exist_sql();
 void table_Init();
 void get_time();
 int date_exist();
 void add_ljt();

 char buf[1024];
 char sql_buf[100];
 sqlite3* sql_fd;

 int exist_callback(void *arg, int column_size, char *column_value[], char *column_name[])
 {
     int* count=(int*)arg;
     *count = atoi(column_value[0]);
     return 0;
 }

 int select_callback(void *arg, int column_size, char *column_value[], char *column_name[])
 {
     int i=0;
     for(;i<column_size;++i){
         printf("%d,%s:%s\n",i,column_name[i],column_value[i]);
     }
     int count = atoi(column_value[2]) + 1;
     memset(sql_buf,'\0',strlen(sql_buf));

     sprintf(sql_buf,"update ljt set hc_open=%d where id=%s;",count,column_value[0]);
     printf("update=%s\n",sql_buf);

     sqlite3_exec(sql_fd,sql_buf,NULL,NULL,NULL);

     return 0;
 }
 int main()
 {
     int date_flag=-1;
     char exist_sql_flag = exist_sql();
     sqlite3_open("sql.db",&sql_fd);

     if(exist_sql_flag == 0){
         table_Init();
     }
     date_flag =  date_exist();
     //辨别当天日期是否存入
     if(date_flag == -1){
         printf("date_exist() error\n");
         exit(-1);
     }else if(date_flag == 0){
         //如果没有数据，那么添加一条
         add_ljt();
     }
     printf("datetime=%s,strlen()=%ld\n",buf,strlen(buf));
     //更新对应数据
     sqlite3_exec(sql_fd,"select * from ljt;",select_callback,NULL,NULL);

     return 0;
 }

 void add_ljt()
 {
     memset(sql_buf,'\0',strlen(sql_buf));
     sprintf(sql_buf,"insert into ljt values(NULL,\"%s\",0,0,0,0,0,0);",buf);
     sqlite3_exec(sql_fd,sql_buf,NULL,NULL,NULL);
 }

 int date_exist()
 {
     int count=-1;
     get_time();
     memset(sql_buf,'\0',strlen(sql_buf));
     snprintf(sql_buf,sizeof(sql_buf),"select count(*) from ljt where %s;",buf);
     printf("%s\n",sql_buf);
     sqlite3_exec(sql_fd,sql_buf,exist_callback,&count,NULL);
     return count;
 }


 void get_time()
 {
     //获取时间
     memset(buf,'\0',strlen(buf));
     time_t now;
     struct tm* tm_now;
     time(&now);
     tm_now = localtime(&now);
     strftime(buf,200,"%Y-%m-%d",tm_now);
 }

 void table_Init(){
     char* table="create table ljt("\
                  "id INTEGER PRIMARY KEY AUTOINCREMENT,"\
                  "dateTime char(50) NOT NULL,"\
                  "hc_open INT DEFAULT 0,"\
                  "hc_close INT DEFAULT 0,"\
                  "voice_open INT DEFAULT 0,"\
                  "voice_close INT DEFAULT 0,"\
                  "socket_open INT DEFAULT 0,"
                  "socket_close INT DEFAULT 0"\
                  ")";
     sqlite3_exec(sql_fd,table,NULL,NULL,NULL);
 }

 //检测是否存在sql.db文件
 char exist_sql()
 {
     memset(buf,'\0',strlen(buf));
     FILE* file = popen("ls","r");

     fread(buf,1024,1,file);

     if(strstr(buf,"sql.db") == NULL){
         return 0;
     }
     return 1;
 }

总体代码

链接: gitHub

总结

这一个项目让我发现了非常多的问题，比如上面提到的使用条件变量时，要注意mutex必须要被及时获取到。
然后项目中有许多的优化点，比如写入文件和写入数据库的时候，会发现写入的数据不对。

GS8FG
关注
  • 1
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于Linux全志H3开发板的智能垃圾桶
weixin_57296333的博客
03-23 786
Linux智能垃圾桶
linux的垃圾箱是哪个文件夹,Ubuntu命令行的垃圾箱Trash CLI，远离 rm 命令误删除重要文件的阴影...
weixin_30118803的博客
05-05 3049
原标题：Ubuntu命令行的垃圾箱Trash CLI，远离 rm 命令误删除重要文件的阴影 作为Linux用户，您可能需要不时从系统中删除文件。我们在删除文件时往往会保持谨慎，特别是在永久删除文件时，因为我们不想永远错误地丢失有用的信息。不幸的是，有些情况下我们会错误地删除某些内容而无法恢复它。或者，我们打算只删除文件夹中的文件，但也错误地从子文件夹中删除文件。在图形界面中，事物几乎可见，并且还有...
linux - rm命令删除文件到垃圾箱
最新发布
种一棵树，最好的结果是十年前，其次是现在！
03-26 717
pass@pass:~/.trash$ cat /var/log/cron.log 检查定时任务日志执行成功。修改原来的rm指令到垃圾箱，对于误操作的删除可以直接从垃圾箱里拉回来，同时提高网络安全意识。pass@pass:~$ select-editor 该指令可以重新选择编辑器。（注：首次创建会提示什么工具编辑，这里建议vim选择2）ubuntu 查看cron定时日志方法。检查删除的文件是否放到垃圾箱。定期删除垃圾数据，节省空间。将文件从垃圾箱拉取到本地。验证定时清理任务的执行。
linux 创建一个垃圾篓防误删及其误删文件恢复
smilejiasmile的博客
11-05 600
一、创建一个垃圾篓 给你的linux创建一个垃圾篓/回收站，防误删 创建一个垃圾回收站，保存被删除距今3天的文件，过期则被删除 1. 在你的主目录下，创建文件夹 .trash cd ~ mkdir .trash 2. 在你的常用脚本目录下创建这俩脚本 #!/bin/bash TRASH_DIR="/home/lixy/.trash" for i in $*; do STAMP=`date +%s` fileName=`basename $i` if [[ -d
智能垃圾桶 Linux和树莓派-网络编程（总结）
Addrews的博客
08-31 911
前期准备： 1.OLED液晶显示模块 2.L9110马达驱动模块 3.HC-SR04超声波模块 4.SG90舵机驱动模块 5.DS18B20温度检测模块 6.树莓派3B 模块原理： OLED液晶显示屏： 液晶显示是点阵显示，就是一个一个的点显示在屏幕上，靠这些点的亮灭组合来完成我们想要的目标。 1.那么我们 要想显示就得先创建一个用来初始化屏幕的数组。 2.我们创建一个能显示内容在屏幕上的数...
在linux/centos中构建一个“垃圾桶”
blackcloud
09-17 747
人类犯错误时因为我们不是一台电脑，所以在使用rm命令时要额外注意，不要在 任何时候使用rm -rf *当你使用rm命令时，它会永久删除文件，不会像文件管理器那样将这些文件移动到“垃圾箱” 将文件移动到“垃圾箱”是一个好主意，当你无意中运行rm命令时候，可以拯救你i；但是很少有人会说这是个好习惯，如果你不注意“垃圾桶”，它可能会在一段时间内被文件和目录堆积起来。在这种情况下，建议你按照你的意愿去做...
NOR Flash的三种基本操作擦（erase），写（write），更新（update）实现方式
bkyy123的博客
05-02 1万+
//分享一下芯片底层Flash操作，因为工作相关，主要接触三星的芯片居多。很多芯片应用都是由芯片厂商提供API来辅助开发，API是个黑盒，知道输入条件和结果。降低了客户开发的难度，但是API需要导入LIB才能使用，占用空间啊。其实根据芯片的usermanual完全可以自己实现。一.擦（erase）    Flash 的编程原理都是只能将 1 写为 0，而不能将 0 写为 1。所以在 Flash 编...
为linux添加一个垃圾桶
newbietao的博客
04-06 1693
就在刚才迷迷糊糊的就把 /usr 给 rm -rf 了，当时身上冷汗都冒出来了。好在只是工作和学习的云主机上边的内容并不重要，于是就重新做系统了。这些都不是重点重点是怎么能避免下一次再犯这样的低级错误，下面我给大家提供了一个解决方案。1.添加一个垃圾桶   在根目录下创建一个trash目录，并将目录权限修改为755。# cd / # mkdir trash # chmod 755 trash2.编...
Linux系统中用命令行清空垃圾箱Trash
热门推荐
快乐晓笑
06-08 4万+
我用的系统是Ubuntu16.04,最近遇到了一个问题是，当我的垃圾箱有大量的小文件时，当我用图形界面清空垃圾箱时，总是卡死，而其清理很慢，于是用命令行清理，代码如下：这里的关键是确定你的系统的 Trash文件夹在那个路径。我的系统用以下命令：　$ sudo rm -rf /home/yourname/.local/share/Trash/
Linux垃圾桶
weixin_43214808的博客
03-04 1177
部署一个垃圾桶，防止删错文件 #下载GitHUB上的垃圾桶项目，并把服务添加至系统级 #yum -y install git #git clone https://github.com/lagerspetz/linux-stuff #mv linux-stuff/scripts/saferm.sh /usr/bin/ #设置 “rm” 的别名为 saferm.sh &lt;在文件末尾添加&gt;...
linux_为rm命令添加“垃圾桶”
也许有一天我们再相逢 睁开眼睛看清楚 我才是英雄！
05-05 707
1.rm命令解析rm命令可以删除一个目录中的一个或多个文件或目录，也可以将某个目录及其下属的所有文件及其子目录均删除掉。对于链接文件，只是删除整个链接文件，而原有文件保持不变。注意：使用rm命令要格外小心。因为一旦删除了一个文件，就无法再恢复它。所以，在删除文件之前，最好再看一下文件的内容，确定是否真要删除。rm命令可以用-i选项，这个选项在使用文件扩展名字符删除多个文件时特别有用。使用这个选项，...
linux垃圾桶项目
qq_33014857的博客
03-24 391
#下载github上的垃圾桶项目，并把程序添加至系统级$ yum -y install git$ git clone https://github.com/lagerspetz/linux-stuff$ mv linux-stuff/scripts/saferm.sh /usr/bin/#设置"rm"的别名为saferm.sh &lt;在文件末尾加&gt;vim .bashrcalias rm='...
linux　回收站的路径
Masha
02-23 2万+
~/.local/share/Trash
linux 私人垃圾箱的实现。
yuhengyue的博客
12-11 520
linux下的rm命令是个危险的命令，它不会把文件放入垃圾箱，而是直接删除。有时候不小心会造成无法挽回的后果。私人垃圾箱是个解决此类问题的好办法。它通过alias机制指向一个脚本，脚本里做的事情就是把文件mv到私人垃圾箱。 以ubuntu12.04举例， ubuntu自带了一个垃圾箱，但是它针对的是窗口界面操作，在终端里用不到。 一，创建私人垃圾箱 假设我的用户名是john。 mkdir...
linux 垃圾箱位置,如何将Linux rm命令删除的文件放入垃圾箱
weixin_39758494的博客
05-13 419
因为rm命令删除的文件是不会放入垃圾箱的，所以无法恢复，下面小编就给大家介绍一种方法，通过替换Linux rm命令的方法，从而将rm命令删除的文件放入垃圾箱。方法：1. 在/home/username/ 目录下新建一个目录，命名为：.trash2. 在/home/username/tools/目录下，新建一个shell文件，命名为： remove.shPARA_CNT=$#TRASH_DIR=“/...
ubuntu trash 垃圾箱的文件存储位置
学习记录
12-01 2万+
前几天我有一个很重要的文件，但是一不小心让我删除了，但是我的垃圾箱似乎坏掉了，一打开就崩溃，所以我就想可以尝试从文件目录中去找回来，然后查到： ubuntu Trash ‘s location 记录一下ubuntu的回收站位置，今天遇到了回收站不能清空；记录一下。 ~/.local/share/Trash/   对就是这个位置。
linux命令清空垃圾箱
来自塞北的神算子的博客
08-17 2456
使用的系统：ubuntu16.04 碰到的问题：要删除的文件太大了，是一个.tar.bz2文件解压后２g多的软件包，桌面清空trash完成不了，计算机一直在卡死 解决方式：trash　在系统中的位置是/home/your username(你的系统安装时自己设定的用户名)/.local/share/Trash                   命令　rm -rf 可以删除文件，并且可以删除
Ubuntu 删除缓存(转载)
^greatcolor 待到道成日，纵横天地间！
12-11 2488
linux和windows系统不同，linux不会产生无用垃圾文件，但是在升级缓存中，linux不会自动删除这些文件，还是很占硬盘的！ 一、删除缓存 1，非常有用的清理命令：sudo apt-get autoclean                清理旧版本的软件缓存sudo apt-get clean                    清理所有软件缓存sudo apt-get au...
海口智能垃圾桶项目：商业计划与市场机遇分析
"海口'智能垃圾桶'有限公司商业计划书提供了一个详细而具有前瞻性的智能垃圾桶项目的实施方案。该公司专注于专业生产和出口智能感应垃圾桶系列，凭借其自主研发能力和国家专利知识产权，产品在市场上具有竞争优势。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值