五、mini2440按键，从设备文件读取按键数据

最新推荐文章于 2024-08-01 15:05:06 发布
最新推荐文章于 2024-08-01 15:05:06 发布
阅读量187 收藏 1
点赞数
分类专栏： 智能音箱 文章标签： java 算法 数据结构 Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_60961911/article/details/128838041
版权

select.c

else if (FD_ISSET(g_buttonfd, &tmpfd))    //按键有数据可读
        {
            int id = get_key_id();
            switch (id)
            {
                case 1:
                    start_play();
                    break;
                case 2:
                    stop_play();
                    break;
                case 3:
                    suspend_play();
                    break;
                case 4:
                    continue_play();
                    break;
                case 5:
                    prior_play();
                    break;
                case 6:
                    next_play();
                    break;
            }
        }

因为学习记录的所以不全，全部代码如下，如有需要可以自取：

一、device.c

//用于操作硬件设备

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include "main.h"
#include <sys/ioctl.h>

extern int g_buttonfd;
extern int g_ledfd;
extern int g_mixerfd;
extern int g_maxfd;

int InitDriver()
{
    //打开按键设备文件
    g_buttonfd = open("/dev/buttons", O_RDONLY);
    if (-1 == g_buttonfd)
    {
        return FAILURE;
    }

    //打开led设备文件
    g_ledfd = open("/dev/leds", O_WRONLY);
    if (-1 == g_ledfd)
    {
        return FAILURE;
    }

    //所有LED灭
    int i;
    for (i = 0; i < 4; i++)
    {
        ioctl(g_ledfd, 0, i);
    }

    //打开minxer设备文件
    g_mixerfd = open("/dev/mixer", O_WRONLY);
    if (-1 == g_mixerfd)
    {
        return FAILURE;
    }

    if (g_mixerfd > g_maxfd)
    {
        g_maxfd = g_mixerfd;
    }

    return SUCCESS;
}

void led_on(int which)
{
    ioctl(g_ledfd, 1, which);    
}

void led_off(int which)
{
    ioctl(g_ledfd, 0, which);
}

int get_key_id()
{
    char buttons[6] = {'0', '0', '0', '0', '0', '0'};
    char cur_buttons[6] = {0};

    int ret = read(g_buttonfd, cur_buttons, sizeof(cur_buttons));
    if (-1 == ret)
    {
        perror("read");
    }

    int i;
    for (i = 0; i < 6; i++)
    {
        if (buttons[i] != cur_buttons[i])
        {
            return i + 1;
        }
    }
    return 0;
}

二、device.h

#ifndef DEVICE_H
#define DEVICE_H

int InitDriver();
int led_on(int which);
int led_off(int which);

#endif

三、link.c

#include <stdio.h>
#include <stdlib.h>
#include "main.h"
#include <string.h>
#include "link.h"
#include "player.h"
#include <time.h>

extern struct Node *head;

//初始化双向循环链表
int InitLink()
{
    head = (Node *)malloc(sizeof(Node) * 1);
    if (NULL == head)
    {
        return FAILURE;
    }

    head->next = head;
    head->prior = head;

    return SUCCESS;
}

int InsertLink(Node *h, const char *name)
{
    if (NULL == h || NULL == name)
    {
        return FAILURE;
    }

    Node *end = h->prior;


    Node *n = (Node *)malloc(sizeof(Node) * 1);
    if (NULL == n)
    {
        return FAILURE;
    }

    n->next = h;
    strcpy(n->music_name, name);
    end->next = n;
    n->prior = end;
    h->prior = n;

    return SUCCESS;
}

/*
函数描述：根据当前歌曲和播放模式，找到下一首歌
函数参数：cur：当前歌曲
          mode:播放模式
          next：存放下一首歌名
返回值：无
*/
void FindNextMusic(const char *cur, int mode, char *next)
{
    if (mode == CIRCLE)     //单曲循环
    {
        strcpy(next, cur);
        return;
    }
    else if (mode == SEQUENCEMODE)
    {
        Node *p = head->next;
        while (strcmp(p->music_name, cur) != 0)
        {
            p = p->next;
        }
            
        if (p->next == head)          //忽略头结点
        {
            strcpy(next, head->next->music_name);
        }
        else
        {
            strcpy(next, p->next->music_name);
        }
        return;
    }
    else 
    {
        Node *p = head->next;
        srand(time(NULL));
        int num = rand() % 100;

        int i;
        for (i = 0; i < num; i++)
        {
            p = p->next;
        }

        if (p == head)
        {
            strcpy(next, head->next->music_name);
        }
        else
        {
            strcpy(next, p->music_name);
        }

        return;
    }
}

void PriorMusic(const char *cur, int mode, char *prior)
{
    if (mode == SEQUENCEMODE || mode == CIRCLE)
    {
        Node *p = head->next;
        while (strcmp(p->music_name, cur) != 0)
        {
            p = p->next;
        }

        if (p == head->next)
        {
            printf("%s\n", head->prior->music_name);
            strcpy(prior, head->prior->music_name);
        }
        else
        {
            strcpy(prior, p->prior->music_name);
        }
        return;
    }
    else 
    {
        Node *p = head->next;
        srand(time(NULL));
        int num = rand() % 100;

        int i;
        for (i = 0; i < num; i++)
        {
            p = p->next;
        }

        if (p == head)
        {
            strcpy(prior, p->next->music_name);
        }
        else
        {
            strcpy(prior, p->music_name);
        }

        return;
    }
}

void NextMusic(const char *cur, int mode, char *next)
{
    if (mode == SEQUENCEMODE || mode == CIRCLE)
    {
        Node *p = head->next;
        while (strcmp(p->music_name, cur) != 0)
        {
            p = p->next;
        }

        if (p->next == head)
        {
            strcpy(next, head->next->music_name);
        }
        else
        {
            strcpy(next, p->next->music_name);
        }
        return;
    }
    else 
    {
        Node *p = head->next;
        srand(time(NULL));
        int num = rand() % 100;

        int i;
        for (i = 0; i < num; i++)
        {
            p = p->next;
        }

        if (p == head)
        {
            strcpy(next, p->next->music_name);
        }
        else
        {
            strcpy(next, p->music_name);
        }

        return;
    }
}

四、link.h

#ifndef LINK_H
#define LINK_H

struct Node
{
    char music_name[64];
    struct Node *next;
    struct Node *prior;
};
typedef struct Node Node;

int InitLink();
void FindNextMusic(const char *cur, int mode, char *next);
int InsertLink(Node *h, const char *name);
void PriorMusic(const char *cur, int mode, char *prior);
void NextMusic(const char *cur, int mode, char *next);

#endif

五、main.c

#include <stdio.h>
#include "main.h"
#include "device.h"
#include <stdlib.h>
#include "socket.h"
#include "link.h"
#include "player.h"
#include <signal.h>
#include <sys/ipc.h> 
#include <sys/shm.h>
#include <string.h>
#include <sys/select.h>

int g_buttonfd = 3;
int g_ledfd;
int g_mixerfd;
int g_sockfd = 3;
struct Node *head;
extern int shmid;
extern void *g_addr;
fd_set readfd, tmpfd;
int g_maxfd;


void m_select();

void handler(int sig)
{
    shm s;
    memset(&s, 0, sizeof(s));
    memcpy(&s, g_addr, sizeof(s));
    kill(s.child_pid, SIGKILL);
    kill(s.grand_pid, SIGKILL);

    shmdt(g_addr);
    shmctl(shmid, IPC_RMID, NULL);

    close(g_sockfd);

    exit(0);
}

int main()
{
    int ret;
    ret = InitDriver();     //打开设备文件
    if (FAILURE == ret)
    {
        printf("初始化设备文件失败\n");
        exit(1);
    }
    
    InitSelect();

    ret = InitSocket();      //初始化网络
    if (FAILURE == ret)
    {
        printf("初始化网络失败\n");
        //初始化失败，点亮 2 个LED灯
        led_on(0);
        led_on(1);
    }

    //初始化链表
    ret = InitLink();
    if (FAILURE == ret)
    {
        printf("链表初始化失败\n");
        exit(1);
    }

    //初始化共享内存
    ret = InitShm();
    if (FAILURE == ret)
    {
        printf("共享内存初始化失败\n");
        exit(1);
    }

    //读取音乐
    GetMusic();

    //捕获ctrl c信号
    signal(SIGINT, handler);

    m_select();

    return 0;
}

六、main.h

#ifndef MAIN_H
#define MAIN_H

#define SUCCESS     10000
#define FAILURE     10001

#endif

七、player.c

#include <stdio.h>
#include "link.h"
#include "main.h"
#include <sys/types.h>
#include <dirent.h>
#include <stdlib.h>
#include "player.h"
#include <sys/ipc.h>
#include <sys/shm.h>
#include <unistd.h>
#include <sys/wait.h>
#include <string.h>
#include <signal.h>
#include <sys/ioctl.h>
#include <linux/soundcard.h>

extern int g_mixerfd;
extern Node *head;
void *g_addr = NULL;      //共享内存映射地址
int shmid;

int g_start_flag = 0;     //表示没有开始播放音乐
int g_suspend_flag = 0;   //表示没有暂停

int iLeft = 20;
int iRight = 60;

int InitShm()
{
    //创建共享内存
    shmid = shmget(SHMKEY, SHMSIZE, IPC_CREAT | IPC_EXCL);
    if (-1 == shmid)
    {
        return FAILURE;
    }

    //映射
    g_addr = shmat(shmid, NULL, 0);
    if (NULL == g_addr)
    {
        return FAILURE;
    }

    //初始化共享内存数据
    shm s;
    s.play_mode = SEQUENCEMODE;
    s.ppid = getpid();
    memcpy(g_addr, &s, sizeof(s));

    return SUCCESS;
}

//判断是不是.mp3结尾
int m_mp3_end(const char *name)
{
    const char *ptr = name;

    while (*ptr != '\0')
    {
        ptr++;
    }
    int i;
    for (i = 0; i < 4; i++)
    {
        ptr--;
    }
    
    if (ptr < name)
        return 0;
    
    return (strcmp(ptr, ".mp3") == 0) ? 1 : 0;
}

void GetMusic()
{
    //打开目录
    DIR *dir = opendir(MUSICPATH);
    if (NULL == dir)
    {
        perror("opendir");
        exit(1);
    }

    struct dirent *file = NULL;

    //读取目录
    while ((file = readdir(dir)) != NULL)
    {
        if (file->d_type != 8)      //不是普通文件
        {
            continue;
        }

        if (!m_mp3_end(file->d_name))   //不是mp3文件
        {
            continue;
        }

        printf("%s\n", file->d_name);

        int ret = InsertLink(head, file->d_name);
        if (FAILURE == ret)
        {
            printf("歌曲插入失败\n");
            exit(1);
        }
    }
}

void play_music(const char *name)
{
    pid_t child_pid = fork();
    if (-1 == child_pid)
    {
        perror("fork");
        exit(1);
    }
    else if (0 == child_pid)         //子进程
    {
        while (1)
        {
            pid_t grand_pid = vfork();
            if (-1 == grand_pid)
            {
                perror("fork");
                exit(1);
            }
            else if (0 == grand_pid)    //孙进程
            {
                char cur_name[64] = {0};
                shm s;

                //获取共享内存
                int shmid = shmget(SHMKEY, SHMSIZE, 0);
                if (-1 == shmid)
                {
                    perror("shmget");
                    exit(1);
                }

                //映射
                void *addr = shmat(shmid, NULL, 0);
                if (NULL == addr)
                {
                    perror("shmat");
                    exit(1);
                }

                if (strlen(name) != 0)      //直接开始播放
                {
                    strcpy(cur_name, name);    
                }
                else                        //遍历链表，找到一首歌播放
                {
                    //判断播放模式，找到一首歌曲
                    memcpy(&s, addr, sizeof(s));
                    FindNextMusic(s.cur_name, s.play_mode, cur_name);
                }

                //把信息写入共享内存（父子孙进程号、当前歌曲名）
                memcpy(&s, addr, sizeof(s));
                strcpy(s.cur_name, name);
                s.child_pid = getppid();
                s.grand_pid = getpid();
                memcpy(addr, &s, sizeof(s));
                shmdt(addr);           //解除映射

                char music_path[128] = {0};     //包含路径的歌曲名称
                strcpy(music_path, MUSICPATH);
                strcat(music_path, cur_name);
                printf("歌曲名字 %s\n", music_path);
                //execl("/usr/local/bin/madplay", "madplay", music_path, NULL);
                execl("/bin/madplay", "madplay", music_path, NULL);
            }
            else                        //子进程
            {
                memset((void *)name, 0, strlen(name));         //歌曲名长度变为0，方便下一次操作

                int status;
                waitpid(grand_pid, &status, 0);        //回收孙进程
            }
        }
    }
    else
    {
        return;
    }
}

void start_play()
{
    if (g_start_flag == 1)     //已经开始播放
    {
        return;
    }

    //获取歌曲名称
    if (head->next == NULL)    //空链表
    {
        return;
    }

    //设置音量
    int iLevel;
    iLeft = 80;
    iLevel = (iRight << 8) + iLeft;
    ioctl(g_mixerfd, MIXER_WRITE(SOUND_MIXER_VOLUME), &iLevel);

    //开始播放音乐
    //play_music(head->next->music_name);
    //play_music函数中会把head->next->music_name字符串清空修改成
    char name[128] = {0};
    strcpy(name, head->next->music_name);
    play_music(name);
    
    g_start_flag = 1;
}

void stop_play()
{
    if (g_start_flag == 0)
    {
        return;
    }

    //读取共享内存，获取pid
    shm s;
    memset(&s, 0, sizeof(s));
    memcpy(&s, g_addr, sizeof(s));

    //kill(s.grand_pid, SIGKILL);    //结束子进程
    //kill(s.child_pid, SIGKILL);    //结束孙进程
    
    kill(s.child_pid, SIGKILL);      //结束子进程
    kill(s.grand_pid, SIGKILL);      //结束孙进程
    
    g_start_flag = 0;
}

void suspend_play()
{
    if (g_start_flag == 0 || g_suspend_flag == 1)
    {
        return;
    }

    //读取共享内存，获取pid
    shm s;
    memset(&s, 0, sizeof(s));
    memcpy(&s, g_addr, sizeof(s));

    kill(s.grand_pid, SIGSTOP);     //暂停孙进程
    kill(s.child_pid, SIGSTOP);     //暂停子进程

    g_suspend_flag = 1;
}

void continue_play()
{
    if (g_start_flag == 0 || g_suspend_flag == 0)
    {
        return;
    }

    //读取共享内存，获取pid
    shm s;
    memset(&s, 0, sizeof(s));
    memcpy(&s, g_addr, sizeof(s));

    kill(s.grand_pid, SIGCONT);     //暂停孙进程
    kill(s.child_pid, SIGCONT);     //暂停子进程

    g_suspend_flag = 0;
}

void prior_play()
{
    if (g_start_flag == 0 || g_suspend_flag == 1)
    {
        return;
    }

    //读取共享内存，获取pid
    shm s;
    memset(&s, 0, sizeof(s));
    memcpy(&s, g_addr, sizeof(s));

    //kill(s.grand_pid, SIGKILL);    //结束子进程
    //kill(s.child_pid, SIGKILL);    //结束孙进程
    
    kill(s.child_pid, SIGKILL);      //结束子进程
    kill(s.grand_pid, SIGKILL);      //结束孙进程

    g_start_flag = 0;

    char name[64] = {0};
    PriorMusic(s.cur_name, s.play_mode, name);
    play_music(name);    
    g_start_flag = 1;
}

void next_play()
{
    if (g_start_flag == 0 || g_suspend_flag == 1)
    {
        return;
    }

    //读取共享内存，获取pid
    shm s;
    memset(&s, 0, sizeof(s));
    memcpy(&s, g_addr, sizeof(s));

    //kill(s.grand_pid, SIGKILL);    //结束子进程
    //kill(s.child_pid, SIGKILL);    //结束孙进程
    
    kill(s.child_pid, SIGKILL);      //结束子进程
    kill(s.grand_pid, SIGKILL);      //结束孙进程

    g_start_flag = 0;

    char name[64] = {0};
    NextMusic(s.cur_name, s.play_mode, name);
    play_music(name);    
    g_start_flag = 1;
}


void voice_up()
{
    int iLevel;

    if (iLeft < 100)
    {
        iLeft += 5;
    }

    iLevel = (iRight << 8) + iLeft;
    ioctl(g_mixerfd, MIXER_WRITE(SOUND_MIXER_VOLUME), &iLevel);
}

void voice_down()
{
    int iLevel;

    if (iLeft > 5)
    {
        iLeft -= 5;
    }

    iLevel = (iRight << 8) + iLeft;
    ioctl(g_mixerfd, MIXER_WRITE(SOUND_MIXER_VOLUME), &iLevel);
}

void set_mode(int mode)
{
    shm s;

    memset(&s, 0, sizeof(s));
    memcpy(&s, g_addr, sizeof(s));

    s.play_mode = mode;

    memcpy(g_addr, &s, sizeof(s));
    printf("模式修改成功!\n");
}

八、player.h

#ifndef PLAYER_H
#define PLAYER_H

#include <unistd.h>

//#define MUSICPATH   "/root/music_list/"
#define MUSICPATH   "/mount/usb/"
#define SHMKEY     1234
#define SHMSIZE    4096

#define SEQUENCEMODE    1
#define RANDOM          2
#define CIRCLE          3

//共享内存数据
struct shm
{
    int play_mode;
    char cur_name[64];
    pid_t ppid;
    pid_t child_pid;
    pid_t grand_pid;
};
typedef struct shm shm;

int InitShm();
void GetMusic();
void start_play();
void stop_play();
void suspend_play();
void continue_play();
void prior_play();
void next_play();
void voice_up();
void voice_down();
void set_mode(int mode);


#endif

九、select.c

#include <stdio.h>
#include <sys/select.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
#include "player.h"
//#include <json-c/json.h>
#include <json/json.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include "socket.h"
#include <errno.h>

extern int g_buttonfd;
extern int g_sockfd;
extern fd_set readfd;
extern fd_set tmpfd;
extern int g_maxfd;

void show()
{
    printf("1、开始播放\n");
    printf("2、结束播放\n");
    printf("3、暂停播放\n");
    printf("4、继续播放\n");
    printf("5、上一首\n");
    printf("6、下一首\n");
    printf("7、增加音量\n");
    printf("8、减小音量\n");
    printf("9、顺序播放\n");
    printf("a、随即播放\n");
    printf("b、单曲循环\n");
}

void parse_message(const char *m, char *c)
{
    struct json_object *obj = json_tokener_parse(m);

    struct json_object *json;
    //json_object_object_get_ex(obj, "cmd", &json);
    json = json_object_object_get(obj, "cmd");
    strcpy(c, json_object_get_string(json));
}

void InitSelect()
{
    FD_ZERO(&readfd);
    FD_ZERO(&tmpfd);
    FD_SET(g_buttonfd, &readfd);
}

void m_select()
{
    show();

    fd_set tmpfd;
    int ret;
    char message[1024] = {0};

    while (1)
    {
        tmpfd = readfd;
        ret = select(g_maxfd + 1, &tmpfd, NULL, NULL, NULL);
        if (-1 == ret && errno != EINTR)
        {
            perror("select");
        }
        else if (-1 == ret && errno == EINTR)
        {
            continue;
        }

        if (FD_ISSET(g_sockfd, &tmpfd))           //TCP有数据可读
        {
            memset(message, 0, sizeof(message));
            ret = recv(g_sockfd, message, sizeof(message), 0);
            if (-1 == ret)
            {
                perror("recv");
            }

            char cmd[64] = {0};
            parse_message(message, cmd);

            if (!strcmp(cmd, "start"))
            {
                socket_start_play();            
            }
            else if (!strcmp(cmd, "stop"))
            {
                socket_stop_play();
            }
            else if (!strcmp(cmd, "suspend"))
            {
                socket_suspend_play();
            }
            else if (!strcmp(cmd, "continue"))
            {
                socket_continue_play();
            }
            else if (!strcmp(cmd, "prior"))
            {
                socket_prior_play();
            }
            else if (!strcmp(cmd, "next"))
            {
                socket_next_play();
            }
            else if (!strcmp(cmd, "voice_up"))
            {
                socket_voice_up_play();
            }
            else if (!strcmp(cmd, "voice_down"))
            {
                socket_voice_down_play();
            }
            else if (!strcmp(cmd, "sequence"))
            {
                socket_mode_play(SEQUENCEMODE);
            }
            else if (!strcmp(cmd, "random"))
            {
                socket_mode_play(RANDOM);
            }
            else if (!strcmp(cmd, "circle"))
            {
                socket_mode_play(CIRCLE);
            }
            else if (!strcmp(cmd, "get"))     //获取状态
            {    
                socket_get_status();
            }
            else if (!strcmp(cmd, "music"))   //获取所有音乐
            {
                socket_get_music();                                
            }
        }
        else if (FD_ISSET(g_buttonfd, &tmpfd))    //按键有数据可读
        {
            int id = get_key_id();
            switch (id)
            {
                case 1:
                    start_play();
                    break;
                case 2:
                    stop_play();
                    break;
                case 3:
                    suspend_play();
                    break;
                case 4:
                    continue_play();
                    break;
                case 5:
                    prior_play();
                    break;
                case 6:
                    next_play();
                    break;
            }
        }
    }
}

十、socket.c

//跟网络相关的代码

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include "main.h"
#include <pthread.h>
#include <string.h>
#include <unistd.h>
#include "device.h"
#include "socket.h"
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <signal.h>
//#include <json-c/json.h>
#include <json/json.h>
#include "player.h"
#include <sys/select.h>
#include "link.h"

extern Node *head;
extern int g_sockfd;
extern int iLeft;
extern int g_start_flag;
extern int g_suspend_flag;
extern fd_set readfd;
extern int g_maxfd;
extern void *g_addr;

//5秒执行一次，向服务器发送 alive 字符串
void send_server(int sig)
{
    struct json_object *json = json_object_new_object();
    json_object_object_add(json, "cmd", json_object_new_string("info"));
    json_object_object_add(json, "status", json_object_new_string("alive"));
    json_object_object_add(json, "deviceid", json_object_new_string("001"));

    const char *buf = json_object_to_json_string(json);
    int ret = send(g_sockfd, buf, strlen(buf), 0);
    if (-1 == ret)
    {
        perror("send");
    }

    alarm(TIMEOUT);
}

void *connect_cb(void *arg)
{
    int count = 5, ret;
    struct sockaddr_in server_addr;

    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = PF_INET;
    server_addr.sin_port = htons(SERVER_PORT);
    server_addr.sin_addr.s_addr = inet_addr(SERVER_IP);

    while (count--)
    {
        ret = connect(g_sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr));
        if (ret == -1)
        {
            sleep(5);
            continue;
        }
        
        //连接成功，点亮 4 个LED灯
        led_on(0);
        led_on(1);
        led_on(2);
        led_on(3);

        alarm(TIMEOUT);
        signal(SIGALRM, send_server);

        //连接服务器成功，fd添加到集合
        FD_SET(g_sockfd, &readfd);
        if (g_maxfd < g_sockfd)
        {
            g_maxfd = g_sockfd;
        }

        break;
    }

    return NULL;
}

int InitSocket()
{
    g_sockfd = socket(PF_INET, SOCK_STREAM, 0);
    if (-1 == g_sockfd)
    {
        return FAILURE;
    }

    //启动线程向服务器发起连接
    pthread_t tid;
    int ret = pthread_create(&tid, NULL, connect_cb, NULL);
    if (ret != 0)
    {
        return FAILURE;
    }

    return SUCCESS;
}

void socket_start_play()
{
    start_play();

    struct json_object *json = json_object_new_object();
    json_object_object_add(json, "cmd", json_object_new_string("reply"));
    json_object_object_add(json, "result", json_object_new_string("start_success"));

    const char *buf = json_object_to_json_string(json);
    int ret = send(g_sockfd, buf, strlen(buf), 0);
    if (-1 == ret)
    {
        perror("send");
    }
}

void socket_stop_play()
{
    stop_play();

    struct json_object *json = json_object_new_object();
    json_object_object_add(json, "cmd", json_object_new_string("reply"));
    json_object_object_add(json, "result", json_object_new_string("stop_success"));

    const char *buf = json_object_to_json_string(json);
    int ret = send(g_sockfd, buf, strlen(buf), 0);
    if (-1 == ret)
    {
        perror("send");
    }
}

void socket_suspend_play()
{
    suspend_play();

    struct json_object *json = json_object_new_object();
    json_object_object_add(json, "cmd", json_object_new_string("reply"));
    json_object_object_add(json, "result", json_object_new_string("suspend_success"));

    const char *buf = json_object_to_json_string(json);
    int ret = send(g_sockfd, buf, strlen(buf), 0);
    if (-1 == ret)
    {
        perror("send");
    }
}

void socket_continue_play()
{
    continue_play();

    struct json_object *json = json_object_new_object();
    json_object_object_add(json, "cmd", json_object_new_string("reply"));
    json_object_object_add(json, "result", json_object_new_string("continue_success"));

    const char *buf = json_object_to_json_string(json);
    int ret = send(g_sockfd, buf, strlen(buf), 0);
    if (-1 == ret)
    {
        perror("send");
    }
}

void socket_prior_play()
{
    prior_play();

    struct json_object *json = json_object_new_object();
    json_object_object_add(json, "cmd", json_object_new_string("reply"));
    json_object_object_add(json, "result", json_object_new_string("success"));

    const char *buf = json_object_to_json_string(json);
    int ret = send(g_sockfd, buf, strlen(buf), 0);
    if (-1 == ret)
    {
        perror("send");
    }
}

void socket_next_play()
{
    next_play();

    struct json_object *json = json_object_new_object();
    json_object_object_add(json, "cmd", json_object_new_string("reply"));
    json_object_object_add(json, "result", json_object_new_string("success"));

    const char *buf = json_object_to_json_string(json);
    int ret = send(g_sockfd, buf, strlen(buf), 0);
    if (-1 == ret)
    {
        perror("send");
    }
}

void socket_voice_up_play()
{
    voice_up();

    struct json_object *json = json_object_new_object();
    json_object_object_add(json, "cmd", json_object_new_string("reply"));
    json_object_object_add(json, "result", json_object_new_string("success"));

    const char *buf = json_object_to_json_string(json);
    int ret = send(g_sockfd, buf, strlen(buf), 0);
    if (-1 == ret)
    {
        perror("send");
    }
}

void socket_voice_down_play()
{
    voice_down();

    struct json_object *json = json_object_new_object();
    json_object_object_add(json, "cmd", json_object_new_string("reply"));
    json_object_object_add(json, "result", json_object_new_string("success"));

    const char *buf = json_object_to_json_string(json);
    int ret = send(g_sockfd, buf, strlen(buf), 0);
    if (-1 == ret)
    {
        perror("send");
    }
}

void socket_mode_play(int mode)
{
    set_mode(mode);

    struct json_object *json = json_object_new_object();
    json_object_object_add(json, "cmd", json_object_new_string("reply"));
    json_object_object_add(json, "result", json_object_new_string("success"));

    const char *buf = json_object_to_json_string(json);
    int ret = send(g_sockfd, buf, strlen(buf), 0);
    if (-1 == ret)
    {
        perror("send");
    }
}

void socket_get_status()
{
    //播放状态  当前歌曲名  音量
    struct json_object *json = json_object_new_object();
    json_object_object_add(json, "cmd", json_object_new_string("reply_status"));
    if (g_start_flag == 1 && g_suspend_flag == 0)
    {
        json_object_object_add(json, "status", json_object_new_string("start"));
    }
    else if (g_start_flag == 1 && g_suspend_flag == 1)
    {
        json_object_object_add(json, "status", json_object_new_string("suspend"));
    }
    else if (g_start_flag == 0)
    {
        json_object_object_add(json, "status", json_object_new_string("stop"));
    }
    json_object_object_add(json, "voice", json_object_new_int(iLeft));

    shm s;
    memset(&s, 0, sizeof(s));
    memcpy(&s, g_addr, sizeof(s));
    json_object_object_add(json, "music", json_object_new_string(s.cur_name));

    const char *buf = json_object_to_json_string(json);
    int ret = send(g_sockfd, buf, strlen(buf), 0);
    if (-1 == ret)
    {
        perror("send");
    }
}

void socket_get_music()
{
    struct json_object *json = json_object_new_object();
    json_object_object_add(json, "cmd", json_object_new_string("reply_music"));

    struct json_object *array = json_object_new_array();
    Node *p = head->next;
    while (p != head)
    {
        json_object_array_add(array, json_object_new_string(p->music_name));
        p = p->next;
    }

    json_object_object_add(json, "music", array);

    const char *buf = json_object_to_json_string(json);
    int ret = send(g_sockfd, buf, strlen(buf), 0);
    if (-1 == ret)
    {
        perror("send");
    }
}

十一、socket.h

#ifndef SOCKET_H
#define SOCKET_H

#define SERVER_PORT   8000
#define SERVER_IP     "47.101.128.140"
//#define SERVER_IP    "127.0.0.1"
#define TIMEOUT       1

int InitSocket();
void socket_start_play();
void socket_stop_play();
void socket_suspend_play();
void socket_continue_play();
void socket_prior_play();
void socket_next_play();
void socket_voice_up_play();
void socket_voice_down_play();
void socket_mode_play(int);
void socket_get_status();
void socket_get_music();

#endif

学习我是拒绝的
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
NodeMCU ESP8266 读取按键外部输入信号详解（图文并茂）
一名热爱技术的工程师的博客。分享技术干货，记录美好生活。永远相信美好的事情即将发生。
10-19 3032
ESP8266如何检测外部信号的输入，通常可以检测到TTL电平的高电平和低电平。如何检测呢？
基于mini2440的按键驱动编写总结
05-20
在Linux系统中，驱动程序是操作系统与硬件交互的桥梁，对于基于S3C2440平台的mini2440开发板来说，编写按键驱动是实现用户与系统交互的关键步骤。本文主要针对如何编写基于mini2440的按键驱动进行总结。 首先，驱动...
mini2440按键驱动程序分析
Yfw的博客
10-11 176
先说明一下按键与S3C2440芯片的连接方式： KEY1 <----> EINT8 <----> GPG0 KEY2 <----> EINT11 <----> GPG3 KEY3 <----> EINT13 <----> GPG5 KEY4 <----> EINT14 <----> GPG6 KEY5 ...
mini2440按键驱动分析
wudong_2012的专栏
03-14 618
buttonstructfileuserlist工作 DECLARE_WAIT_QUEUE_HEAD(name) -- 生成一个等待队列头 DECLARE_WAIT_QUEUE_HEAD(name) -- 生成一个等待队列头wait_queue_head_t,名字为name -----------------------------------------------------------
mini2440按键中断
峰升的专栏
02-28 876
ARM中断控制系统 按键驱动程序设计 一．Arm中断控制系统 1.查询方式 程序不断地查询设备的状态，并做出相应的反应。该方式实现比较简单，常用在比较单一的系统中，比如：一个温控系统中可以实用查询的方式不断检测温度变化。 特点：实现简单；但CPU利用率很低，不适合多任务的系统。 2.中断方式 当事件发生时，硬件会设置某个寄存器；CPU在每执行完一个指令时，查看这个寄存器，如果所关注的
MINI2440按键中断
yuzeze的专栏
04-18 398
编写按键驱动的方法很多，这里我仅仅列举用中断法加上简单地字符设备注册来编写，并没有采用misc设备来注册。(这里的注册函数都是相对古老，以后不推荐使用！)首先编写一个设备驱动程序头文件先定义了，这很容易，照搬别人的就行了。接着确定你的设备驱动程序会用到的数据结构，这里会用到一个重要的数据结构，struct button_irqs，用来表征按键的状态以及按键的标识。接着确定file_operat
Linux input按键设备驱动
Frake的博客
03-31 1755
本文基于mini2440开发板，Linux版本号是：linux-2.6.32.2 一. input模块的注册 input模块被当成了一个字符设备，注册到内核中。 #define INPUT_MAJOR 13 static int __init input_init(void) { int err; err = register_chrdev(INPUT_MAJOR, "input"...
mini2440裸机之按键（1）
dfl448866的专栏
04-08 295
1 了解基本的硬件连接 2 按键进行扫描方式操作 1） 按键gpio输入模式上拉输入 2) 按键进行消抖处理 gpio相关寄存器的功能描述 <1> 端口配置寄存器（GPACON 至GPJCON） S3C2440A 中，大多数端口为复用引脚。因此要决定每个引脚选择哪项功能。PnCON（引脚控制寄存器）决 定了每个引脚使用哪项功能。如果在掉电模式中PE0 至PE7 用于...
mini2440按键驱动及详细解释（转）
shangyaowei的专栏
12-19 369
mini2440按键驱动及详细解释（转） 经过为期一周左右的时间，参考《linux设备驱动开发详解》把mini2440开发板的按键驱动完成了。   程序可以分成两部分来看： 第一部分：按键侦测，主要包括中断的初始化、中断处理、按键去抖、等待按键松开，侦测 完成返回按键键值。 第二部分：按键事件处理，主要包括，将案件事件保存至循环链表（其实就是一个数组，可 以循环保存数据）、将
mini2440 基于中断的按键驱动
wjflyhigh的专栏
04-26 667
Mini2440 具有6 个用户测试按键，它们都是连接到CPU 的中断引脚。在/linux-2.6.32.2/drivers/char/目录下创建一个新的驱动程序文件mini2440_buttons.c #include #include #include #include #include #include #include #include #includ
key_led.tar.gz_mini2440_mini2440按键 LED_mini2440按键+LED
09-22
总结来说，"key_led.tar.gz_mini2440_mini2440按键_LED_mini2440按键+led"这个压缩包文件很可能包含了实现上述功能的源代码和文档。通过这个实验，开发者可以学习到嵌入式系统中的基本输入输出操作，以及如何利用S3C...
mini2440按键
03-30
标题中的“mini2440按键”指的是在该开发板上使用按键进行交互操作。描述提到的是“mini2440按键中断”，这涉及到中断机制在嵌入式系统中的应用，尤其是与按键事件处理相关的中断服务程序。 在嵌入式系统中，按键...
mini2440/micor2440按键中断代码
10-11
ISR负责处理按键中断事件，可能包括读取按键状态、清除中断标志、更新计数器或者触发其他系统行为。 3. **按键检测**：在ISR中，通过读取GPIO（General Purpose Input/Output）端口状态来判断哪个按键被按下。S3C...
mini2440驱动例程-中断按键检测
10-15
在这个“mini2440驱动例程-中断按键检测”示例中，我们主要关注的是如何利用中断机制来实现对硬件按键的实时检测。 Mini2440是一款基于Samsung S3C2440处理器的开发板，广泛应用于嵌入式系统的教学和研发。S3C2440...
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
qq_43700885的博客
07-29 602
1.导入hutool的maven依赖。2.复制一下代码执行。
深入理解Java注解
最新发布
weixin_55745942的博客
08-01 559
Java注解是用来描述程序元素（如类、方法、变量等）的一种机制。它们可以提供关于程序的补充信息，帮助编译器、框架或其他工具更好地理解和处理代码。注解通常以符号开头，后跟注解名称和可能的参数。要创建自定义注解，需要使用@interface关键字定义一个接口，并在接口中声明注解的属性。这个注解名为，可以被用来标记方法。它有一个名为value的属性，具有默认值"default"。
社区养老服务小程序的设计
Karen198的博客
07-31 515
管理员账户功能包括：系统首页，个人中心，用户管理，服务人员管理，服务产品管理，服务预约管理，服务状态管理，服务退订管理，活动管理，视频管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。服务器：SpringBoot自带 apache tomcat。微信端账号功能包括：系统首页，服务产品，活动，视频，我的。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。
JavaSE面向对象进阶
qq_45348840的博客
07-30 478
需求：在实际开发中，经常会遇到一些数组使用的工具类;请按照如下要求编写一个数组的工具类：ArrayUtil提供一个工具类方法printArr,用于返回整数数组的内容。返回的字符串格式如：[10,20,50,34,100 ]（只考虑整数数组，且只考虑一维数组)提供这样一个工具方法getAerage,用于返回平均分。（只考虑浮点型数组，且只考虑一维数组)定义一个测试类TestDemo,调用该工具类的工具方法，并返回结果。// 私有化构造方法// 定义静态方法，方便调用。i++) {
MINI2440按键驱动程序解析
MINI2440按键驱动的实现涉及了S3C2440处理器的GPIO中断机制、内核中断处理、字符设备驱动以及用户空间的交互。理解这些知识点有助于开发者编写出高效、可靠的按键驱动程序。在实际开发中，还需要结合具体的电路原理...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值